qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/library/quantum_volume.py

@@ -0,0 +1,167 @@
+# 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.
+
+"""Quantum Volume model circuit."""
+
+from __future__ import annotations
+
+from typing import Optional, Union
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit, CircuitInstruction
+from qiskit.circuit.library.generalized_gates import PermutationGate, UnitaryGate
+from qiskit._accelerate.circuit_library import quantum_volume as qv_rs
+
+
+class QuantumVolume(QuantumCircuit):
+    """A quantum volume model circuit.
+
+    The model circuits are random instances of circuits used to measure
+    the Quantum Volume metric, as introduced in [1].
+
+    The model circuits consist of layers of Haar random
+    elements of SU(4) applied between corresponding pairs
+    of qubits in a random bipartition.
+
+    **Reference Circuit:**
+
+    .. plot::
+
+       from qiskit.circuit.library import QuantumVolume
+       circuit = QuantumVolume(5, 6, seed=10)
+       circuit.draw('mpl')
+
+    **Expanded Circuit:**
+
+    .. plot::
+
+       from qiskit.circuit.library import QuantumVolume
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       circuit = QuantumVolume(5, 6, seed=10, classical_permutation=False)
+       _generate_circuit_library_visualization(circuit.decompose())
+
+    **References:**
+
+    [1] A. Cross et al. Validating quantum computers using
+    randomized model circuits, Phys. Rev. A 100, 032328 (2019).
+    [`arXiv:1811.12926 <https://arxiv.org/abs/1811.12926>`_]
+    """
+
+    def __init__(
+        self,
+        num_qubits: int,
+        depth: Optional[int] = None,
+        seed: Optional[Union[int, np.random.Generator]] = None,
+        classical_permutation: bool = True,
+        *,
+        flatten: bool = False,
+    ) -> None:
+        """Create quantum volume model circuit of size num_qubits x depth.
+
+        Args:
+            num_qubits: number of active qubits in model circuit.
+            depth: layers of SU(4) operations in model circuit.
+            seed: Random number generator or generator seed.
+            classical_permutation: use classical permutations at every layer,
+                rather than quantum.
+            flatten: If ``False`` (the default), construct a circuit that contains a single
+                instruction, which in turn has the actual volume structure.  If ``True``, construct
+                the volume structure directly.
+        """
+        import scipy.stats
+
+        # Parameters
+        depth = depth or num_qubits  # how many layers of SU(4)
+        width = num_qubits // 2  # how many SU(4)s fit in each layer
+        rng = seed if isinstance(seed, np.random.Generator) else np.random.default_rng(seed)
+        seed_name = seed
+        if seed_name is None:
+            # Get the internal entropy used to seed the default RNG, if no seed was given.  This
+            # stays in the output name, so effectively stores a way of regenerating the circuit.
+            # This is just best-effort only, for backwards compatibility, and isn't critical (if
+            # someone needs full reproducibility, they should be manually controlling the seeding).
+            seed_name = getattr(getattr(rng.bit_generator, "seed_seq", None), "entropy", None)
+
+        super().__init__(
+            num_qubits,
+            name="quantum_volume_" + str([num_qubits, depth, seed_name]).replace(" ", ""),
+        )
+        if classical_permutation:
+            if seed is not None:
+                max_value = np.iinfo(np.int64).max
+                seed = rng.integers(max_value, dtype=np.int64)
+            qv_circ = quantum_volume(num_qubits, depth, seed)
+            qv_circ.name = self.name
+            if flatten:
+                self.compose(qv_circ, inplace=True)
+            else:
+                self._append(CircuitInstruction(qv_circ.to_instruction(), tuple(self.qubits)))
+        else:
+            if seed is None:
+                seed = seed_name
+
+            base = self if flatten else QuantumCircuit(num_qubits, name=self.name)
+
+            # For each layer, generate a permutation of qubits
+            # Then generate and apply a Haar-random SU(4) to each pair
+            unitaries = scipy.stats.unitary_group.rvs(4, depth * width, rng).reshape(
+                depth, width, 4, 4
+            )
+            qubits = tuple(base.qubits)
+            for row in unitaries:
+                perm = rng.permutation(num_qubits)
+                base._append(CircuitInstruction(PermutationGate(perm), qubits))
+                for w, unitary in enumerate(row):
+                    gate = UnitaryGate(unitary, check_input=False, num_qubits=2)
+                    qubit = 2 * w
+                    base._append(CircuitInstruction(gate, qubits[qubit : qubit + 2]))
+            if not flatten:
+                self._append(CircuitInstruction(base.to_instruction(), tuple(self.qubits)))
+
+
+def quantum_volume(
+    num_qubits: int,
+    depth: int | None = None,
+    seed: int | np.random.Generator | None = None,
+) -> QuantumCircuit:
+    """A quantum volume model circuit.
+
+    The model circuits are random instances of circuits used to measure
+    the Quantum Volume metric, as introduced in [1].
+
+    The model circuits consist of layers of Haar random
+    elements of SU(4) applied between corresponding pairs
+    of qubits in a random bipartition.
+
+    This function is multithreaded and will launch a thread pool with threads equal to the number
+    of CPUs by default. You can tune the number of threads with the ``RAYON_NUM_THREADS``
+    environment variable. For example, setting ``RAYON_NUM_THREADS=4`` would limit the thread pool
+    to 4 threads.
+
+    **Reference Circuit:**
+
+    .. plot::
+
+       from qiskit.circuit.library import quantum_volume
+       circuit = quantum_volume(5, 6, seed=10)
+       circuit.draw('mpl')
+
+    **References:**
+
+    [1] A. Cross et al. Validating quantum computers using
+    randomized model circuits, Phys. Rev. A 100, 032328 (2019).
+    `arXiv:1811.12926 <https://arxiv.org/abs/1811.12926>`__
+    """
+    if isinstance(seed, np.random.Generator):
+        seed = seed.integers(0, dtype=np.uint64)
+    depth = depth or num_qubits
+    return QuantumCircuit._from_circuit_data(qv_rs(num_qubits, depth, seed))

