qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/circuit/library/boolean_logic/quantum_or.py

@@ -0,0 +1,206 @@
+# 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::
+       :alt: Diagram illustrating the previously described circuit.
+
+       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::
+       :alt: Diagram illustrating the previously described circuit.
+
+       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::
+       :alt: Diagram illustrating the previously described circuit.
+
+       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::
+       :alt: Diagram illustrating the previously described circuit.
+
+       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 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.
+        """
+        super().__init__("or", 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
+        )

qiskit/circuit/library/boolean_logic/quantum_xor.py

@@ -0,0 +1,167 @@
+# 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.
+
+
+"""Bitwise XOR circuit and gate."""
+
+from typing import Optional
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit, Gate
+from qiskit.circuit.exceptions import CircuitError
+from qiskit.utils.deprecation import deprecate_func
+
+
+class XOR(QuantumCircuit):
+    """An n_qubit circuit for bitwise xor-ing the input with some integer ``amount``.
+
+    The ``amount`` is xor-ed in bitstring form with the input.
+
+    This circuit can also represent addition by ``amount`` over the finite field GF(2).
+    """
+
+    @deprecate_func(
+        since="1.3",
+        additional_msg="Instead, for xor-ing with a specified amount, use BitwiseXorGate,"
+        "and for xor-ing with a random amount, use random_bitwise_xor.",
+        pending=True,
+    )
+    def __init__(
+        self,
+        num_qubits: int,
+        amount: Optional[int] = None,
+        seed: Optional[int] = None,
+    ) -> None:
+        """Return a circuit implementing bitwise xor.
+
+        Args:
+            num_qubits: the width of circuit.
+            amount: the xor amount in decimal form.
+            seed: random seed in case a random xor is requested.
+
+        Raises:
+            CircuitError: if the xor bitstring exceeds available qubits.
+
+        Reference Circuit:
+            .. plot::
+               :alt: Diagram illustrating the previously described circuit.
+
+               from qiskit.circuit.library import XOR
+               from qiskit.visualization.library import _generate_circuit_library_visualization
+               circuit = XOR(5, seed=42)
+               _generate_circuit_library_visualization(circuit)
+        """
+        circuit = QuantumCircuit(num_qubits, name="xor")
+
+        if amount is not None:
+            if len(bin(amount)[2:]) > num_qubits:
+                raise CircuitError("Bits in 'amount' exceed circuit width")
+        else:
+            rng = np.random.default_rng(seed)
+            amount = rng.integers(0, 2**num_qubits)
+
+        for i in range(num_qubits):
+            bit = amount & 1
+            amount = amount >> 1
+            if bit == 1:
+                circuit.x(i)
+
+        super().__init__(*circuit.qregs, name="xor")
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)
+
+
+class BitwiseXorGate(Gate):
+    """An n-qubit gate for bitwise xor-ing the input with some integer ``amount``.
+
+    The ``amount`` is xor-ed in bitstring form with the input.
+
+    This gate can also represent addition by ``amount`` over the finite field GF(2).
+
+    Reference Circuit:
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+       from qiskit.circuit import QuantumCircuit
+       from qiskit.circuit.library import BitwiseXorGate
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       circuit = QuantumCircuit(5)
+       circuit.append(BitwiseXorGate(5, amount=12), [0, 1, 2, 3, 4])
+       _generate_circuit_library_visualization(circuit)
+
+    """
+
+    def __init__(
+        self,
+        num_qubits: int,
+        amount: int,
+    ) -> None:
+        """
+        Args:
+            num_qubits: the width of circuit.
+            amount: the xor amount in decimal form.
+
+        Raises:
+            CircuitError: if the xor bitstring exceeds available qubits.
+        """
+        if len(bin(amount)[2:]) > num_qubits:
+            raise CircuitError("Bits in 'amount' exceed circuit width")
+
+        super().__init__("xor", num_qubits, [])
+        self.amount = amount
+
+    def _define(self):
+        circuit = QuantumCircuit(self.num_qubits, name="xor")
+        amount = self.amount
+        for i in range(self.num_qubits):
+            bit = amount & 1
+            amount = amount >> 1
+            if bit == 1:
+                circuit.x(i)
+
+        self.definition = circuit
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, BitwiseXorGate)
+            and self.num_qubits == other.num_qubits
+            and self.amount == other.amount
+        )
+
+    # pylint: disable=unused-argument
+    def inverse(self, annotated: bool = False):
+        r"""Return inverted BitwiseXorGate 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:
+            BitwiseXorGate: inverse gate (self-inverse).
+        """
+        return BitwiseXorGate(self.num_qubits, self.amount)
+
+
+def random_bitwise_xor(num_qubits: int, seed: int) -> BitwiseXorGate:
+    """
+    Create a random BitwiseXorGate.
+
+    Args:
+        num_qubits: the width of circuit.
+        seed: random seed in case a random xor is requested.
+    """
+
+    rng = np.random.default_rng(seed)
+    amount = rng.integers(0, 2**num_qubits)
+    return BitwiseXorGate(num_qubits, amount)

qiskit/circuit/library/data_preparation/__init__.py

@@ -0,0 +1,57 @@
+# 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.
+
+"""
+Data-encoding circuits
+======================
+
+In machine learning, pattern recognition and image processing, a **data-encoding circuit**
+starts from an initial set of measured data and builds derived values (also known as
+**features**) intended to be informative and non-redundant, facilitating the subsequent
+learning and generalization steps, and in some cases leading to better human
+interpretations.
+
+A feature map is related to **dimensionality reduction**; it involves reducing the amount of
+resources required to describe a large set of data. When performing analysis of complex data,
+one of the major problems stems from the number of variables involved. Analysis with a large
+number of variables generally requires a large amount of memory and computation power, and may
+even cause a classification algorithm to overfit to training samples and generalize poorly to new
+samples.
+
+When the input data to an algorithm is too large to be processed and is suspected to be redundant
+(for example, the same measurement is provided in both pounds and kilograms), then it can be
+transformed into a reduced set of features, named a **feature vector**.
+
+The process of determining a subset of the initial features is called **feature selection**.
+The selected features are expected to contain the relevant information from the input data,
+so that the desired task can be performed by using the reduced representation instead
+of the complete initial data.
+
+"""
+
+from .pauli_feature_map import PauliFeatureMap, pauli_feature_map, z_feature_map, zz_feature_map
+from ._z_feature_map import ZFeatureMap
+from ._zz_feature_map import ZZFeatureMap
+from .state_preparation import StatePreparation, UniformSuperpositionGate
+from .initializer import Initialize
+
+__all__ = [
+    "pauli_feature_map",
+    "PauliFeatureMap",
+    "z_feature_map",
+    "ZFeatureMap",
+    "zz_feature_map",
+    "ZZFeatureMap",
+    "StatePreparation",
+    "UniformSuperpositionGate",
+    "Initialize",
+]

qiskit/circuit/library/data_preparation/_z_feature_map.py

@@ -0,0 +1,115 @@
+# 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.
+
+"""Create a new first-order Pauli-Z expansion circuit."""
+
+from typing import Callable, Optional
+import numpy as np
+from qiskit.utils.deprecation import deprecate_func
+
+from .pauli_feature_map import PauliFeatureMap
+
+
+class ZFeatureMap(PauliFeatureMap):
+    """The first order Pauli Z-evolution circuit.
+
+    On 3 qubits and with 2 repetitions the circuit is represented by:
+
+    .. code-block:: text
+
+        ┌───┐┌─────────────┐┌───┐┌─────────────┐
+        ┤ H ├┤ P(2.0*x[0]) ├┤ H ├┤ P(2.0*x[0]) ├
+        ├───┤├─────────────┤├───┤├─────────────┤
+        ┤ H ├┤ U(2.0*x[1]) ├┤ H ├┤ P(2.0*x[1]) ├
+        ├───┤├─────────────┤├───┤├─────────────┤
+        ┤ H ├┤ P(2.0*x[2]) ├┤ H ├┤ P(2.0*x[2]) ├
+        └───┘└─────────────┘└───┘└─────────────┘
+
+    This is a sub-class of :class:`~qiskit.circuit.library.PauliFeatureMap` where the Pauli
+    strings are fixed as `['Z']`. As a result the first order expansion will be a circuit without
+    entangling gates.
+
+    Examples:
+
+        >>> prep = ZFeatureMap(3, reps=3, insert_barriers=True)
+        >>> print(prep.decompose())
+             ┌───┐ ░ ┌─────────────┐ ░ ┌───┐ ░ ┌─────────────┐ ░ ┌───┐ ░ ┌─────────────┐
+        q_0: ┤ H ├─░─┤ P(2.0*x[0]) ├─░─┤ H ├─░─┤ P(2.0*x[0]) ├─░─┤ H ├─░─┤ P(2.0*x[0]) ├
+             ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤
+        q_1: ┤ H ├─░─┤ P(2.0*x[1]) ├─░─┤ H ├─░─┤ P(2.0*x[1]) ├─░─┤ H ├─░─┤ P(2.0*x[1]) ├
+             ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤
+        q_2: ┤ H ├─░─┤ P(2.0*x[2]) ├─░─┤ H ├─░─┤ P(2.0*x[2]) ├─░─┤ H ├─░─┤ P(2.0*x[2]) ├
+             └───┘ ░ └─────────────┘ ░ └───┘ ░ └─────────────┘ ░ └───┘ ░ └─────────────┘
+
+        >>> data_map = lambda x: x[0]*x[0] + 1  # note: input is an array
+        >>> prep = ZFeatureMap(3, reps=1, data_map_func=data_map)
+        >>> print(prep.decompose())
+             ┌───┐┌──────────────────────┐
+        q_0: ┤ H ├┤ P(2.0*x[0]**2 + 2.0) ├
+             ├───┤├──────────────────────┤
+        q_1: ┤ H ├┤ P(2.0*x[1]**2 + 2.0) ├
+             ├───┤├──────────────────────┤
+        q_2: ┤ H ├┤ P(2.0*x[2]**2 + 2.0) ├
+             └───┘└──────────────────────┘
+
+        >>> from qiskit.circuit.library import TwoLocal
+        >>> ry = TwoLocal(3, "ry", "cz", reps=1)
+        >>> classifier = ZFeatureMap(3, reps=1) + ry
+        >>> print(classifier.decompose())
+             ┌───┐┌─────────────┐┌──────────┐      ┌──────────┐
+        q_0: ┤ H ├┤ P(2.0*x[0]) ├┤ RY(θ[0]) ├─■──■─┤ RY(θ[3]) ├────────────
+             ├───┤├─────────────┤├──────────┤ │  │ └──────────┘┌──────────┐
+        q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ RY(θ[1]) ├─■──┼──────■──────┤ RY(θ[4]) ├
+             ├───┤├─────────────┤├──────────┤    │      │      ├──────────┤
+        q_2: ┤ H ├┤ P(2.0*x[2]) ├┤ RY(θ[2]) ├────■──────■──────┤ RY(θ[5]) ├
+             └───┘└─────────────┘└──────────┘                  └──────────┘
+
+    """
+
+    @deprecate_func(
+        since="1.3",
+        additional_msg=(
+            "Use the z_feature_map function as a replacement. Note that this will no longer "
+            "return a BlueprintCircuit, but just a plain QuantumCircuit."
+        ),
+        pending=True,
+    )
+    def __init__(
+        self,
+        feature_dimension: int,
+        reps: int = 2,
+        data_map_func: Optional[Callable[[np.ndarray], float]] = None,
+        parameter_prefix: str = "x",
+        insert_barriers: bool = False,
+        name: str = "ZFeatureMap",
+    ) -> None:
+        """Create a new first-order Pauli-Z expansion circuit.
+
+        Args:
+            feature_dimension: The number of features
+            reps: The number of repeated circuits. Defaults to 2, has a minimum value of 1.
+            data_map_func: A mapping function for data x which can be supplied to override the
+                default mapping from :meth:`self_product`.
+            parameter_prefix: The prefix used if default parameters are generated.
+            insert_barriers: If True, barriers are inserted in between the evolution instructions
+                and hadamard layers.
+
+        """
+        super().__init__(
+            feature_dimension=feature_dimension,
+            paulis=["Z"],
+            reps=reps,
+            data_map_func=data_map_func,
+            parameter_prefix=parameter_prefix,
+            insert_barriers=insert_barriers,
+            name=name,
+        )