qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/circuit/library/blueprintcircuit.py

@@ -0,0 +1,322 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Blueprint circuit object."""
+
+from __future__ import annotations
+from abc import ABC, abstractmethod
+import copy as _copy
+
+from qiskit._accelerate.circuit import CircuitData
+from qiskit.circuit import QuantumRegister, ClassicalRegister
+from qiskit.circuit.parametertable import ParameterView
+from qiskit.circuit.quantumcircuit import QuantumCircuit, _copy_metadata
+from qiskit.utils.deprecation import deprecate_func
+
+
+class BlueprintCircuit(QuantumCircuit, ABC):
+    """Blueprint circuit object.
+
+    In many applications it is necessary to pass around the structure a circuit will have without
+    explicitly knowing e.g. its number of qubits, or other missing information. This can be solved
+    by having a circuit that knows how to construct itself, once all information is available.
+
+    This class provides an interface for such circuits. Before internal data of the circuit is
+    accessed, the ``_build`` method is called. There the configuration of the circuit is checked.
+    """
+
+    @deprecate_func(
+        since="2.1",
+        additional_msg="There is no direct replacement other than the QuantumCircuit class.",
+        removal_timeline="in Qiskit 3.0",
+    )
+    def __init__(self, *regs, name: str | None = None) -> None:
+        """Create a new blueprint circuit."""
+        self._is_initialized = False
+        super().__init__(*regs, name=name)
+        self._qregs: list[QuantumRegister] = []
+        self._cregs: list[ClassicalRegister] = []
+        self._is_built = False
+        self._is_initialized = True
+
+    @abstractmethod
+    def _check_configuration(self, raise_on_failure: bool = True) -> bool:
+        """Check if the current configuration allows the circuit to be built.
+
+        Args:
+            raise_on_failure: If True, raise if the configuration is invalid. If False, return
+                False if the configuration is invalid.
+
+        Returns:
+            True, if the configuration is valid. Otherwise, depending on the value of
+            ``raise_on_failure`` an error is raised or False is returned.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def _build(self) -> None:
+        """Build the circuit."""
+        if self._is_built:
+            return
+
+        # check whether the configuration is valid
+        self._check_configuration()
+        self._is_built = True
+
+    def _invalidate(self) -> None:
+        """Invalidate the current circuit build."""
+        # Take out the registers before invalidating
+        qregs = self._data.qregs
+        cregs = self._data.cregs
+        self._data = CircuitData(self._data.qubits, self._data.clbits)
+        # Re-add the registers
+        for qreg in qregs:
+            self._data.add_qreg(qreg)
+        for creg in cregs:
+            self._data.add_creg(creg)
+        self.global_phase = 0
+        self._is_built = False
+
+    @property
+    def qregs(self):
+        """A list of the quantum registers associated with the circuit."""
+        if not self._is_initialized:
+            return self._qregs
+        return super().qregs
+
+    @qregs.setter
+    def qregs(self, qregs):
+        """Set the quantum registers associated with the circuit."""
+        if not self._is_initialized:
+            # Workaround to ignore calls from QuantumCircuit.__init__() which
+            # doesn't expect 'qregs' to be an overridden property!
+            return
+        self._qregs = []
+        self._ancillas = []
+        self._data = CircuitData(clbits=self._data.clbits)
+        self.global_phase = 0
+        self._is_built = False
+
+        self.add_register(*qregs)
+
+    @property
+    def data(self):
+        """The circuit data (instructions and context).
+
+        Returns:
+            QuantumCircuitData: a list-like object containing the :class:`.CircuitInstruction`\\ s
+            for each instruction.
+        """
+        if not self._is_built:
+            self._build()
+        return super().data
+
+    def decompose(self, gates_to_decompose=None, reps=1):
+        if not self._is_built:
+            self._build()
+        return super().decompose(gates_to_decompose, reps)
+
+    def draw(self, *args, **kwargs):
+        if not self._is_built:
+            self._build()
+        return super().draw(*args, **kwargs)
+
+    @property
+    def num_parameters(self) -> int:
+        """The number of parameter objects in the circuit."""
+        if not self._is_built:
+            self._build()
+        return super().num_parameters
+
+    @property
+    def parameters(self) -> ParameterView:
+        """The parameters defined in the circuit.
+
+        This attribute returns the :class:`.Parameter` objects in the circuit sorted
+        alphabetically. Note that parameters instantiated with a :class:`.ParameterVector`
+        are still sorted numerically.
+
+        Examples:
+
+            The snippet below shows that insertion order of parameters does not matter.
+
+            .. code-block:: python
+
+                >>> from qiskit.circuit import QuantumCircuit, Parameter
+                >>> a, b, elephant = Parameter("a"), Parameter("b"), Parameter("elephant")
+                >>> circuit = QuantumCircuit(1)
+                >>> circuit.rx(b, 0)
+                >>> circuit.rz(elephant, 0)
+                >>> circuit.ry(a, 0)
+                >>> circuit.parameters  # sorted alphabetically!
+                ParameterView([Parameter(a), Parameter(b), Parameter(elephant)])
+
+            Bear in mind that alphabetical sorting might be unintuitive when it comes to numbers.
+            The literal "10" comes before "2" in strict alphabetical sorting.
+
+            .. code-block:: python
+
+                >>> from qiskit.circuit import QuantumCircuit, Parameter
+                >>> angles = [Parameter("angle_1"), Parameter("angle_2"), Parameter("angle_10")]
+                >>> circuit = QuantumCircuit(1)
+                >>> circuit.u(*angles, 0)
+                >>> circuit.draw()
+                   ┌─────────────────────────────┐
+                q: ┤ U(angle_1,angle_2,angle_10) ├
+                   └─────────────────────────────┘
+                >>> circuit.parameters
+                ParameterView([Parameter(angle_1), Parameter(angle_10), Parameter(angle_2)])
+
+            To respect numerical sorting, a :class:`.ParameterVector` can be used.
+
+            .. code-block:: python
+
+                >>> from qiskit.circuit import QuantumCircuit, Parameter, ParameterVector
+                >>> x = ParameterVector("x", 12)
+                >>> circuit = QuantumCircuit(1)
+                >>> for x_i in x:
+                ...     circuit.rx(x_i, 0)
+                >>> circuit.parameters
+                ParameterView([
+                    ParameterVectorElement(x[0]), ParameterVectorElement(x[1]),
+                    ParameterVectorElement(x[2]), ParameterVectorElement(x[3]),
+                    ..., ParameterVectorElement(x[11])
+                ])
+
+
+        Returns:
+            The sorted :class:`.Parameter` objects in the circuit.
+        """
+        if not self._is_built:
+            self._build()
+        return super().parameters
+
+    def _append(self, instruction, _qargs=None, _cargs=None, *, _standard_gate=False):
+        if not self._is_built:
+            self._build()
+        return super()._append(instruction, _qargs, _cargs, _standard_gate=_standard_gate)
+
+    def compose(
+        self,
+        other,
+        qubits=None,
+        clbits=None,
+        front=False,
+        inplace=False,
+        wrap=False,
+        *,
+        copy=True,
+        var_remap=None,
+        inline_captures=False,
+    ):
+        if not self._is_built:
+            self._build()
+        return super().compose(
+            other,
+            qubits,
+            clbits,
+            front,
+            inplace,
+            wrap,
+            copy=copy,
+            var_remap=var_remap,
+            inline_captures=False,
+        )
+
+    def inverse(self, annotated: bool = False):
+        if not self._is_built:
+            self._build()
+        return super().inverse(annotated=annotated)
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, item):
+        return self.data[item]
+
+    def size(self, *args, **kwargs):
+        if not self._is_built:
+            self._build()
+        return super().size(*args, **kwargs)
+
+    def to_instruction(self, parameter_map=None, label=None):
+        if not self._is_built:
+            self._build()
+        return super().to_instruction(parameter_map, label=label)
+
+    def to_gate(self, parameter_map=None, label=None):
+        if not self._is_built:
+            self._build()
+        return super().to_gate(parameter_map, label=label)
+
+    def depth(self, *args, **kwargs):
+        if not self._is_built:
+            self._build()
+        return super().depth(*args, **kwargs)
+
+    def count_ops(self):
+        if not self._is_built:
+            self._build()
+        return super().count_ops()
+
+    def num_nonlocal_gates(self):
+        if not self._is_built:
+            self._build()
+        return super().num_nonlocal_gates()
+
+    def num_connected_components(self, unitary_only=False):
+        if not self._is_built:
+            self._build()
+        return super().num_connected_components(unitary_only=unitary_only)
+
+    def copy_empty_like(
+        self, name: str | None = None, *, vars_mode: str = "alike"
+    ) -> QuantumCircuit:
+        """Return an empty :class:`.QuantumCircuit` of same size and metadata.
+
+        See also :meth:`.QuantumCircuit.copy_empty_like` for more details on copied metadata.
+
+        Args:
+            name: Name for the copied circuit. If None, then the name stays the same.
+            vars_mode: The mode to handle realtime variables in.
+
+        Returns:
+            An empty circuit of same dimensions. Note that the result is no longer a
+            :class:`.BlueprintCircuit`.
+        """
+
+        cpy = QuantumCircuit(*self.qregs, *self.cregs, name=name, global_phase=self.global_phase)
+        _copy_metadata(self, cpy, vars_mode)
+        return cpy
+
+    def copy(self, name: str | None = None) -> BlueprintCircuit:
+        """Copy the blueprint circuit.
+
+        Args:
+            name: Name to be given to the copied circuit. If None, then the name stays the same.
+
+        Returns:
+            A deepcopy of the current blueprint circuit, with the specified name.
+        """
+        if not self._is_built:
+            self._build()
+
+        cpy = _copy.copy(self)
+        _copy_metadata(self, cpy, "alike")
+
+        cpy._is_built = self._is_built
+        cpy._data = self._data.copy()
+
+        if name is not None:
+            cpy.name = name
+
+        return cpy

