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/equivalence_library.py

@@ -115,6 +115,16 @@ def _cnot_rxx_decompose(plus_ry: bool = True, plus_rxx: bool = True):
 
 # Import existing gate definitions
 
+# HGate
+#
+#    ┌───┐        ┌───────────┐
+# q: ┤ H ├  ≡  q: ┤ U(0, 0,π) ├
+#    └───┘        └───────────┘
+q = QuantumRegister(1, "q")
+def_h = QuantumCircuit(q)
+def_h.append(UGate(pi / 2, 0, pi), [q[0]], [])
+_sel.add_equivalence(HGate(), def_h)
+
 # HGate
 #
 #    ┌───┐        ┌─────────┐
@@ -206,14 +216,14 @@ _sel.add_equivalence(CPhaseGate(theta), cphase_to_rzz)
 
 # RGate
 #
-#    ┌────────┐        ┌───────────────────────┐
-# q: ┤ R(ϴ,φ) ├  ≡  q: ┤ U3(ϴ,φ - π/2,π/2 - φ) ├
-#    └────────┘        └───────────────────────┘
+#    ┌────────┐        ┌──────────────────────┐
+# q: ┤ R(ϴ,φ) ├  ≡  q: ┤ U(ϴ,φ - π/2,π/2 - φ) ├
+#    └────────┘        └──────────────────────┘
 q = QuantumRegister(1, "q")
 theta = Parameter("theta")
 phi = Parameter("phi")
 def_r = QuantumCircuit(q)
-def_r.append(U3Gate(theta, phi - pi / 2, -phi + pi / 2), [q[0]])
+def_r.append(UGate(theta, phi - pi / 2, -phi + pi / 2), [q[0]])
 _sel.add_equivalence(RGate(theta, phi), def_r)
 
 # IGate
@@ -283,11 +293,11 @@ q = QuantumRegister(2, "q")
 theta = Parameter("theta")
 def_crx = QuantumCircuit(q)
 for inst, qargs, cargs in [
-    (U1Gate(pi / 2), [q[1]], []),
+    (SGate(), [q[1]], []),
     (CXGate(), [q[0], q[1]], []),
-    (U3Gate(-theta / 2, 0, 0), [q[1]], []),
+    (UGate(-theta / 2, 0, 0), [q[1]], []),
     (CXGate(), [q[0], q[1]], []),
-    (U3Gate(theta / 2, -pi / 2, 0), [q[1]], []),
+    (UGate(theta / 2, -pi / 2, 0), [q[1]], []),
 ]:
     def_crx.append(inst, qargs, cargs)
 _sel.add_equivalence(CRXGate(theta), def_crx)
