qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/circuit/library/blueprintcircuit.py

@@ -0,0 +1,216 @@
+# 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
+
+from qiskit._accelerate.circuit import CircuitData
+from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
+from qiskit.circuit.parametertable import ParameterView
+
+
+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.
+    """
+
+    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._qubit_indices = {}
+        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."""
+        self._data = CircuitData(self._data.qubits, self._data.clbits)
+        self.global_phase = 0
+        self._is_built = False
+
+    @property
+    def qregs(self):
+        """A list of the quantum registers associated with the circuit."""
+        return self._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._qubit_indices = {}
+        self._data = CircuitData(clbits=self._data.clbits)
+        self.global_phase = 0
+        self._is_built = False
+
+        self.add_register(*qregs)
+
+    @property
+    def data(self):
+        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:
+        if not self._is_built:
+            self._build()
+        return super().num_parameters
+
+    @property
+    def parameters(self) -> ParameterView:
+        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=None, *, vars_mode="alike"):
+        if not self._is_built:
+            self._build()
+        cpy = super().copy_empty_like(name=name, vars_mode=vars_mode)
+        # The base `copy_empty_like` will typically trigger code that `BlueprintCircuit` treats as
+        # an "invalidation", so we have to manually restore properties deleted by that that
+        # `copy_empty_like` is supposed to propagate.
+        cpy.global_phase = self.global_phase
+        return cpy
+
+    def copy(self, name=None):
+        if not self._is_built:
+            self._build()
+        circuit_copy = super().copy(name=name)
+        circuit_copy._is_built = self._is_built
+        return circuit_copy

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
+from .quantum_or import OR
+from .quantum_xor import XOR
+from .inner_product import InnerProduct

qiskit/circuit/library/boolean_logic/inner_product.py

@@ -0,0 +1,78 @@
+# 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.
+
+
+"""InnerProduct circuit."""
+
+
+from qiskit.circuit import QuantumRegister, QuantumCircuit
+
+
+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.
+
+    .. parsed-literal::
+
+
+        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)
+    """
+
+    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)

qiskit/circuit/library/boolean_logic/quantum_and.py

@@ -0,0 +1,97 @@
+# 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.
+
+
+"""Implementations of boolean logic quantum circuits."""
+from __future__ import annotations
+
+from qiskit.circuit import QuantumRegister, QuantumCircuit, AncillaRegister
+from qiskit.circuit.library.standard_gates import MCXGate
+
+
+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)
+
+    """
+
+    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 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="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)

qiskit/circuit/library/boolean_logic/quantum_or.py

@@ -0,0 +1,98 @@
+# 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.
+
+
+"""Implementations of boolean logic quantum circuits."""
+from __future__ import annotations
+from typing import List, Optional
+
+from qiskit.circuit import QuantumRegister, QuantumCircuit, AncillaRegister
+from qiskit.circuit.library.standard_gates import MCXGate
+
+
+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)
+
+    """
+
+    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)

qiskit/circuit/library/boolean_logic/quantum_xor.py

@@ -0,0 +1,71 @@
+# 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.
+
+
+"""XOR circuit."""
+
+from typing import Optional
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit.exceptions import CircuitError
+
+
+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).
+    """
+
+    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::
+
+               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)

qiskit/circuit/library/data_preparation/__init__.py

@@ -0,0 +1,54 @@
+# 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
+from .z_feature_map import ZFeatureMap
+from .zz_feature_map import ZZFeatureMap
+from .state_preparation import StatePreparation, UniformSuperpositionGate
+from .initializer import Initialize
+
+__all__ = [
+    "PauliFeatureMap",
+    "ZFeatureMap",
+    "ZZFeatureMap",
+    "StatePreparation",
+    "UniformSuperpositionGate",
+    "Initialize",
+]