qiskit/circuit/library/standard_gates/__init__.py

@@ -0,0 +1,142 @@
+# 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.
+
+"""
+Standard gates
+"""
+
+from .h import HGate, CHGate
+from .i import IGate
+from .p import PhaseGate, CPhaseGate, MCPhaseGate
+from .r import RGate
+from .rx import RXGate, CRXGate
+from .rxx import RXXGate
+from .ry import RYGate, CRYGate
+from .ryy import RYYGate
+from .rz import RZGate, CRZGate
+from .rzz import RZZGate
+from .rzx import RZXGate
+from .xx_minus_yy import XXMinusYYGate
+from .xx_plus_yy import XXPlusYYGate
+from .ecr import ECRGate
+from .s import SGate, SdgGate, CSGate, CSdgGate
+from .swap import SwapGate, CSwapGate
+from .iswap import iSwapGate
+from .sx import SXGate, SXdgGate, CSXGate
+from .dcx import DCXGate
+from .t import TGate, TdgGate
+from .u import UGate, CUGate
+from .u1 import U1Gate, CU1Gate, MCU1Gate
+from .u2 import U2Gate
+from .u3 import U3Gate, CU3Gate
+from .x import XGate, CXGate, CCXGate, C3XGate, C3SXGate, C4XGate, RCCXGate, RC3XGate
+from .x import MCXGate, MCXGrayCode, MCXRecursive, MCXVChain
+from .y import YGate, CYGate
+from .z import ZGate, CZGate, CCZGate
+from .global_phase import GlobalPhaseGate
+from .multi_control_rotation_gates import mcrx, mcry, mcrz
+
+
+def get_standard_gate_name_mapping():
+    """Return a dictionary mapping the name of standard gates and instructions to an object for
+    that name.
+
+    Examples:
+
+        .. code-block:: python
+
+            from qiskit.circuit.library import get_standard_gate_name_mapping
+
+            gate_name_map = get_standard_gate_name_mapping()
+            cx_object = gate_name_map["cx"]
+
+            print(cx_object)
+            print(type(cx_object))
+
+        .. code-block:: text
+
+            Instruction(name='cx', num_qubits=2, num_clbits=0, params=[])
+            _SingletonCXGate
+    """
+
+    from qiskit.circuit.parameter import Parameter
+    from qiskit.circuit.measure import Measure
+    from qiskit.circuit.delay import Delay
+    from qiskit.circuit.reset import Reset
+
+    lambda_ = Parameter("λ")
+    theta = Parameter("ϴ")
+    phi = Parameter("φ")
+    gamma = Parameter("γ")
+    beta = Parameter("β")
+    time = Parameter("t")
+
+    # Standard gates library mapping, multicontrolled gates not included since they're
+    # variable width
+    gates = [
+        IGate(),
+        SXGate(),
+        XGate(),
+        CXGate(),
+        RZGate(lambda_),
+        RGate(theta, phi),
+        C3SXGate(),
+        CCXGate(),
+        DCXGate(),
+        CHGate(),
+        CPhaseGate(theta),
+        CRXGate(theta),
+        CRYGate(theta),
+        CRZGate(theta),
+        CSwapGate(),
+        CSXGate(),
+        CUGate(theta, phi, lambda_, gamma),
+        CU1Gate(lambda_),
+        CU3Gate(theta, phi, lambda_),
+        CYGate(),
+        CZGate(),
+        CCZGate(),
+        GlobalPhaseGate(theta),
+        HGate(),
+        PhaseGate(theta),
+        RCCXGate(),
+        RC3XGate(),
+        RXGate(theta),
+        RXXGate(theta),
+        RYGate(theta),
+        RYYGate(theta),
+        RZZGate(theta),
+        RZXGate(theta),
+        XXMinusYYGate(theta, beta),
+        XXPlusYYGate(theta, beta),
+        ECRGate(),
+        SGate(),
+        SdgGate(),
+        CSGate(),
+        CSdgGate(),
+        SwapGate(),
+        iSwapGate(),
+        SXdgGate(),
+        TGate(),
+        TdgGate(),
+        UGate(theta, phi, lambda_),
+        U1Gate(lambda_),
+        U2Gate(phi, lambda_),
+        U3Gate(theta, phi, lambda_),
+        YGate(),
+        ZGate(),
+        Delay(time),
+        Reset(),
+        Measure(),
+    ]
+    name_mapping = {gate.name: gate for gate in gates}
+    return name_mapping