@@ -524,6 +534,28 @@ for inst, qargs, cargs in [
     def_ryy.append(inst, qargs, cargs)
 _sel.add_equivalence(RYYGate(theta), def_ryy)
 
+# RYYGate
+#
+#      ┌─────────┐          ┌──────┐                   ┌────┐
+# q_0: ┤0        ├     q_0: ┤ √Xdg ├──■─────────────■──┤ √X ├
+#      │  Ryy(ϴ) │  ≡       ├──────┤┌─┴─┐┌───────┐┌─┴─┐├────┤
+# q_1: ┤1        ├     q_1: ┤ √Xdg ├┤ X ├┤ Rz(ϴ) ├┤ X ├┤ √X ├
+#      └─────────┘          └──────┘└───┘└───────┘└───┘└────┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+def_ryy = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (SXdgGate(), [q[0]], []),
+    (SXdgGate(), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (RZGate(theta), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (SXGate(), [q[0]], []),
+    (SXGate(), [q[1]], []),
+]:
+    def_ryy.append(inst, qargs, cargs)
+_sel.add_equivalence(RYYGate(theta), def_ryy)
+
 # RYY to RZZ
 q = QuantumRegister(2, "q")
 theta = Parameter("theta")
@@ -554,13 +586,13 @@ _sel.add_equivalence(RYYGate(theta), ryy_to_rxx)
 
 # RZGate
 #                  global phase: -ϴ/2
-#    ┌───────┐        ┌───────┐
-# q: ┤ Rz(ϴ) ├  ≡  q: ┤ U1(ϴ) ├
-#    └───────┘        └───────┘
+#    ┌───────┐        ┌──────┐
+# q: ┤ Rz(ϴ) ├  ≡  q: ┤ P(ϴ) ├
+#    └───────┘        └──────┘
 q = QuantumRegister(1, "q")
 theta = Parameter("theta")
 def_rz = QuantumCircuit(q, global_phase=-theta / 2)
-def_rz.append(U1Gate(theta), [q[0]], [])
+def_rz.append(PhaseGate(theta), [q[0]], [])
 _sel.add_equivalence(RZGate(theta), def_rz)
 
 # RZGate
@@ -789,51 +821,35 @@ _sel.add_equivalence(CXGate(), def_ecr_to_cx_cliff)
 
 # SGate
 #
-#    ┌───┐        ┌─────────┐
-# q: ┤ S ├  ≡  q: ┤ U1(π/2) ├
-#    └───┘        └─────────┘
+#    ┌───┐        ┌────────┐
+# q: ┤ S ├  ≡  q: ┤ P(π/2) ├
+#    └───┘        └────────┘
+q = QuantumRegister(1, "q")
+def_s = QuantumCircuit(q)
+def_s.append(PhaseGate(pi / 2), [q[0]], [])
+_sel.add_equivalence(SGate(), def_s)
+
+# SGate
+#
+#    ┌───┐┌───┐
+# q: ┤ T ├┤ T ├
+#    └───┘└───┘
 q = QuantumRegister(1, "q")
 def_s = QuantumCircuit(q)
-def_s.append(U1Gate(pi / 2), [q[0]], [])
+def_s.append(TGate(), [q[0]], [])
+def_s.append(TGate(), [q[0]], [])
 _sel.add_equivalence(SGate(), def_s)
 
 # SdgGate
 #
-#    ┌─────┐        ┌──────────┐
-# q: ┤ Sdg ├  ≡  q: ┤ U1(-π/2) ├
-#    └─────┘        └──────────┘
+#    ┌─────┐        ┌─────────┐
+# q: ┤ Sdg ├  ≡  q: ┤ P(-π/2) ├
+#    └─────┘        └─────────┘
 q = QuantumRegister(1, "q")
 def_sdg = QuantumCircuit(q)
-def_sdg.append(U1Gate(-pi / 2), [q[0]], [])
+def_sdg.append(PhaseGate(-pi / 2), [q[0]], [])
 _sel.add_equivalence(SdgGate(), def_sdg)
 
-# CSGate
-#
-# q_0: ──■──   q_0: ───────■────────
-#      ┌─┴─┐        ┌───┐┌─┴──┐┌───┐
-# q_1: ┤ S ├ = q_1: ┤ H ├┤ Sx ├┤ H ├
-#      └───┘        └───┘└────┘└───┘
-q = QuantumRegister(2, "q")
-def_cs = QuantumCircuit(q)
-def_cs.append(HGate(), [q[1]], [])
-def_cs.append(CSXGate(), [q[0], q[1]], [])
-def_cs.append(HGate(), [q[1]], [])
-_sel.add_equivalence(CSGate(), def_cs)
-
-# CSdgGate
-#
-# q_0: ───■───   q_0: ───────■────■────────
-#      ┌──┴──┐        ┌───┐┌─┴─┐┌─┴──┐┌───┐
-# q_1: ┤ Sdg ├ = q_1: ┤ H ├┤ X ├┤ Sx ├┤ H ├
-#      └─────┘        └───┘└───┘└────┘└───┘
-q = QuantumRegister(2, "q")
-def_csdg = QuantumCircuit(q)
-def_csdg.append(HGate(), [q[1]], [])
-def_csdg.append(CXGate(), [q[0], q[1]], [])
-def_csdg.append(CSXGate(), [q[0], q[1]], [])
-def_csdg.append(HGate(), [q[1]], [])
-_sel.add_equivalence(CSdgGate(), def_csdg)
-
 # SdgGate
 #
 #    ┌─────┐        ┌───┐┌───┐
@@ -877,6 +893,79 @@ for inst, qargs, cargs in [
     def_sdg.append(inst, qargs, cargs)
 _sel.add_equivalence(SdgGate(), def_sdg)
 
+# SdgGate
+#
+#    ┌─────┐┌─────┐
+# q: ┤ Tdg ├┤ Tdg ├
+#    └─────┘└─────┘
+q = QuantumRegister(1, "q")
+def_sdg = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (TdgGate(), [q[0]], []),
+    (TdgGate(), [q[0]], []),
+]:
+    def_sdg.append(inst, qargs, cargs)
+_sel.add_equivalence(SdgGate(), def_sdg)
+
+# CSGate
+#
+#                    ┌───┐
+# q_0: ──■──    q_0: ┤ T ├──■───────────■──
+#      ┌─┴─┐         ├───┤┌─┴─┐┌─────┐┌─┴─┐
+# q_1: ┤ S ├ =  q_1: ┤ T ├┤ X ├┤ Tdg ├┤ X ├
+#      └───┘         └───┘└───┘└─────┘└───┘
+q = QuantumRegister(2, "q")
+def_cs = QuantumCircuit(q)
+def_cs.append(TGate(), [q[0]], [])
+def_cs.append(TGate(), [q[1]], [])
+def_cs.append(CXGate(), [q[0], q[1]], [])
+def_cs.append(TdgGate(), [q[1]], [])
+def_cs.append(CXGate(), [q[0], q[1]], [])
+_sel.add_equivalence(CSGate(), def_cs)
+
+# CSGate
+#
+# q_0: ──■──   q_0: ───────■────────
+#      ┌─┴─┐        ┌───┐┌─┴──┐┌───┐
+# q_1: ┤ S ├ = q_1: ┤ H ├┤ Sx ├┤ H ├
+#      └───┘        └───┘└────┘└───┘
+q = QuantumRegister(2, "q")
+def_cs_csx = QuantumCircuit(q)
+def_cs_csx.append(HGate(), [q[1]], [])
+def_cs_csx.append(CSXGate(), [q[0], q[1]], [])
+def_cs_csx.append(HGate(), [q[1]], [])
+_sel.add_equivalence(CSGate(), def_cs_csx)
+
+# CSdgGate
+#
+#                                     ┌─────┐
+# q_0: ───■───    q_0: ──■─────────■──┤ Tdg ├
+#      ┌──┴──┐         ┌─┴─┐┌───┐┌─┴─┐├─────┤
+# q_1: ┤ Sdg ├ =  q_1: ┤ X ├┤ T ├┤ X ├┤ Tdg ├
+#      └─────┘         └───┘└───┘└───┘└─────┘
+q = QuantumRegister(2, "q")
+def_csdg = QuantumCircuit(q)
+def_csdg.append(CXGate(), [q[0], q[1]], [])
+def_csdg.append(TGate(), [q[1]], [])
+def_csdg.append(CXGate(), [q[0], q[1]], [])
+def_csdg.append(TdgGate(), [q[0]], [])
+def_csdg.append(TdgGate(), [q[1]], [])
+_sel.add_equivalence(CSdgGate(), def_csdg)
+
+# CSdgGate
+#
+# q_0: ───■───   q_0: ───────■────■────────
+#      ┌──┴──┐        ┌───┐┌─┴─┐┌─┴──┐┌───┐
+# q_1: ┤ Sdg ├ = q_1: ┤ H ├┤ X ├┤ Sx ├┤ H ├
+#      └─────┘        └───┘└───┘└────┘└───┘
+q = QuantumRegister(2, "q")
+def_csdg_csx = QuantumCircuit(q)
+def_csdg_csx.append(HGate(), [q[1]], [])
+def_csdg_csx.append(CXGate(), [q[0], q[1]], [])
+def_csdg_csx.append(CSXGate(), [q[0], q[1]], [])
+def_csdg_csx.append(HGate(), [q[1]], [])
+_sel.add_equivalence(CSdgGate(), def_csdg_csx)
+
 # SwapGate
 #                        ┌───┐
 # q_0: ─X─     q_0: ──■──┤ X ├──■──
@@ -1033,15 +1122,15 @@ _sel.add_equivalence(SXdgGate(), sxdg_to_rx)
 
 # CSXGate
 #
-# q_0: ──■───     q_0: ──────■─────────────
-#      ┌─┴──┐  ≡       ┌───┐ │U1(π/2) ┌───┐
-# q_1: ┤ Sx ├     q_1: ┤ H ├─■────────┤ H ├
-#      └────┘          └───┘          └───┘
+# q_0: ──■───     q_0: ───────■───────
+#      ┌─┴──┐  ≡       ┌───┐┌─┴─┐┌───┐
+# q_1: ┤ Sx ├     q_1: ┤ H ├┤ S ├┤ H ├
+#      └────┘          └───┘└───┘└───┘
 q = QuantumRegister(2, "q")
 def_csx = QuantumCircuit(q)
 for inst, qargs, cargs in [
     (HGate(), [q[1]], []),
-    (CU1Gate(pi / 2), [q[0], q[1]], []),
+    (CSGate(), [q[0], q[1]], []),
     (HGate(), [q[1]], []),
 ]:
     def_csx.append(inst, qargs, cargs)
@@ -1119,22 +1208,44 @@ _sel.add_equivalence(CSwapGate(), def_cswap)
 
 # TGate
 #
-#    ┌───┐        ┌─────────┐
-# q: ┤ T ├  ≡  q: ┤ U1(π/4) ├
-#    └───┘        └─────────┘
+#    ┌───┐        ┌────────┐
+# q: ┤ T ├  ≡  q: ┤ P(π/4) ├
+#    └───┘        └────────┘
 q = QuantumRegister(1, "q")
 def_t = QuantumCircuit(q)
-def_t.append(U1Gate(pi / 4), [q[0]], [])
+def_t.append(PhaseGate(pi / 4), [q[0]], [])
+_sel.add_equivalence(TGate(), def_t)
+
+# TGate
+#
+#    ┌─────┐┌─────┐┌─────┐┌─────┐┌─────┐┌─────┐┌─────┐
+# q: ┤ Tdg ├┤ Tdg ├┤ Tdg ├┤ Tdg ├┤ Tdg ├┤ Tdg ├┤ Tdg ├
+#    └─────┘└─────┘└─────┘└─────┘└─────┘└─────┘└─────┘
+q = QuantumRegister(1, "q")
+def_t = QuantumCircuit(q)
+for _ in range(7):
+    def_t.append(TdgGate(), [q[0]], [])
 _sel.add_equivalence(TGate(), def_t)
 
 # TdgGate
 #
-#    ┌─────┐        ┌──────────┐
-# q: ┤ Tdg ├  ≡  q: ┤ U1(-π/4) ├
-#    └─────┘        └──────────┘
+#    ┌─────┐        ┌─────────┐
+# q: ┤ Tdg ├  ≡  q: ┤ P(-π/4) ├
+#    └─────┘        └─────────┘
 q = QuantumRegister(1, "q")
 def_tdg = QuantumCircuit(q)
-def_tdg.append(U1Gate(-pi / 4), [q[0]], [])
+def_tdg.append(PhaseGate(-pi / 4), [q[0]], [])
+_sel.add_equivalence(TdgGate(), def_tdg)
+
+# TdgGate
+#
+#    ┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐
+# q: ┤ T ├┤ T ├┤ T ├┤ T ├┤ T ├┤ T ├┤ T ├
+#    └───┘└───┘└───┘└───┘└───┘└───┘└───┘
+q = QuantumRegister(1, "q")
+def_tdg = QuantumCircuit(q)
+for _ in range(7):
+    def_tdg.append(TGate(), [q[0]], [])
 _sel.add_equivalence(TdgGate(), def_tdg)
 
 # UGate
@@ -1226,34 +1337,34 @@ u1_to_rz.append(RZGate(theta), [q[0]], [])
 _sel.add_equivalence(U1Gate(theta), u1_to_rz)
 
 # CU1Gate
-#                       ┌─────────┐
-# q_0: ─■─────     q_0: ┤ U1(θ/2) ├──■────────────────■─────────────
-#       │U1(θ)  ≡       └─────────┘┌─┴─┐┌──────────┐┌─┴─┐┌─────────┐
-# q_1: ─■─────     q_1: ───────────┤ X ├┤ U1(-θ/2) ├┤ X ├┤ U1(θ/2) ├
-#                                  └───┘└──────────┘└───┘└─────────┘
+#                       ┌────────┐
+# q_0: ─■─────     q_0: ┤ P(θ/2) ├──■───────────────■────────────
+#       │U1(θ)  ≡       └────────┘┌─┴─┐┌─────────┐┌─┴─┐┌────────┐
+# q_1: ─■─────     q_1: ──────────┤ X ├┤ P(-θ/2) ├┤ X ├┤ P(θ/2) ├
+#                                 └───┘└─────────┘└───┘└────────┘
 q = QuantumRegister(2, "q")
 theta = Parameter("theta")
 def_cu1 = QuantumCircuit(q)
 for inst, qargs, cargs in [
-    (U1Gate(theta / 2), [q[0]], []),
+    (PhaseGate(theta / 2), [q[0]], []),
     (CXGate(), [q[0], q[1]], []),
-    (U1Gate(-theta / 2), [q[1]], []),
+    (PhaseGate(-theta / 2), [q[1]], []),
     (CXGate(), [q[0], q[1]], []),
-    (U1Gate(theta / 2), [q[1]], []),
+    (PhaseGate(theta / 2), [q[1]], []),
 ]:
     def_cu1.append(inst, qargs, cargs)
 _sel.add_equivalence(CU1Gate(theta), def_cu1)
 
 # U2Gate
 #
-#    ┌─────────┐        ┌─────────────┐
-# q: ┤ U2(ϕ,λ) ├  ≡  q: ┤ U3(π/2,ϕ,λ) ├
-#    └─────────┘        └─────────────┘
+#    ┌─────────┐        ┌────────────┐
+# q: ┤ U2(ϕ,λ) ├  ≡  q: ┤ U(π/2,ϕ,λ) ├
+#    └─────────┘        └────────────┘
 q = QuantumRegister(1, "q")
 phi = Parameter("phi")
 lam = Parameter("lam")
 def_u2 = QuantumCircuit(q)
-def_u2.append(U3Gate(pi / 2, phi, lam), [q[0]], [])
+def_u2.append(UGate(pi / 2, phi, lam), [q[0]], [])
 _sel.add_equivalence(U2Gate(phi, lam), def_u2)
 
 # U2Gate
@@ -1301,28 +1412,28 @@ u3_to_u.u(theta, phi, lam, 0)
 _sel.add_equivalence(U3Gate(theta, phi, lam), u3_to_u)
 
 # CU3Gate
-#                             ┌───────────────┐                                   »
-# q_0: ──────■──────     q_0: ┤ U1(λ/2 + ϕ/2) ├──■─────────────────────────────■──»
-#      ┌─────┴─────┐  ≡       ├───────────────┤┌─┴─┐┌───────────────────────┐┌─┴─┐»
-# q_1: ┤ U3(θ,ϕ,λ) ├     q_1: ┤ U1(λ/2 - ϕ/2) ├┤ X ├┤ U3(-θ/2,0,-λ/2 - ϕ/2) ├┤ X ├»
-#      └───────────┘          └───────────────┘└───┘└───────────────────────┘└───┘»
+#                             ┌──────────────┐                                  »
+# q_0: ──────■──────     q_0: ┤ P(λ/2 + ϕ/2) ├──■────────────────────────────■──»
+#      ┌─────┴─────┐  ≡       ├──────────────┤┌─┴─┐┌──────────────────────┐┌─┴─┐»
+# q_1: ┤ U3(θ,ϕ,λ) ├     q_1: ┤ P(λ/2 - ϕ/2) ├┤ X ├┤ U(-θ/2,0,-λ/2 - ϕ/2) ├┤ X ├»
+#      └───────────┘          └──────────────┘└───┘└──────────────────────┘└───┘»
 # «
-# «q_0: ───────────────
-# «     ┌─────────────┐
-# «q_1: ┤ U3(θ/2,ϕ,0) ├
-# «     └─────────────┘
+# «q_0: ──────────────
+# «     ┌────────────┐
+# «q_1: ┤ P(θ/2,ϕ,0) ├
+# «     └────────────┘
 q = QuantumRegister(2, "q")
 theta = Parameter("theta")
 phi = Parameter("phi")
 lam = Parameter("lam")
 def_cu3 = QuantumCircuit(q)
 for inst, qargs, cargs in [
-    (U1Gate((lam + phi) / 2), [q[0]], []),
-    (U1Gate((lam - phi) / 2), [q[1]], []),
+    (PhaseGate((lam + phi) / 2), [q[0]], []),
+    (PhaseGate((lam - phi) / 2), [q[1]], []),
     (CXGate(), [q[0], q[1]], []),
-    (U3Gate(-theta / 2, 0, -(phi + lam) / 2), [q[1]], []),
+    (UGate(-theta / 2, 0, -(phi + lam) / 2), [q[1]], []),
     (CXGate(), [q[0], q[1]], []),
-    (U3Gate(theta / 2, phi, 0), [q[1]], []),
+    (UGate(theta / 2, phi, 0), [q[1]], []),
 ]:
     def_cu3.append(inst, qargs, cargs)
 _sel.add_equivalence(CU3Gate(theta, phi, lam), def_cu3)
@@ -1337,12 +1448,12 @@ _sel.add_equivalence(CU3Gate(theta, phi, lam), cu3_to_cu)
 
 # XGate
 #
-#    ┌───┐        ┌───────────┐
-# q: ┤ X ├  ≡  q: ┤ U3(π,0,π) ├
-#    └───┘        └───────────┘
+#    ┌───┐        ┌──────────┐
+# q: ┤ X ├  ≡  q: ┤ U(π,0,π) ├
+#    └───┘        └──────────┘
 q = QuantumRegister(1, "q")
 def_x = QuantumCircuit(q)
-def_x.append(U3Gate(pi, 0, pi), [q[0]], [])
+def_x.append(UGate(pi, 0, pi), [q[0]], [])
 _sel.add_equivalence(XGate(), def_x)
 
 # XGate
@@ -1543,12 +1654,12 @@ _sel.add_equivalence(CCXGate(), ccx_to_cx_csx)
 
 # YGate
 #
-#    ┌───┐        ┌───────────────┐
-# q: ┤ Y ├  ≡  q: ┤ U3(π,π/2,π/2) ├
-#    └───┘        └───────────────┘
+#    ┌───┐        ┌──────────────┐
+# q: ┤ Y ├  ≡  q: ┤ U(π,π/2,π/2) ├
+#    └───┘        └──────────────┘
 q = QuantumRegister(1, "q")
 def_y = QuantumCircuit(q)
-def_y.append(U3Gate(pi, pi / 2, pi / 2), [q[0]], [])
+def_y.append(UGate(pi, pi / 2, pi / 2), [q[0]], [])
 _sel.add_equivalence(YGate(), def_y)
 
 # YGate
@@ -1617,12 +1728,12 @@ _sel.add_equivalence(CYGate(), def_cy)
 
 # ZGate
 #
-#    ┌───┐        ┌───────┐
-# q: ┤ Z ├  ≡  q: ┤ U1(π) ├
-#    └───┘        └───────┘
+#    ┌───┐        ┌──────┐
+# q: ┤ Z ├  ≡  q: ┤ P(π) ├
+#    └───┘        └──────┘
 q = QuantumRegister(1, "q")
 def_z = QuantumCircuit(q)
-def_z.append(U1Gate(pi), [q[0]], [])
+def_z.append(PhaseGate(pi), [q[0]], [])
 _sel.add_equivalence(ZGate(), def_z)
 
 # ZGate
@@ -1764,6 +1875,31 @@ for instr, qargs, cargs in rules:
     xxplusyy._append(instr, qargs, cargs)
 _sel.add_equivalence(XXPlusYYGate(theta, beta), xxplusyy)
 
+# XXPlusYYGate
+# ┌───────────────┐
+# ┤0              ├
+# │  {XX+YY}(θ,β) │
+# ┤1              ├
+# └───────────────┘
+#   ┌───────┐┌─────────────┐┌─────────────┐┌────────┐
+#   ┤ Rz(β) ├┤0            ├┤0            ├┤ Rz(-β) ├
+# ≡ └───────┘│  Rxx(0.5*θ) ││  Ryy(0.5*θ) │└────────┘
+#   ─────────┤1            ├┤1            ├──────────
+#            └─────────────┘└─────────────┘
+q = QuantumRegister(2, "q")
+xxplusyy = QuantumCircuit(q)
+beta = Parameter("beta")
+theta = Parameter("theta")
+rules: list[tuple[Gate, list[Qubit], list[Clbit]]] = [
+    (RZGate(beta), [q[0]], []),
+    (RXXGate(0.5 * theta), [q[0], q[1]], []),
+    (RYYGate(0.5 * theta), [q[0], q[1]], []),
+    (RZGate(-beta), [q[0]], []),
+]
+for instr, qargs, cargs in rules:
+    xxplusyy._append(instr, qargs, cargs)
+_sel.add_equivalence(XXPlusYYGate(theta, beta), xxplusyy)
+
 # XXMinusYYGate
 # ┌───────────────┐
 # ┤0              ├

qiskit/circuit/library/standard_gates/global_phase.py

@@ -35,7 +35,7 @@ class GlobalPhaseGate(Gate):
             \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.GlobalPhaseGate
+    _standard_gate = StandardGate.GlobalPhase
 
     def __init__(self, phase: ParameterValueType, label: Optional[str] = None):
         """
@@ -47,12 +47,11 @@ class GlobalPhaseGate(Gate):
 
     def _define(self):
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
+        from qiskit.circuit import QuantumCircuit
 
-        q = QuantumRegister(0, "q")
-        qc = QuantumCircuit(q, name=self.name, global_phase=self.params[0])
-
-        self.definition = qc
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.GlobalPhase._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         r"""Return inverse GlobalPhaseGate gate.

qiskit/circuit/library/standard_gates/h.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from math import sqrt, pi
+from math import sqrt
 from typing import Optional, Union
 import numpy
 from qiskit.circuit.singleton import SingletonGate, SingletonControlledGate, stdlib_singleton_key
@@ -54,7 +54,7 @@ class HGate(SingletonGate):
             \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.HGate
+    _standard_gate = StandardGate.H
 
     def __init__(self, label: Optional[str] = None):
         """Create new H gate."""
@@ -63,20 +63,17 @@ class HGate(SingletonGate):
     _singleton_lookup_key = stdlib_singleton_key()
 
     def _define(self):
-        """
-        gate h a { u2(0,pi) a; }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .u2 import U2Gate
+        from qiskit.circuit import QuantumCircuit
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U2Gate(0, pi), [q[0]], [])]
-        for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+        #    ┌────────────┐
+        # q: ┤ U(π/2,0,π) ├
+        #    └────────────┘
 
-        self.definition = qc
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.H._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def control(
         self,
@@ -188,7 +185,7 @@ class CHGate(SingletonControlledGate):
                 \end{pmatrix}
     """
 
-    _standard_gate = StandardGate.CHGate
+    _standard_gate = StandardGate.CH
 
     def __init__(
         self,
@@ -212,38 +209,18 @@ class CHGate(SingletonControlledGate):
     _singleton_lookup_key = stdlib_singleton_key(num_ctrl_qubits=1)
 
     def _define(self):
-        """
-        gate ch a,b {
-            s b;
-            h b;
-            t b;
-            cx a, b;
-            tdg b;
-            h b;
-            sdg b;
-        }
-        """
+        """Default definition"""
         # pylint: disable=cyclic-import
-        from qiskit.circuit import QuantumCircuit, QuantumRegister
-        from .x import CXGate  # pylint: disable=cyclic-import
-        from .t import TGate, TdgGate
-        from .s import SGate, SdgGate
-
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (SGate(), [q[1]], []),
-            (HGate(), [q[1]], []),
-            (TGate(), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (TdgGate(), [q[1]], []),
-            (HGate(), [q[1]], []),
-            (SdgGate(), [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 ├┤ H ├┤ T ├┤ X ├┤ Tdg ├┤ H ├┤ Sdg ├
+        #      └───┘└───┘└───┘└───┘└─────┘└───┘└─────┘
+
+        self.definition = QuantumCircuit._from_circuit_data(
+            StandardGate.CH._get_definition(self.params), add_regs=True, name=self.name
+        )
 
     def inverse(self, annotated: bool = False):
         """Return inverted CH gate (itself)."""

qiskit/circuit/library/standard_gates/i.py

@@ -47,7 +47,7 @@ class IGate(SingletonGate):
              └───┘
     """
 
-    _standard_gate = StandardGate.IGate
+    _standard_gate = StandardGate.I
 
     def __init__(self, label: Optional[str] = None):
         """Create new Identity gate."""