qiskit 2.0.2__cp39-abi3-macosx_11_0_arm64.whl → 2.1.0rc1__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/library/standard_gates/iswap.py

@@ -85,7 +85,7 @@ class iSwapGate(SingletonGate):
             \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.ISwapGate
+    _standard_gate = StandardGate.ISwap
 
     def __init__(self, label: Optional[str] = None):
         """Create new iSwap gate."""
@@ -94,37 +94,19 @@ class iSwapGate(SingletonGate):
     _singleton_lookup_key = stdlib_singleton_key()
 
     def _define(self):
-        """
-        gate iswap a,b {
-            s q[0];
-            s q[1];
-            h q[0];
-            cx q[0],q[1];
-            cx q[1],q[0];
-            h q[1];
-        }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-
-        from .h import HGate
-        from .s import SGate
-        from .x import CXGate
-
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (SGate(), [q[0]], []),
-            (SGate(), [q[1]], []),
-            (HGate(), [q[0]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (CXGate(), [q[1], q[0]], []),
-            (HGate(), [q[1]], []),
-        ]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
-
-        self.definition = qc
+        from qiskit.circuit import QuantumCircuit
+
+        #      ┌───┐┌───┐     ┌───┐
+        # q_0: ┤ S ├┤ H ├──■──┤ X ├─────
+        #      ├───┤└───┘┌─┴─┐└─┬─┘┌───┐
+        # q_1: ┤ S ├─────┤ X ├──■──┤ H ├
+        #      └───┘     └───┘     └───┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.ISwap._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def power(self, exponent: float, annotated: bool = False):
         return XXPlusYYGate(-np.pi * exponent)

qiskit/circuit/library/standard_gates/p.py

@@ -75,21 +75,24 @@ class PhaseGate(Gate):
         `1612.00858 <https://arxiv.org/abs/1612.00858>`_
     """
 
-    _standard_gate = StandardGate.PhaseGate
+    _standard_gate = StandardGate.Phase
 
     def __init__(self, theta: ParameterValueType, label: str | None = None):
         """Create new Phase gate."""
         super().__init__("p", 1, [theta], label=label)
 
     def _define(self):
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .u import UGate
+        from qiskit.circuit import QuantumCircuit
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        qc.append(UGate(0, 0, self.params[0]), [0])
-        self.definition = qc
+        #    ┌──────────┐
+        # q: ┤ U(0,0,θ) ├
+        #    └──────────┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.Phase._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,
@@ -197,7 +200,7 @@ class CPhaseGate(ControlledGate):
         phase difference.
     """
 
-    _standard_gate = StandardGate.CPhaseGate
+    _standard_gate = StandardGate.CPhase
 
     def __init__(
         self,
@@ -219,29 +222,19 @@ class CPhaseGate(ControlledGate):
         )
 
     def _define(self):
-        """
-        gate cphase(lambda) a,b
-        { phase(lambda/2) a; cx a,b;
-          phase(-lambda/2) b; cx a,b;
-          phase(lambda/2) b;
-        }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
+        from qiskit.circuit import QuantumCircuit
 
         #      ┌────────┐
-        # q_0: ┤ P(λ/2) ├──■───────────────■────────────
+        # q_0: ┤ P(θ/2) ├──■───────────────■────────────
         #      └────────┘┌─┴─┐┌─────────┐┌─┴─┐┌────────┐
-        # q_1: ──────────┤ X ├┤ P(-λ/2) ├┤ X ├┤ P(λ/2) ├
+        # q_1: ──────────┤ X ├┤ P(-θ/2) ├┤ X ├┤ P(θ/2) ├
         #                └───┘└─────────┘└───┘└────────┘
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        qc.p(self.params[0] / 2, 0)
-        qc.cx(0, 1)
-        qc.p(-self.params[0] / 2, 1)
-        qc.cx(0, 1)
-        qc.p(self.params[0] / 2, 1)
-        self.definition = qc
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.CPhase._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,

qiskit/circuit/library/standard_gates/r.py

@@ -14,7 +14,6 @@
 
 import math
 from cmath import exp
-from math import pi
 from typing import Optional
 import numpy
 from qiskit.circuit.gate import Gate
