qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/circuit/library/templates/rzx/rzx_xz.py

@@ -0,0 +1,54 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+# pylint: disable=missing-module-docstring
+
+from __future__ import annotations
+
+import numpy as np
+
+from qiskit.circuit import Parameter, QuantumCircuit
+from qiskit.circuit.parameterexpression import ParameterValueType
+
+
+def rzx_xz(theta: ParameterValueType | None = None):
+    """RZX-based template for CX - RXGate - CX.
+
+    .. code-block:: text
+
+             ┌───┐         ┌───┐┌─────────┐┌─────────┐┌─────────┐┌──────────┐»
+        q_0: ┤ X ├─────────┤ X ├┤ RZ(π/2) ├┤ RX(π/2) ├┤ RZ(π/2) ├┤0         ├»
+             └─┬─┘┌───────┐└─┬─┘└─────────┘└─────────┘└─────────┘│  RZX(-ϴ) │»
+        q_1: ──■──┤ RX(ϴ) ├──■───────────────────────────────────┤1         ├»
+                  └───────┘                                      └──────────┘»
+        «     ┌─────────┐┌─────────┐┌─────────┐
+        «q_0: ┤ RZ(π/2) ├┤ RX(π/2) ├┤ RZ(π/2) ├
+        «     └─────────┘└─────────┘└─────────┘
+        «q_1: ─────────────────────────────────
+        «
+    """
+    if theta is None:
+        theta = Parameter("ϴ")
+
+    qc = QuantumCircuit(2)
+    qc.cx(1, 0)
+    qc.rx(theta, 1)
+    qc.cx(1, 0)
+
+    qc.rz(np.pi / 2, 0)
+    qc.rx(np.pi / 2, 0)
+    qc.rz(np.pi / 2, 0)
+    qc.rzx(-1 * theta, 0, 1)
+    qc.rz(np.pi / 2, 0)
+    qc.rx(np.pi / 2, 0)
+    qc.rz(np.pi / 2, 0)
+    return qc

qiskit/circuit/library/templates/rzx/rzx_yz.py

@@ -0,0 +1,45 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+# pylint: disable=missing-module-docstring
+
+from __future__ import annotations
+
+import numpy as np
+
+from qiskit.circuit import Parameter, QuantumCircuit
+from qiskit.circuit.parameterexpression import ParameterValueType
+
+
+def rzx_yz(theta: ParameterValueType | None = None):
+    """RZX-based template for CX - RYGate - CX.
+
+    .. code-block:: text
+
+                  ┌────────┐     ┌─────────┐┌─────────┐┌──────────┐
+        q_0: ──■──┤ RY(-ϴ) ├──■──┤ RX(π/2) ├┤0        ├┤ RX(-π/2) ├
+             ┌─┴─┐└────────┘┌─┴─┐└─────────┘│  RZX(ϴ) │└──────────┘
+        q_1: ┤ X ├──────────┤ X ├───────────┤1        ├────────────
+             └───┘          └───┘           └─────────┘
+    """
+    if theta is None:
+        theta = Parameter("ϴ")
+
+    circ = QuantumCircuit(2)
+    circ.cx(0, 1)
+    circ.ry(-1 * theta, 0)
+    circ.cx(0, 1)
+    circ.rx(np.pi / 2, 0)
+    circ.rzx(theta, 0, 1)
+    circ.rx(-np.pi / 2, 0)
+
+    return circ

qiskit/circuit/library/templates/rzx/rzx_zz1.py

