qiskit 1.3.0__cp39-abi3-win32.whl

qiskit/circuit/library/boolean_logic/inner_product.py

@@ -0,0 +1,155 @@
+# 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::
+
+           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="1.3",
+        additional_msg="Use qiskit.circuit.library.InnerProductGate instead.",
+        pending=True,
+    )
+    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::
+
+           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,200 @@
+# 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::
+
+       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::
+
+       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="1.3",
+        additional_msg="Use qiskit.circuit.library.AndGate instead.",
+        pending=True,
+    )
+    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::
+
+       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::
+
+       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
+        )

qiskit/circuit/library/boolean_logic/quantum_or.py

@@ -0,0 +1,202 @@
+# 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 OR circuit and gate."""
+
+from __future__ import annotations
+from typing import List, Optional
+
+from qiskit.circuit import QuantumRegister, QuantumCircuit, AncillaRegister, Gate
+from qiskit.circuit.library.standard_gates import MCXGate
+from qiskit.utils.deprecation import deprecate_func
+
+
+class OR(QuantumCircuit):
+    r"""A circuit implementing the logical OR operation on a number of qubits.
+
+    For the OR operation the state :math:`|1\rangle` is interpreted as ``True``. The result
+    qubit is flipped, if the state of any variable qubit is ``True``. The OR is implemented using
+    a multi-open-controlled X gate (i.e. flips if the state is :math:`|0\rangle`) and
+    applying an X gate on the result qubit.
+    Using a list of flags, qubits can be skipped or negated.
+
+    The OR gate without special flags:
+
+    .. plot::
+
+       from qiskit.circuit.library import OR
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       circuit = OR(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`` or one of the last two are ``True`` we use the
+    flags ``[-1, 0, 0, 1, 1]``.
+
+    .. plot::
+
+       from qiskit.circuit.library import OR
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       circuit = OR(5, flags=[-1, 0, 0, 1, 1])
+       _generate_circuit_library_visualization(circuit)
+
+    """
+
+    @deprecate_func(
+        since="1.3",
+        additional_msg="Use qiskit.circuit.library.OrGate instead.",
+        pending=True,
+    )
+    def __init__(
+        self,
+        num_variable_qubits: int,
+        flags: Optional[List[int]] = None,
+        mcx_mode: str = "noancilla",
+    ) -> None:
+        """Create a new logical OR circuit.
+
+        Args:
+            num_variable_qubits: The qubits of which the OR 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="or")
+
+        # 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)
+
+        circuit.x(qr_result)
+        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="or")
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)
+
+
+class OrGate(Gate):
+    r"""A gate representing the logical OR operation on a number of qubits.
+
+    For the OR operation the state :math:`|1\rangle` is interpreted as ``True``. The result
+    qubit is flipped, if the state of any variable qubit is ``True``. The OR is implemented using
+    a multi-open-controlled X gate (i.e. flips if the state is :math:`|0\rangle`) and
+    applying an X gate on the result qubit.
+    Using a list of flags, qubits can be skipped or negated.
+
+    The OrGate gate without special flags:
+
+    .. plot::
+
+       from qiskit.circuit import QuantumCircuit
+       from qiskit.circuit.library import OrGate
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       circuit = QuantumCircuit(6)
+       circuit.append(OrGate(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`` or one of the last two are ``True`` we use the
+    flags ``[-1, 0, 0, 1, 1]``.
+
+    .. plot::
+
+       from qiskit.circuit import QuantumCircuit
+       from qiskit.circuit.library import OrGate
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       circuit = QuantumCircuit(6)
+       circuit.append(OrGate(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="or")
+
+        circuit.x(qr_result)
+        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 OR 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:
+            OrGate: inverse gate (self-inverse).
+        """
+        return OrGate(self.num_variable_qubits, self.flags)
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, OrGate)
+            and self.num_variable_qubits == other.num_variable_qubits
+            and self.flags == other.flags
+        )