qiskit 2.0.3__cp39-abi3-macosx_11_0_arm64.whl → 2.1.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/library/standard_gates/rzz.py

@@ -87,37 +87,25 @@ class RZZGate(Gate):
                                     \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.RZZGate
+    _standard_gate = StandardGate.RZZ
 
     def __init__(self, theta: ParameterValueType, label: Optional[str] = None):
         """Create new RZZ gate."""
         super().__init__("rzz", 2, [theta], label=label)
 
     def _define(self):
-        """
-        gate rzz(theta) a, b { cx a, b; u1(theta) b; cx a, b; }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .x import CXGate
-        from .rz import RZGate
+        from qiskit.circuit import QuantumCircuit
 
         # q_0: ──■─────────────■──
         #      ┌─┴─┐┌───────┐┌─┴─┐
         # q_1: ┤ X ├┤ Rz(0) ├┤ X ├
         #      └───┘└───────┘└───┘
-        q = QuantumRegister(2, "q")
-        theta = self.params[0]
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (CXGate(), [q[0], q[1]], []),
-            (RZGate(theta), [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.RZZ._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,

qiskit/circuit/library/standard_gates/s.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-from math import pi
 from typing import Optional, Union
 
 import numpy
@@ -59,7 +58,7 @@ class SGate(SingletonGate):
     Equivalent to a :math:`\pi/2` radian rotation about the Z axis.
     """
 
-    _standard_gate = StandardGate.SGate
+    _standard_gate = StandardGate.S
 
     def __init__(self, label: Optional[str] = None):
         """Create new S gate."""
@@ -68,21 +67,17 @@ class SGate(SingletonGate):
     _singleton_lookup_key = stdlib_singleton_key()
 
     def _define(self):
-        """
-        gate s a { u1(pi/2) 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")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U1Gate(pi / 2), [q[0]], [])]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+        #    ┌────────┐
+        # q: ┤ P(π/2) ├
+        #    └────────┘
 
-        self.definition = qc
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.S._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,
@@ -171,7 +166,7 @@ class SdgGate(SingletonGate):
     Equivalent to a :math:`-\pi/2` radian rotation about the Z axis.
     """
 
-    _standard_gate = StandardGate.SdgGate
+    _standard_gate = StandardGate.Sdg
 
     def __init__(self, label: Optional[str] = None):
         """Create new Sdg gate."""
@@ -180,21 +175,17 @@ class SdgGate(SingletonGate):
     _singleton_lookup_key = stdlib_singleton_key()
 
     def _define(self):
-        """
-        gate sdg a { u1(-pi/2) 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")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U1Gate(-pi / 2), [q[0]], [])]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+        #    ┌─────────┐
+        # q: ┤ P(-π/2) ├
+        #    └─────────┘
 
-        self.definition = qc
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.Sdg._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,
@@ -282,7 +273,7 @@ class CSGate(SingletonControlledGate):
             \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.CSGate
+    _standard_gate = StandardGate.CS
 
     def __init__(
         self,
@@ -306,12 +297,19 @@ class CSGate(SingletonControlledGate):
     _singleton_lookup_key = stdlib_singleton_key(num_ctrl_qubits=1)
 
     def _define(self):
-        """
-        gate cs a,b { h b; cp(pi/2) a,b; h b; }
-        """
-        from .p import CPhaseGate
+        """Default definition"""
+        # pylint: disable=cyclic-import
+        from qiskit.circuit import QuantumCircuit
 
-        self.definition = CPhaseGate(theta=pi / 2).definition
+        #      ┌───┐
+        # q_0: ┤ T ├──■───────────■───────
+        #      └───┘┌─┴─┐┌─────┐┌─┴─┐┌───┐
+        # q_1: ─────┤ X ├┤ Tdg ├┤ X ├┤ T ├
+        #           └───┘└─────┘└───┘└───┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.CS._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         """Return inverse of CSGate (CSdgGate).
@@ -366,7 +364,7 @@ class CSdgGate(SingletonControlledGate):
             \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.CSdgGate