@@ -0,0 +1,69 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+# pylint: disable=missing-module-docstring
+
+from __future__ import annotations
+
+import numpy as np
+
+from qiskit.circuit import Parameter, QuantumCircuit
+from qiskit.circuit.parameterexpression import ParameterValueType
+
+
+def rzx_zz1(theta: ParameterValueType | None = None):
+    """RZX-based template for CX - RZGate - CX.
+
+    .. code-block:: text
+
+                                                                                      »
+          q_0: ──■────────────────────────────────────────────■───────────────────────»
+               ┌─┴─┐┌───────┐┌────┐┌───────┐┌────┐┌────────┐┌─┴─┐┌────────┐┌─────────┐»
+          q_1: ┤ X ├┤ RZ(ϴ) ├┤ √X ├┤ RZ(π) ├┤ √X ├┤ RZ(3π) ├┤ X ├┤ RZ(-ϴ) ├┤ RZ(π/2) ├»
+               └───┘└───────┘└────┘└───────┘└────┘└────────┘└───┘└────────┘└─────────┘»
+          «                                    ┌──────────┐                      »
+          «q_0: ───────────────────────────────┤0         ├──────────────────────»
+          «     ┌─────────┐┌─────────┐┌───────┐│  RZX(-ϴ) │┌─────────┐┌─────────┐»
+          «q_1: ┤ RX(π/2) ├┤ RZ(π/2) ├┤ RX(ϴ) ├┤1         ├┤ RZ(π/2) ├┤ RX(π/2) ├»
+          «     └─────────┘└─────────┘└───────┘└──────────┘└─────────┘└─────────┘»
+          «
+          «q_0: ───────────
+          «     ┌─────────┐
+          «q_1: ┤ RZ(π/2) ├
+          «     └─────────┘
+    """
+    if theta is None:
+        theta = Parameter("ϴ")
+
+    qc = QuantumCircuit(2)
+    qc.cx(0, 1)
+    qc.rz(theta, 1)
+    qc.sx(1)
+    qc.rz(np.pi, 1)
+    qc.sx(1)
+    qc.rz(3 * np.pi, 1)
+    qc.cx(0, 1)
+    qc.rz(-1 * theta, 1)
+
+    # Hadamard
+    qc.rz(np.pi / 2, 1)
+    qc.rx(np.pi / 2, 1)
+    qc.rz(np.pi / 2, 1)
+
+    qc.rx(theta, 1)
+    qc.rzx(-1 * theta, 0, 1)
+    # Hadamard
+    qc.rz(np.pi / 2, 1)
+    qc.rx(np.pi / 2, 1)
+    qc.rz(np.pi / 2, 1)
+
+    return qc

qiskit/circuit/library/templates/rzx/rzx_zz2.py

@@ -0,0 +1,59 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+# pylint: disable=missing-module-docstring
+
+from __future__ import annotations
+
+import numpy as np
+
+from qiskit.circuit import Parameter, QuantumCircuit
+from qiskit.circuit.parameterexpression import ParameterValueType
+
+
+def rzx_zz2(theta: ParameterValueType | None = None):
+    """RZX-based template for CX - PhaseGate - CX.
+
+    .. code-block:: text
+
+                                                                                    »
+          q_0: ──■────────────■─────────────────────────────────────────────────────»
+               ┌─┴─┐┌──────┐┌─┴─┐┌───────┐┌─────────┐┌─────────┐┌─────────┐┌───────┐»
+          q_1: ┤ X ├┤ P(ϴ) ├┤ X ├┤ P(-ϴ) ├┤ RZ(π/2) ├┤ RX(π/2) ├┤ RZ(π/2) ├┤ RX(ϴ) ├»
+               └───┘└──────┘└───┘└───────┘└─────────┘└─────────┘└─────────┘└───────┘»
+          «     ┌──────────┐
+          «q_0: ┤0         ├─────────────────────────────────
+          «     │  RZX(-ϴ) │┌─────────┐┌─────────┐┌─────────┐
+          «q_1: ┤1         ├┤ RZ(π/2) ├┤ RX(π/2) ├┤ RZ(π/2) ├
+          «     └──────────┘└─────────┘└─────────┘└─────────┘
+    """
+    if theta is None:
+        theta = Parameter("ϴ")
+
+    qc = QuantumCircuit(2)
+    qc.cx(0, 1)
+    qc.p(theta, 1)
+    qc.cx(0, 1)
+    qc.p(-1 * theta, 1)
+    # Hadamard
+    qc.rz(np.pi / 2, 1)
+    qc.rx(np.pi / 2, 1)
+    qc.rz(np.pi / 2, 1)
+
+    qc.rx(theta, 1)
+    qc.rzx(-1 * theta, 0, 1)
+    # Hadamard
+    qc.rz(np.pi / 2, 1)
+    qc.rx(np.pi / 2, 1)
+    qc.rz(np.pi / 2, 1)
+
+    return qc