qiskit/circuit/library/standard_gates/dcx.py

@@ -0,0 +1,78 @@
+# 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.
+
+"""Double-CNOT gate."""
+
+from qiskit.circuit.singleton import SingletonGate, stdlib_singleton_key
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit._utils import with_gate_array
+from qiskit._accelerate.circuit import StandardGate
+
+
+@with_gate_array([[1, 0, 0, 0], [0, 0, 0, 1], [0, 1, 0, 0], [0, 0, 1, 0]])
+class DCXGate(SingletonGate):
+    r"""Double-CNOT gate.
+
+    A 2-qubit Clifford gate consisting of two back-to-back
+    CNOTs with alternate controls.
+
+    Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
+    with the :meth:`~qiskit.circuit.QuantumCircuit.dcx` method.
+
+    .. code-block:: text
+
+                  ┌───┐
+        q_0: ──■──┤ X ├
+             ┌─┴─┐└─┬─┘
+        q_1: ┤ X ├──■──
+             └───┘
+
+    This is a classical logic gate, equivalent to a CNOT-SWAP (CNS) sequence,
+    and locally equivalent to an iSWAP.
+
+    .. math::
+
+        DCX\ q_0, q_1 =
+            \begin{pmatrix}
+                1 & 0 & 0 & 0 \\
+                0 & 0 & 0 & 1 \\
+                0 & 1 & 0 & 0 \\
+                0 & 0 & 1 & 0
+            \end{pmatrix}
+    """
+
+    _standard_gate = StandardGate.DCXGate
+
+    def __init__(self, label=None, *, duration=None, unit="dt"):
+        """Create new DCX gate."""
+        super().__init__("dcx", 2, [], label=label, duration=duration, unit=unit)
+
+    _singleton_lookup_key = stdlib_singleton_key()
+
+    def _define(self):
+        """
+        gate dcx a, b { cx a, b; cx b, a; }
+        """
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from .x import CXGate
+
+        q = QuantumRegister(2, "q")
+        qc = QuantumCircuit(q, name=self.name)
+        rules = [(CXGate(), [q[0], q[1]], []), (CXGate(), [q[1], q[0]], [])]
+        for instr, qargs, cargs in rules:
+            qc._append(instr, qargs, cargs)
+
+        self.definition = qc
+
+    def __eq__(self, other):
+        return isinstance(other, DCXGate)