+    _standard_gate = StandardGate.CSdg
 
     def __init__(
         self,
@@ -389,12 +387,19 @@ class CSdgGate(SingletonControlledGate):
     _singleton_lookup_key = stdlib_singleton_key(num_ctrl_qubits=1)
 
     def _define(self):
-        """
-        gate csdg a,b { h b; cp(-pi/2) a,b; h b; }
-        """
-        from .p import CPhaseGate
+        """Default definition"""
+        # pylint: disable=cyclic-import
+        from qiskit.circuit import QuantumCircuit
 
-        self.definition = CPhaseGate(theta=-pi / 2).definition
+        #      ┌─────┐
+        # q_0: ┤ Tdg ├──■─────────■─────────
+        #      └─────┘┌─┴─┐┌───┐┌─┴─┐┌─────┐
+        # q_1: ───────┤ X ├┤ T ├┤ X ├┤ Tdg ├
+        #             └───┘└───┘└───┘└─────┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.CSdg._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         """Return inverse of CSdgGate (CSGate).

qiskit/circuit/library/standard_gates/swap.py

@@ -60,7 +60,7 @@ class SwapGate(SingletonGate):
         |a, b\rangle \rightarrow |b, a\rangle
     """
 
-    _standard_gate = StandardGate.SwapGate
+    _standard_gate = StandardGate.Swap
 
     def __init__(self, label: Optional[str] = None):
         """Create new SWAP gate."""
@@ -69,24 +69,19 @@ class SwapGate(SingletonGate):
     _singleton_lookup_key = stdlib_singleton_key()
 
     def _define(self):
-        """
-        gate swap a,b { cx a,b; cx b,a; 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 = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (CXGate(), [q[0], q[1]], []),
-            (CXGate(), [q[1], q[0]], []),
-            (CXGate(), [q[0], q[1]], []),
-        ]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+        #           ┌───┐
+        # q_0: ──■──┤ X ├──■──
+        #      ┌─┴─┐└─┬─┘┌─┴─┐
+        # q_1: ┤ X ├──■──┤ X ├
+        #      └───┘     └───┘
 
-        self.definition = qc
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.Swap._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,
@@ -217,7 +212,7 @@ class CSwapGate(SingletonControlledGate):
         |1, b, c\rangle \rightarrow |1, c, b\rangle
     """
 
-    _standard_gate = StandardGate.CSwapGate
+    _standard_gate = StandardGate.CSwap
 
     def __init__(
         self,
@@ -240,28 +235,20 @@ class CSwapGate(SingletonControlledGate):
     _singleton_lookup_key = stdlib_singleton_key(num_ctrl_qubits=1)
 
     def _define(self):
-        """
-        gate cswap a,b,c
-        { cx c,b;
-          ccx a,b,c;
-          cx c,b;
-        }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .x import CXGate, CCXGate
-
-        q = QuantumRegister(3, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (CXGate(), [q[2], q[1]], []),
-            (CCXGate(), [q[0], q[1], q[2]], []),
-            (CXGate(), [q[2], 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: ┤ X ├──■──┤ X ├
+        #      └─┬─┘┌─┴─┐└─┬─┘
+        # q_2: ──■──┤ X ├──■──
+        #           └───┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.CSwap._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         """Return inverse CSwap gate (itself).

qiskit/circuit/library/standard_gates/sx.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-from math import pi
 from typing import Optional, Union
 from qiskit.circuit.singleton import SingletonGate, SingletonControlledGate, stdlib_singleton_key
 from qiskit.circuit._utils import with_gate_array, with_controlled_gate_array
@@ -64,7 +63,7 @@ class SXGate(SingletonGate):
 
     """
 
-    _standard_gate = StandardGate.SXGate
+    _standard_gate = StandardGate.SX
 
     def __init__(self, label: Optional[str] = None):
         """Create new SX gate."""
@@ -73,20 +72,18 @@ class SXGate(SingletonGate):
     _singleton_lookup_key = stdlib_singleton_key()
 
     def _define(self):
-        """
-        gate sx a { rz(-pi/2) a; h a; rz(-pi/2); }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .s import SdgGate
-        from .h import HGate
+        from qiskit.circuit import QuantumCircuit
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name, global_phase=pi / 4)
-        rules = [(SdgGate(), [q[0]], []), (HGate(), [q[0]], []), (SdgGate(), [q[0]], [])]
-        for operation, qubits, clbits in rules:
-            qc._append(operation, qubits, clbits)
-        self.definition = qc
+        # global phase: π/4
+        #    ┌─────┐┌───┐┌─────┐
+        # q: ┤ Sdg ├┤ H ├┤ Sdg ├
+        #    └─────┘└───┘└─────┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.SX._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         """Return inverse SX gate (i.e. SXdg).
@@ -168,7 +165,7 @@ class SXdgGate(SingletonGate):
                     = e^{-i \pi/4} \sqrt{X}^{\dagger}
     """
 
-    _standard_gate = StandardGate.SXdgGate
+    _standard_gate = StandardGate.SXdg
 
     def __init__(self, label: Optional[str] = None):
         """Create new SXdg gate."""
@@ -177,20 +174,18 @@ class SXdgGate(SingletonGate):
     _singleton_lookup_key = stdlib_singleton_key()
 
     def _define(self):
-        """
-        gate sxdg a { rz(pi/2) a; h a; rz(pi/2); }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .s import SGate
-        from .h import HGate
+        from qiskit.circuit import QuantumCircuit
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name, global_phase=-pi / 4)
-        rules = [(SGate(), [q[0]], []), (HGate(), [q[0]], []), (SGate(), [q[0]], [])]
-        for operation, qubits, clbits in rules:
-            qc._append(operation, qubits, clbits)
-        self.definition = qc
+        # global phase: 7π/4
+        #    ┌───┐┌───┐┌───┐
+        # q: ┤ S ├┤ H ├┤ S ├
+        #    └───┘└───┘└───┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.SXdg._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         """Return inverse SXdg gate (i.e. SX).
@@ -268,7 +263,7 @@ class CSXGate(SingletonControlledGate):
 
     """
 
-    _standard_gate = StandardGate.CSXGate
+    _standard_gate = StandardGate.CSX
 
     def __init__(
         self,
@@ -291,20 +286,18 @@ class CSXGate(SingletonControlledGate):
     _singleton_lookup_key = stdlib_singleton_key(num_ctrl_qubits=1)
 
     def _define(self):
-        """
-        gate csx a,b { h b; cu1(pi/2) a,b; h b; }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .h import HGate
-        from .u1 import CU1Gate
-
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(HGate(), [q[1]], []), (CU1Gate(pi / 2), [q[0], q[1]], []), (HGate(), [q[1]], [])]
-        for operation, qubits, clbits in rules:
-            qc._append(operation, qubits, clbits)
-        self.definition = qc
+        from qiskit.circuit import QuantumCircuit
+
+        # q_0: ───────■───────
+        #      ┌───┐┌─┴─┐┌───┐
+        # q_1: ┤ H ├┤ S ├┤ H ├
+        #      └───┘└───┘└───┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.CSX._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def __eq__(self, other):
         return isinstance(other, CSXGate) and self.ctrl_state == other.ctrl_state

qiskit/circuit/library/standard_gates/t.py

@@ -12,7 +12,6 @@
 
 """T and Tdg gate."""
 import math
-from math import pi
 from typing import Optional
 
 import numpy
@@ -55,7 +54,7 @@ class TGate(SingletonGate):
     Equivalent to a :math:`\pi/4` radian rotation about the Z axis.
     """
 
-    _standard_gate = StandardGate.TGate
+    _standard_gate = StandardGate.T
 
     def __init__(self, label: Optional[str] = None):
         """Create new T gate."""
@@ -64,21 +63,17 @@ class TGate(SingletonGate):
     _singleton_lookup_key = stdlib_singleton_key()
 
     def _define(self):
-        """
-        gate t a { u1(pi/4) 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")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U1Gate(pi / 4), [q[0]], [])]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+        #    ┌────────┐
+        # q: ┤ P(π/4) ├
+        #    └────────┘
 
-        self.definition = qc
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.T._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         """Return inverse T gate (i.e. Tdg).
@@ -132,7 +127,7 @@ class TdgGate(SingletonGate):
     Equivalent to a :math:`-\pi/4` radian rotation about the Z axis.
     """
 
-    _standard_gate = StandardGate.TdgGate
+    _standard_gate = StandardGate.Tdg
 
     def __init__(self, label: Optional[str] = None):
         """Create new Tdg gate."""
@@ -141,21 +136,17 @@ class TdgGate(SingletonGate):
     _singleton_lookup_key = stdlib_singleton_key()
 
     def _define(self):
-        """
-        gate tdg a { u1(pi/4) 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")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U1Gate(-pi / 4), [q[0]], [])]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+        #    ┌─────────┐
+        # q: ┤ P(-π/4) ├
+        #    └─────────┘
 
-        self.definition = qc
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.Tdg._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         """Return inverse Tdg gate (i.e. T).

qiskit/circuit/library/standard_gates/u.py

@@ -71,7 +71,7 @@ class UGate(Gate):
         U(\theta, 0, 0) = RY(\theta)
     """
 
-    _standard_gate = StandardGate.UGate
+    _standard_gate = StandardGate.U
 
     def __init__(
         self,
@@ -269,7 +269,7 @@ class CUGate(ControlledGate):
             \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.CUGate
+    _standard_gate = StandardGate.CU
 
     def __init__(
         self,
@@ -294,35 +294,19 @@ class CUGate(ControlledGate):
         )
 
     def _define(self):
-        """
-        gate cu(theta,phi,lambda,gamma) c, t
-        { phase(gamma) c;
-          phase((lambda+phi)/2) c;
-          phase((lambda-phi)/2) t;
-          cx c,t;
-          u(-theta/2,0,-(phi+lambda)/2) t;
-          cx c,t;
-          u(theta/2,phi,0) t;
-        }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
+        from qiskit.circuit import QuantumCircuit
 
         #          ┌──────┐    ┌──────────────┐
         # q_0: ────┤ P(γ) ├────┤ P(λ/2 + φ/2) ├──■────────────────────────────■────────────────
         #      ┌───┴──────┴───┐└──────────────┘┌─┴─┐┌──────────────────────┐┌─┴─┐┌────────────┐
         # q_1: ┤ P(λ/2 - φ/2) ├────────────────┤ X ├┤ U(-0/2,0,-λ/2 - φ/2) ├┤ X ├┤ U(0/2,φ,0) ├
         #      └──────────────┘                └───┘└──────────────────────┘└───┘└────────────┘
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        qc.p(self.params[3], 0)
-        qc.p((self.params[2] + self.params[1]) / 2, 0)
-        qc.p((self.params[2] - self.params[1]) / 2, 1)
-        qc.cx(0, 1)
-        qc.u(-self.params[0] / 2, 0, -(self.params[1] + self.params[2]) / 2, 1)
-        qc.cx(0, 1)
-        qc.u(self.params[0] / 2, self.params[1], 0, 1)
-        self.definition = qc
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.CU._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         r"""Return inverted CU gate.