qiskit/circuit/library/templates/rzx/rzx_zz3.py

@@ -0,0 +1,59 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+# pylint: disable=missing-module-docstring
+
+from __future__ import annotations
+
+import numpy as np
+
+from qiskit.circuit import Parameter, QuantumCircuit
+from qiskit.circuit.parameterexpression import ParameterValueType
+
+
+def rzx_zz3(theta: ParameterValueType | None = None):
+    """RZX-based template for CX - RZGate - CX.
+
+    .. code-block:: text
+
+                                                                                      »
+          q_0: ──■─────────────■──────────────────────────────────────────────────────»
+               ┌─┴─┐┌───────┐┌─┴─┐┌────────┐┌─────────┐┌─────────┐┌─────────┐┌───────┐»
+          q_1: ┤ X ├┤ RZ(ϴ) ├┤ X ├┤ RZ(-ϴ) ├┤ RZ(π/2) ├┤ RX(π/2) ├┤ RZ(π/2) ├┤ RX(ϴ) ├»
+               └───┘└───────┘└───┘└────────┘└─────────┘└─────────┘└─────────┘└───────┘»
+          «     ┌──────────┐
+          «q_0: ┤0         ├─────────────────────────────────
+          «     │  RZX(-ϴ) │┌─────────┐┌─────────┐┌─────────┐
+          «q_1: ┤1         ├┤ RZ(π/2) ├┤ RX(π/2) ├┤ RZ(π/2) ├
+          «     └──────────┘└─────────┘└─────────┘└─────────┘
+    """
+    if theta is None:
+        theta = Parameter("ϴ")
+
+    qc = QuantumCircuit(2)
+    qc.cx(0, 1)
+    qc.rz(theta, 1)
+    qc.cx(0, 1)
+    qc.rz(-1 * theta, 1)
+    # Hadamard
+    qc.rz(np.pi / 2, 1)
+    qc.rx(np.pi / 2, 1)
+    qc.rz(np.pi / 2, 1)
+
+    qc.rx(theta, 1)
+    qc.rzx(-1 * theta, 0, 1)
+    # Hadamard
+    qc.rz(np.pi / 2, 1)
+    qc.rx(np.pi / 2, 1)
+    qc.rz(np.pi / 2, 1)
+
+    return qc

qiskit/circuit/measure.py

@@ -0,0 +1,53 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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.
+
+"""
+Quantum measurement in the computational basis.
+"""
+
+from qiskit.circuit.singleton import SingletonInstruction, stdlib_singleton_key
+from qiskit.circuit.exceptions import CircuitError
+from qiskit._accelerate.circuit import StandardInstructionType
+
+
+class Measure(SingletonInstruction):
+    """Quantum measurement in the computational basis."""
+
+    _standard_instruction_type = StandardInstructionType.Measure
+
+    def __init__(self, label=None):
+        """
+        Args:
+            label: optional string label for this instruction.
+        """
+        super().__init__("measure", 1, 1, [], label=label)
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        # Subclasses of Measure are not "standard", so we set this to None to
+        # prevent the Rust code from treating them as such.
+        cls._standard_instruction_type = None
+
+    _singleton_lookup_key = stdlib_singleton_key()
+
+    def broadcast_arguments(self, qargs, cargs):
+        qarg = qargs[0]
+        carg = cargs[0]
+
+        if len(carg) == len(qarg):
+            for qarg, carg in zip(qarg, carg):
+                yield [qarg], [carg]
+        elif len(qarg) == 1 and carg:
+            for each_carg in carg:
+                yield qarg, [each_carg]
+        else:
+            raise CircuitError("register size error")

qiskit/circuit/operation.py