qiskit/circuit/library/boolean_logic/__init__.py

@@ -0,0 +1,18 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""The Boolean logic circuit library."""
+
+from .quantum_and import AND, AndGate
+from .quantum_or import OR, OrGate
+from .quantum_xor import XOR, BitwiseXorGate, random_bitwise_xor
+from .inner_product import InnerProduct, InnerProductGate

qiskit/circuit/library/boolean_logic/inner_product.py

@@ -0,0 +1,157 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020, 2024.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+
+"""InnerProduct circuit and gate."""
+
+
+from qiskit.circuit import QuantumRegister, QuantumCircuit, Gate
+from qiskit.utils.deprecation import deprecate_func
+
+
+class InnerProduct(QuantumCircuit):
+    r"""A 2n-qubit Boolean function that computes the inner product of
+    two n-qubit vectors over :math:`F_2`.
+
+    This implementation is a phase oracle which computes the following transform.
+
+    .. math::
+
+        \mathcal{IP}_{2n} : F_2^{2n} \rightarrow {-1, 1}
+        \mathcal{IP}_{2n}(x_1, \cdots, x_n, y_1, \cdots, y_n) = (-1)^{x.y}
+
+    The corresponding unitary is a diagonal, which induces a -1 phase on any inputs
+    where the inner product of the top and bottom registers is 1. Otherwise it keeps
+    the input intact.
+
+    .. code-block:: text
+
+
+        q0_0: ─■──────────
+               │
+        q0_1: ─┼──■───────
+               │  │
+        q0_2: ─┼──┼──■────
+               │  │  │
+        q0_3: ─┼──┼──┼──■─
+               │  │  │  │
+        q1_0: ─■──┼──┼──┼─
+                  │  │  │
+        q1_1: ────■──┼──┼─
+                     │  │
+        q1_2: ───────■──┼─
+                        │
+        q1_3: ──────────■─
+
+
+    Reference Circuit:
+        .. plot::
+           :alt: Diagram illustrating the previously described circuit.
+
+           from qiskit.circuit.library import InnerProduct
+           from qiskit.visualization.library import _generate_circuit_library_visualization
+           circuit = InnerProduct(4)
+           _generate_circuit_library_visualization(circuit)
+    """
+
+    @deprecate_func(
+        since="2.1",
+        additional_msg="Use qiskit.circuit.library.InnerProductGate instead.",
+        removal_timeline="in Qiskit 3.0",
+    )
+    def __init__(self, num_qubits: int) -> None:
+        """Return a circuit to compute the inner product of 2 n-qubit registers.
+
+        Args:
+            num_qubits: width of top and bottom registers (half total circuit width)
+        """
+        qr_a = QuantumRegister(num_qubits)
+        qr_b = QuantumRegister(num_qubits)
+        inner = QuantumCircuit(qr_a, qr_b, name="inner_product")
+
+        for i in range(num_qubits):
+            inner.cz(qr_a[i], qr_b[i])
+
+        super().__init__(*inner.qregs, name="inner_product")
+        self.compose(inner.to_gate(), qubits=self.qubits, inplace=True)
+
+
+class InnerProductGate(Gate):
+    r"""A 2n-qubit Boolean function that computes the inner product of
+    two n-qubit vectors over :math:`F_2`.
+
+    This implementation is a phase oracle which computes the following transform.
+
+    .. math::
+
+        \mathcal{IP}_{2n} : F_2^{2n} \rightarrow {-1, 1}
+        \mathcal{IP}_{2n}(x_1, \cdots, x_n, y_1, \cdots, y_n) = (-1)^{x.y}
+
+    The corresponding unitary is a diagonal, which induces a -1 phase on any inputs
+    where the inner product of the top and bottom registers is 1. Otherwise, it keeps
+    the input intact.
+
+    .. parsed-literal::
+
+
+        q0_0: ─■──────────
+               │
+        q0_1: ─┼──■───────
+               │  │
+        q0_2: ─┼──┼──■────
+               │  │  │
+        q0_3: ─┼──┼──┼──■─
+               │  │  │  │
+        q1_0: ─■──┼──┼──┼─
+                  │  │  │
+        q1_1: ────■──┼──┼─
+                     │  │
+        q1_2: ───────■──┼─
+                        │
+        q1_3: ──────────■─
+
+
+    Reference Circuit:
+        .. plot::
+           :alt: Diagram illustrating the previously described circuit.
+
+           from qiskit.circuit import QuantumCircuit
+           from qiskit.circuit.library import InnerProductGate
+           from qiskit.visualization.library import _generate_circuit_library_visualization
+           circuit = QuantumCircuit(8)
+           circuit.append(InnerProductGate(4), [0, 1, 2, 3, 4, 5, 6, 7])
+           _generate_circuit_library_visualization(circuit)
+    """
+
+    def __init__(
+        self,
+        num_qubits: int,
+    ) -> None:
+        """
+        Args:
+            num_qubits: width of top and bottom registers (half total number of qubits).
+        """
+        super().__init__("inner_product", 2 * num_qubits, [])
+
+    def _define(self):
+        num_qubits = self.num_qubits // 2
+        qr_a = QuantumRegister(num_qubits, name="x")
+        qr_b = QuantumRegister(num_qubits, name="y")
+
+        circuit = QuantumCircuit(qr_a, qr_b, name="inner_product")
+        for i in range(num_qubits):
+            circuit.cz(qr_a[i], qr_b[i])
+
+        self.definition = circuit
+
+    def __eq__(self, other):
+        return isinstance(other, InnerProductGate) and self.num_qubits == other.num_qubits

qiskit/circuit/library/boolean_logic/quantum_and.py

@@ -0,0 +1,204 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020, 2024.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+
+"""Boolean AND circuit and gate."""
+
+from __future__ import annotations
+
+from qiskit.circuit import QuantumRegister, QuantumCircuit, AncillaRegister, Gate
+from qiskit.circuit.library.standard_gates import MCXGate
+from qiskit.utils.deprecation import deprecate_func
+
+
+class AND(QuantumCircuit):
+    r"""A circuit implementing the logical AND operation on a number of qubits.
+
+    For the AND operation the state :math:`|1\rangle` is interpreted as ``True``. The result
+    qubit is flipped, if the state of all variable qubits is ``True``. In this format, the AND
+    operation equals a multi-controlled X gate, which is controlled on all variable qubits.
+    Using a list of flags however, qubits can be skipped or negated. Practically, the flags
+    allow to skip controls or to apply pre- and post-X gates to the negated qubits.
+
+    The AND gate without special flags equals the multi-controlled-X gate:
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+       from qiskit.circuit.library import AND
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       circuit = AND(5)
+       _generate_circuit_library_visualization(circuit)
+
+    Using flags we can negate qubits or skip them. For instance, if we have 5 qubits and want to
+    return ``True`` if the first qubit is ``False`` and the last two are ``True`` we use the flags
+    ``[-1, 0, 0, 1, 1]``.
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+       from qiskit.circuit.library import AND
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       circuit = AND(5, flags=[-1, 0, 0, 1, 1])
+       _generate_circuit_library_visualization(circuit)
+
+    """
+
+    @deprecate_func(
+        since="2.1",
+        additional_msg="Use qiskit.circuit.library.AndGate instead.",
+        removal_timeline="in Qiskit 3.0",
+    )
+    def __init__(
+        self,
+        num_variable_qubits: int,
+        flags: list[int] | None = None,
+        mcx_mode: str = "noancilla",
+    ) -> None:
+        """Create a new logical AND circuit.
+
+        Args:
+            num_variable_qubits: The qubits of which the AND is computed. The result will be written
+                into an additional result qubit.
+            flags: A list of +1/0/-1 marking negations or omissions of qubits.
+            mcx_mode: The mode to be used to implement the multi-controlled X gate.
+        """
+        self.num_variable_qubits = num_variable_qubits
+        self.flags = flags
+
+        # add registers
+        qr_variable = QuantumRegister(num_variable_qubits, name="variable")
+        qr_result = QuantumRegister(1, name="result")
+
+        circuit = QuantumCircuit(qr_variable, qr_result, name="and")
+
+        # determine the control qubits: all that have a nonzero flag
+        flags = flags or [1] * num_variable_qubits
+        control_qubits = [q for q, flag in zip(qr_variable, flags) if flag != 0]
+
+        # determine the qubits that need to be flipped (if a flag is < 0)
+        flip_qubits = [q for q, flag in zip(qr_variable, flags) if flag < 0]
+
+        # determine the number of ancillas
+        num_ancillas = MCXGate.get_num_ancilla_qubits(len(control_qubits), mode=mcx_mode)
+        if num_ancillas > 0:
+            qr_ancilla = AncillaRegister(num_ancillas, "ancilla")
+            circuit.add_register(qr_ancilla)
+        else:
+            qr_ancilla = AncillaRegister(0)
+
+        if len(flip_qubits) > 0:
+            circuit.x(flip_qubits)
+        circuit.mcx(control_qubits, qr_result[:], qr_ancilla[:], mode=mcx_mode)
+        if len(flip_qubits) > 0:
+            circuit.x(flip_qubits)
+
+        super().__init__(*circuit.qregs, name="and")
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)
+
+
+class AndGate(Gate):
+    r"""A gate representing the logical AND operation on a number of qubits.
+
+    For the AND operation the state :math:`|1\rangle` is interpreted as ``True``. The result
+    qubit is flipped, if the state of all variable qubits is ``True``. In this format, the AND
+    operation equals a multi-controlled X gate, which is controlled on all variable qubits.
+    Using a list of flags however, qubits can be skipped or negated. Practically, the flags
+    allow to skip controls or to apply pre- and post-X gates to the negated qubits.
+
+    The AndGate gate without special flags equals the multi-controlled-X gate:
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+       from qiskit.circuit import QuantumCircuit
+       from qiskit.circuit.library import AndGate
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       circuit = QuantumCircuit(6)
+       circuit.append(AndGate(5), [0, 1, 2, 3, 4, 5])
+       _generate_circuit_library_visualization(circuit)
+
+    Using flags we can negate qubits or skip them. For instance, if we have 5 qubits and want to
+    return ``True`` if the first qubit is ``False`` and the last two are ``True`` we use the flags
+    ``[-1, 0, 0, 1, 1]``.
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+       from qiskit.circuit import QuantumCircuit
+       from qiskit.circuit.library import AndGate
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       circuit = QuantumCircuit(6)
+       circuit.append(AndGate(5, flags=[-1, 0, 0, 1, 1]), [0, 1, 2, 3, 4, 5])
+       _generate_circuit_library_visualization(circuit)
+
+    """
+
+    def __init__(
+        self,
+        num_variable_qubits: int,
+        flags: list[int] | None = None,
+    ) -> None:
+        """
+        Args:
+            num_variable_qubits: The qubits of which the AND is computed. The result will be written
+                into an additional result qubit.
+            flags: A list of +1/0/-1 marking negations or omissions of qubits.
+        """
+        super().__init__("and", num_variable_qubits + 1, [])
+        self.num_variable_qubits = num_variable_qubits
+        self.flags = flags
+
+    def _define(self):
+        # add registers
+        qr_variable = QuantumRegister(self.num_variable_qubits, name="variable")
+        qr_result = QuantumRegister(1, name="result")
+
+        # determine the control qubits: all that have a nonzero flag
+        flags = self.flags or [1] * self.num_variable_qubits
+        control_qubits = [q for q, flag in zip(qr_variable, flags) if flag != 0]
+
+        # determine the qubits that need to be flipped (if a flag is < 0)
+        flip_qubits = [q for q, flag in zip(qr_variable, flags) if flag < 0]
+
+        # create the definition circuit
+        circuit = QuantumCircuit(qr_variable, qr_result, name="and")
+
+        if len(flip_qubits) > 0:
+            circuit.x(flip_qubits)
+        circuit.mcx(control_qubits, qr_result[:])
+        if len(flip_qubits) > 0:
+            circuit.x(flip_qubits)
+
+        self.definition = circuit
+
+    # pylint: disable=unused-argument
+    def inverse(self, annotated: bool = False):
+        r"""Return inverted AND gate (itself).
+
+        Args:
+            annotated: when set to ``True``, this is typically used to return an
+                :class:`.AnnotatedOperation` with an inverse modifier set instead of a concrete
+                :class:`.Gate`. However, for this class this argument is ignored as this gate
+                is self-inverse.
+
+        Returns:
+            AndGate: inverse gate (self-inverse).
+        """
+        return AndGate(self.num_variable_qubits, self.flags)
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, AndGate)
+            and self.num_variable_qubits == other.num_variable_qubits
+            and self.flags == other.flags
+        )