qiskit/circuit/library/standard_gates/ecr.py

@@ -0,0 +1,130 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Two-qubit ZX-rotation gate."""
+from math import sqrt
+import numpy as np
+
+from qiskit.circuit._utils import with_gate_array
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.singleton import SingletonGate, stdlib_singleton_key
+from qiskit._accelerate.circuit import StandardGate
+from .rzx import RZXGate
+from .x import XGate
+
+
+@with_gate_array(
+    sqrt(0.5) * np.array([[0, 1, 0, 1.0j], [1, 0, -1.0j, 0], [0, 1.0j, 0, 1], [-1.0j, 0, 1, 0]])
+)
+class ECRGate(SingletonGate):
+    r"""An echoed cross-resonance gate.
+
+    This gate is maximally entangling and is equivalent to a CNOT up to
+    single-qubit pre-rotations. The echoing procedure mitigates some
+    unwanted terms (terms other than ZX) to cancel in an experiment.
+    More specifically, this gate implements :math:`\frac{1}{\sqrt{2}}(IX-XY)`.
+
+    Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
+    with the :meth:`~qiskit.circuit.QuantumCircuit.ecr` method.
+
+    **Circuit Symbol:**
+
+    .. code-block:: text
+
+             ┌─────────┐            ┌────────────┐┌────────┐┌─────────────┐
+        q_0: ┤0        ├       q_0: ┤0           ├┤ RX(pi) ├┤0            ├
+             │   ECR   │   =        │  RZX(pi/4) │└────────┘│  RZX(-pi/4) │
+        q_1: ┤1        ├       q_1: ┤1           ├──────────┤1            ├
+             └─────────┘            └────────────┘          └─────────────┘
+
+    **Matrix Representation:**
+
+    .. math::
+
+        ECR\ q_0, q_1 = \frac{1}{\sqrt{2}}
+            \begin{pmatrix}
+                0   & 1   &  0  & i \\
+                1   & 0   &  -i & 0 \\
+                0   & i   &  0  & 1 \\
+                -i  & 0   &  1  & 0
+            \end{pmatrix}
+
+    .. note::
+
+        In Qiskit's convention, higher qubit indices are more significant
+        (little endian convention). In the above example we apply the gate
+        on (q_0, q_1) which results in the :math:`X \otimes Z` tensor order.
+        Instead, if we apply it on (q_1, q_0), the matrix will
+        be :math:`Z \otimes X`:
+
+        .. code-block:: text
+
+                 ┌─────────┐
+            q_0: ┤1        ├
+                 │   ECR   │
+            q_1: ┤0        ├
+                 └─────────┘
+
+        .. math::
+
+            ECR\ q_0, q_1 = \frac{1}{\sqrt{2}}
+                \begin{pmatrix}
+                    0   & 0   &  1  & i \\
+                    0   & 0   &  i  & 1 \\
+                    1   & -i  &  0  & 0 \\
+                    -i  & 1   &  0  & 0
+                \end{pmatrix}
+    """
+
+    _standard_gate = StandardGate.ECRGate
+
+    def __init__(self, label=None, *, duration=None, unit="dt"):
+        """Create new ECR gate."""
+        super().__init__("ecr", 2, [], label=label, duration=duration, unit=unit)
+
+    _singleton_lookup_key = stdlib_singleton_key()
+
+    def _define(self):
+        """
+        gate ecr a, b { rzx(pi/4) a, b; x a; rzx(-pi/4) a, b;}
+        """
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+        q = QuantumRegister(2, "q")
+        qc = QuantumCircuit(q, name=self.name)
+        rules = [
+            (RZXGate(np.pi / 4), [q[0], q[1]], []),
+            (XGate(), [q[0]], []),
+            (RZXGate(-np.pi / 4), [q[0], q[1]], []),
+        ]
+        for instr, qargs, cargs in rules:
+            qc._append(instr, qargs, cargs)
+
+        self.definition = qc
+
+    def inverse(self, annotated: bool = False):
+        """Return inverse ECR 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:
+            ECRGate: inverse gate (self-inverse).
+        """
+        return ECRGate()  # self-inverse
+
+    def __eq__(self, other):
+        return isinstance(other, ECRGate)