@@ -0,0 +1,68 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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.
+
+"""Quantum Operation Mixin."""
+
+from abc import ABC, abstractmethod
+
+
+class Operation(ABC):
+    """Quantum operation interface.
+
+    The minimal interface that any object must fulfil in order to be added to a
+    :class:`.QuantumCircuit`.
+
+    Concrete instances of this interface include :class:`~qiskit.circuit.Gate`,
+    :class:`~qiskit.circuit.Reset`, :class:`~qiskit.circuit.Barrier`,
+    :class:`~qiskit.circuit.Measure`, and operators such as :class:`~qiskit.quantum_info.Clifford`.
+
+    The main purpose is to allow abstract mathematical objects to be added directly onto
+    abstract circuits, and for the exact syntheses of these to be determined later, during
+    compilation.
+
+    Example:
+
+        Add a Clifford and a Toffoli gate to a :class:`QuantumCircuit`.
+
+        .. plot::
+           :alt: Circuit diagram output by the previous code.
+           :include-source:
+
+           from qiskit import QuantumCircuit
+           from qiskit.quantum_info import Clifford, random_clifford
+
+           qc = QuantumCircuit(3)
+           cliff = random_clifford(2)
+           qc.append(cliff, [0, 1])
+           qc.ccx(0, 1, 2)
+           qc.draw('mpl')
+    """
+
+    __slots__ = ()
+
+    @property
+    @abstractmethod
+    def name(self):
+        """Unique string identifier for operation type."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def num_qubits(self):
+        """Number of qubits."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def num_clbits(self):
+        """Number of classical bits."""
+        raise NotImplementedError

qiskit/circuit/parameter.py