@@ -50,7 +49,7 @@ class RGate(Gate):
             \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.RGate
+    _standard_gate = StandardGate.R
 
     def __init__(
         self,
@@ -62,22 +61,17 @@ class RGate(Gate):
         super().__init__("r", 1, [theta, phi], label=label)
 
     def _define(self):
-        """
-        gate r(θ, φ) a {u3(θ, φ - π/2, -φ + π/2) a;}
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .u3 import U3Gate
-
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        theta = self.params[0]
-        phi = self.params[1]
-        rules = [(U3Gate(theta, phi - pi / 2, -phi + pi / 2), [q[0]], [])]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
-
-        self.definition = qc
+        from qiskit.circuit import QuantumCircuit
+
+        #    ┌───────────────────────┐
+        # q: ┤ U(θ,-π/2 + φ,π/2 - φ) ├
+        #    └───────────────────────┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.R._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         r"""Invert this gate as: :math:`R(θ, φ)^{\dagger} = R(-θ, φ)`

qiskit/circuit/library/standard_gates/rx.py

@@ -15,7 +15,6 @@
 from __future__ import annotations
 
 import math
-from math import pi
 from typing import Optional, Union
 import numpy
 
@@ -52,27 +51,24 @@ class RXGate(Gate):
             \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.RXGate
+    _standard_gate = StandardGate.RX
 
     def __init__(self, theta: ParameterValueType, label: Optional[str] = None):
         """Create new RX gate."""
         super().__init__("rx", 1, [theta], label=label)
 
     def _define(self):
-        """
-        gate rx(theta) a {r(theta, 0) a;}
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .r import RGate
+        from qiskit.circuit import QuantumCircuit
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(RGate(self.params[0], 0), [q[0]], [])]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+        #    ┌────────┐
+        # q: ┤ R(θ,0) ├
+        #    └────────┘
 
-        self.definition = qc
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.RX._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,
@@ -202,7 +198,7 @@ class CRXGate(ControlledGate):
                 \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.CRXGate
+    _standard_gate = StandardGate.CRX
 
     def __init__(
         self,
@@ -224,38 +220,18 @@ class CRXGate(ControlledGate):
         )
 
     def _define(self):
-        """
-        gate cu3(theta,phi,lambda) c, t
-        { u1(pi/2) t;
-          cx c,t;
-          u3(-theta/2,0,0) t;
-          cx c,t;
-          u3(theta/2,-pi/2,0) t;
-        }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .u1 import U1Gate
-        from .u3 import U3Gate
-        from .x import CXGate
-
-        # q_0: ─────────────■───────────────────■────────────────────
-        #      ┌─────────┐┌─┴─┐┌─────────────┐┌─┴─┐┌────────────────┐
-        # q_1: ┤ U1(π/2) ├┤ X ├┤ U3(0/2,0,0) ├┤ X ├┤ U3(0/2,-π/2,0) ├
-        #      └─────────┘└───┘└─────────────┘└───┘└────────────────┘
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (U1Gate(pi / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (U3Gate(-self.params[0] / 2, 0, 0), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (U3Gate(self.params[0] / 2, -pi / 2, 0), [q[1]], []),
-        ]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
-
-        self.definition = qc
+        from qiskit.circuit import QuantumCircuit
+
+        # q_0: ───────■────────────────────■──────────────────────
+        #      ┌───┐┌─┴─┐┌──────────────┐┌─┴─┐┌───────────┐┌─────┐
+        # q_1: ┤ S ├┤ X ├┤ Ry((-0.5)*θ) ├┤ X ├┤ Ry(0.5*θ) ├┤ Sdg ├
+        #      └───┘└───┘└──────────────┘└───┘└───────────┘└─────┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.CRX._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         """Return inverse CRX gate (i.e. with the negative rotation angle).

qiskit/circuit/library/standard_gates/rxx.py

@@ -75,41 +75,26 @@ class RXXGate(Gate):
                                     \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.RXXGate
+    _standard_gate = StandardGate.RXX
 
     def __init__(self, theta: ParameterValueType, label: Optional[str] = None):
         """Create new RXX gate."""
         super().__init__("rxx", 2, [theta], label=label)
 
     def _define(self):
-        """Calculate a subcircuit that implements this unitary."""
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .x import CXGate
-        from .h import HGate
-        from .rz import RZGate
+        from qiskit.circuit import QuantumCircuit
 
         #      ┌───┐                   ┌───┐
         # q_0: ┤ H ├──■─────────────■──┤ H ├
         #      ├───┤┌─┴─┐┌───────┐┌─┴─┐├───┤
         # q_1: ┤ H ├┤ X ├┤ Rz(0) ├┤ X ├┤ H ├
         #      └───┘└───┘└───────┘└───┘└───┘
-        theta = self.params[0]
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (HGate(), [q[0]], []),
-            (HGate(), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RZGate(theta), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (HGate(), [q[1]], []),
-            (HGate(), [q[0]], []),
-        ]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
-
-        self.definition = qc
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.RXX._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,

qiskit/circuit/library/standard_gates/ry.py

@@ -15,7 +15,6 @@
 from __future__ import annotations
 
 import math
-from math import pi
 from typing import Optional, Union
 import numpy
 from qiskit.circuit.controlledgate import ControlledGate
@@ -51,27 +50,24 @@ class RYGate(Gate):
             \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.RYGate
+    _standard_gate = StandardGate.RY
 
     def __init__(self, theta: ParameterValueType, label: Optional[str] = None):
         """Create new RY gate."""
         super().__init__("ry", 1, [theta], label=label)
 
     def _define(self):
-        """
-        gate ry(theta) a { r(theta, pi/2) a; }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .r import RGate
+        from qiskit.circuit import QuantumCircuit
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(RGate(self.params[0], pi / 2), [q[0]], [])]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+        #    ┌──────────┐
+        # q: ┤ R(θ,π/2) ├
+        #    └──────────┘
 
-        self.definition = qc
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.RY._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,
@@ -201,7 +197,7 @@ class CRYGate(ControlledGate):
                 \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.CRYGate
+    _standard_gate = StandardGate.CRY
 
     def __init__(
         self,
@@ -223,32 +219,18 @@ class CRYGate(ControlledGate):
         )
 
     def _define(self):
-        """
-        gate cry(lambda) a,b
-        { u3(lambda/2,0,0) b; cx a,b;
-          u3(-lambda/2,0,0) b; cx a,b;
-        }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .x import CXGate
-
-        # q_0: ─────────────■───────────────■──
-        #      ┌─────────┐┌─┴─┐┌─────────┐┌─┴─┐
-        # q_1: ┤ Ry(λ/2) ├┤ X ├┤ Ry(λ/2) ├┤ X ├
-        #      └─────────┘└───┘└─────────┘└───┘
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (RYGate(self.params[0] / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RYGate(-self.params[0] / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-        ]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
-
-        self.definition = qc
+        from qiskit.circuit import QuantumCircuit
+
+        # q_0: ─────────────■────────────────■──
+        #      ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐
+        # q_1: ┤ Ry(θ/2) ├┤ X ├┤ Ry(-θ/2) ├┤ X ├
+        #      └─────────┘└───┘└──────────┘└───┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.CRY._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         """Return inverse CRY gate (i.e. with the negative rotation angle)

qiskit/circuit/library/standard_gates/ryy.py

@@ -75,41 +75,26 @@ class RYYGate(Gate):
                                     \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.RYYGate
+    _standard_gate = StandardGate.RYY
 
     def __init__(self, theta: ParameterValueType, label: Optional[str] = None):
         """Create new RYY gate."""
         super().__init__("ryy", 2, [theta], label=label)
 
     def _define(self):
-        """Calculate a subcircuit that implements this unitary."""
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .x import CXGate
-        from .rx import RXGate
-        from .rz import RZGate
-
-        #      ┌─────────┐                   ┌──────────┐
-        # q_0: ┤ Rx(π/2) ├──■─────────────■──┤ Rx(-π/2) ├
-        #      ├─────────┤┌─┴─┐┌───────┐┌─┴─┐├──────────┤
-        # q_1: ┤ Rx(π/2) ├┤ X ├┤ Rz(0) ├┤ X ├┤ Rx(-π/2) ├
-        #      └─────────┘└───┘└───────┘└───┘└──────────┘
-        q = QuantumRegister(2, "q")
-        theta = self.params[0]
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (RXGate(np.pi / 2), [q[0]], []),
-            (RXGate(np.pi / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RZGate(theta), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RXGate(-np.pi / 2), [q[0]], []),
-            (RXGate(-np.pi / 2), [q[1]], []),
-        ]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
-
-        self.definition = qc
+        from qiskit.circuit import QuantumCircuit
+
+        #      ┌──────┐                   ┌────┐
+        # q_0: ┤ √Xdg ├──■─────────────■──┤ √X ├
+        #      ├──────┤┌─┴─┐┌───────┐┌─┴─┐├────┤
+        # q_1: ┤ √Xdg ├┤ X ├┤ Rz(θ) ├┤ X ├┤ √X ├
+        #      └──────┘└───┘└───────┘└───┘└────┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.RYY._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,

qiskit/circuit/library/standard_gates/rz.py

@@ -62,28 +62,25 @@ class RZGate(Gate):
         `1612.00858 <https://arxiv.org/abs/1612.00858>`_
     """
 
-    _standard_gate = StandardGate.RZGate
+    _standard_gate = StandardGate.RZ
 
     def __init__(self, phi: ParameterValueType, label: Optional[str] = None):
         """Create new RZ gate."""
         super().__init__("rz", 1, [phi], label=label)
 
     def _define(self):
-        """
-        gate rz(phi) a { u1(phi) a; }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .u1 import U1Gate
+        from qiskit.circuit import QuantumCircuit
 
-        q = QuantumRegister(1, "q")
-        theta = self.params[0]
-        qc = QuantumCircuit(q, name=self.name, global_phase=-theta / 2)
-        rules = [(U1Gate(theta), [q[0]], [])]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+        # global phase: -0.5*φ
+        #    ┌──────┐
+        # q: ┤ P(φ) ├
+        #    └──────┘
 
-        self.definition = qc
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.RZ._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,
@@ -220,7 +217,7 @@ class CRZGate(ControlledGate):
         phase difference.
     """
 
-    _standard_gate = StandardGate.CRZGate
+    _standard_gate = StandardGate.CRZ
 
     def __init__(
         self,
@@ -242,32 +239,18 @@ class CRZGate(ControlledGate):
         )
 
     def _define(self):
-        """
-        gate crz(lambda) a,b
-        { rz(lambda/2) b; cx a,b;
-          rz(-lambda/2) b; cx a,b;
-        }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .x import CXGate
+        from qiskit.circuit import QuantumCircuit
 
         # q_0: ─────────────■────────────────■──
         #      ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐
-        # q_1: ┤ Rz(λ/2) ├┤ X ├┤ Rz(-λ/2) ├┤ X ├
+        # q_1: ┤ Rz(θ/2) ├┤ X ├┤ Rz(-θ/2) ├┤ X ├
         #      └─────────┘└───┘└──────────┘└───┘
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (RZGate(self.params[0] / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RZGate(-self.params[0] / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-        ]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
-
-        self.definition = qc
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.CRZ._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         """Return inverse CRZ gate (i.e. with the negative rotation angle).

qiskit/circuit/library/standard_gates/rzx.py

@@ -120,40 +120,25 @@ class RZXGate(Gate):
                                     \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.RZXGate
+    _standard_gate = StandardGate.RZX
 
     def __init__(self, theta: ParameterValueType, label: Optional[str] = None):
         """Create new RZX gate."""
         super().__init__("rzx", 2, [theta], label=label)
 
     def _define(self):
-        """
-        gate rzx(theta) a, b { h b; cx a, b; u1(theta) b; cx a, b; h b;}
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .h import HGate
-        from .x import CXGate
-        from .rz import RZGate
+        from qiskit.circuit import QuantumCircuit
 
         # q_0: ───────■─────────────■───────
         #      ┌───┐┌─┴─┐┌───────┐┌─┴─┐┌───┐
         # q_1: ┤ H ├┤ X ├┤ Rz(0) ├┤ X ├┤ H ├
         #      └───┘└───┘└───────┘└───┘└───┘
-        theta = self.params[0]
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (HGate(), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RZGate(theta), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (HGate(), [q[1]], []),
-        ]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
-
-        self.definition = qc
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.RZX._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,