@@ -0,0 +1,188 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# 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.
+"""
+Parameter Class for variable parameters.
+"""
+
+from __future__ import annotations
+
+from uuid import uuid4, UUID
+
+import qiskit._accelerate.circuit
+from qiskit.circuit.exceptions import CircuitError
+from qiskit.utils.optionals import HAS_SYMPY
+
+from .parameterexpression import ParameterExpression
+
+
+SymbolExpr = qiskit._accelerate.circuit.ParameterExpression
+
+
+class Parameter(ParameterExpression):
+    """A compile-time symbolic parameter.
+
+    The value of a :class:`Parameter` must be entirely determined before a circuit begins execution.
+    Typically this will mean that you should supply values for all :class:`Parameter`\\ s in a
+    circuit using :meth:`.QuantumCircuit.assign_parameters`, though certain hardware vendors may
+    allow you to give them a circuit in terms of these parameters, provided you also pass the values
+    separately.
+
+    This is the atom of :class:`.ParameterExpression`, and is itself an expression.  The numeric
+    value of a parameter need not be fixed while the circuit is being defined.
+
+    Examples:
+
+        Construct a variable-rotation X gate using circuit parameters.
+
+        .. plot::
+           :alt: Circuit diagram output by the previous code.
+           :include-source:
+
+           from qiskit.circuit import QuantumCircuit, Parameter
+
+           # create the parameter
+           phi = Parameter('phi')
+           qc = QuantumCircuit(1)
+
+           # parameterize the rotation
+           qc.rx(phi, 0)
+           qc.draw('mpl')
+
+           # bind the parameters after circuit to create a bound circuit
+           bc = qc.assign_parameters({phi: 3.14})
+           bc.measure_all()
+           bc.draw('mpl')
+    """
+
+    __slots__ = ("_uuid", "_hash")
+
+    # This `__init__` does not call the super init, because we can't construct the
+    # `_parameter_symbols` dictionary we need to pass to it before we're entirely initialized
+    # anyway, because `ParameterExpression` depends heavily on the structure of `Parameter`.
+
+    def __init__(
+        self, name: str, *, uuid: UUID | None = None
+    ):  # pylint: disable=super-init-not-called
+        """
+        Args:
+            name: name of the ``Parameter``, used for visual representation. This can
+                be any Unicode string, e.g. "ϕ".
+            uuid: For advanced usage only.  Override the UUID of this parameter, in order to make it
+                compare equal to some other parameter object.  By default, two parameters with the
+                same name do not compare equal to help catch shadowing bugs when two circuits
+                containing the same named parameters are spurious combined.  Setting the ``uuid``
+                field when creating two parameters to the same thing (along with the same name)
+                allows them to be equal.  This is useful during serialization and deserialization.
+        """
+        self._uuid = uuid4() if uuid is None else uuid
+        symbol = SymbolExpr.Symbol(name)
+
+        self._symbol_expr = symbol
+        self._parameter_keys = frozenset((self._hash_key(),))
+        self._hash = hash((self._parameter_keys, self._symbol_expr))
+        self._parameter_symbols = {self: symbol}
+        self._name_map = None
+        self._qpy_replay = []
+        self._standalone_param = True
+
+    def assign(self, parameter, value):
+        if parameter != self:
+            # Corresponds to superclass calls to `subs` and `bind` that would implicitly set
+            # `allow_unknown_parameters=False`.
+            raise CircuitError(
+                f"Cannot bind Parameters ({[str(parameter)]}) not present in expression."
+            )
+        if isinstance(value, ParameterExpression):
+            # This is the `super().subs` case.
+            return value
+        # This is the `super().bind` case, where we're required to return a `ParameterExpression`,
+        # so we need to lift the given value to a symbolic expression.
+        return ParameterExpression({}, SymbolExpr.Value(value))
+
+    def subs(self, parameter_map: dict, allow_unknown_parameters: bool = False):
+        """Substitute self with the corresponding parameter in ``parameter_map``."""
+        if self in parameter_map:
+            return parameter_map[self]
+        if allow_unknown_parameters:
+            return self
+        raise CircuitError(
+            f"Cannot bind Parameters ({[str(p) for p in parameter_map]}) not present in "
+            "expression."
+        )
+
+    @property
+    def name(self):
+        """Returns the name of the :class:`Parameter`."""
+        return self._symbol_expr.name
+
+    @property
+    def uuid(self) -> UUID:
+        """Returns the :class:`~uuid.UUID` of the :class:`Parameter`.
+
+        In advanced use cases, this property can be passed to the
+        :class:`Parameter` constructor to produce an instance that compares
+        equal to another instance.
+        """
+        return self._uuid
+
+    def __str__(self):
+        return self.name
+
+    def __copy__(self):
+        return self
+
+    def __deepcopy__(self, memo=None):
+        return self
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.name})"
+
+    def __eq__(self, other):
+        if isinstance(other, Parameter):
+            return (self._uuid, self._symbol_expr) == (other._uuid, other._symbol_expr)
+        elif isinstance(other, ParameterExpression):
+            return super().__eq__(other)
+        else:
+            return False
+
+    def _hash_key(self):
+        # `ParameterExpression` needs to be able to hash all its contained `Parameter` instances in
+        # its hash as part of the equality comparison but has its own more complete symbolic
+        # expression, so its full hash key is split into `(parameter_keys, symbolic_expression)`.
+        # This method lets containing expressions get only the bits they need for equality checks in
+        # the first value, without wasting time re-hashing individual symbols.
+        return (self._symbol_expr, self._uuid)
+
+    def __hash__(self):
+        # This is precached for performance, since it's used a lot and we are immutable.
+        return self._hash
+
+    # We have to manually control the pickling so that the hash is computable before the unpickling
+    # operation attempts to put this parameter into a hashmap.
+
+    def __getstate__(self):
+        return (self.name, self._uuid, self._symbol_expr)
+
+    def __setstate__(self, state):
+        _, self._uuid, self._symbol_expr = state
+        self._parameter_keys = frozenset((self._hash_key(),))
+        self._hash = hash((self._parameter_keys, self._symbol_expr))
+        self._parameter_symbols = {self: self._symbol_expr}
+        self._name_map = None
+        self._qpy_replay = []
+        self._standalone_param = True
+
+    @HAS_SYMPY.require_in_call
+    def sympify(self):
+        import sympy
+
+        return sympy.Symbol(self.name)