qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/circuit/library/standard_gates/equivalence_library.py

@@ -0,0 +1,1800 @@
+# 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.
+
+"""Standard gates."""
+
+from __future__ import annotations
+
+from math import pi
+
+from qiskit.circuit import (
+    EquivalenceLibrary,
+    Parameter,
+    QuantumCircuit,
+    QuantumRegister,
+    Gate,
+    Qubit,
+    Clbit,
+)
+
+from . import (
+    HGate,
+    CHGate,
+    PhaseGate,
+    CPhaseGate,
+    RGate,
+    RCCXGate,
+    RXGate,
+    CRXGate,
+    RXXGate,
+    RYGate,
+    CRYGate,
+    RZGate,
+    CRZGate,
+    RZZGate,
+    RZXGate,
+    SGate,
+    SdgGate,
+    CSGate,
+    CSdgGate,
+    SwapGate,
+    CSwapGate,
+    iSwapGate,
+    SXGate,
+    SXdgGate,
+    CSXGate,
+    DCXGate,
+    TGate,
+    TdgGate,
+    UGate,
+    CUGate,
+    U1Gate,
+    CU1Gate,
+    U2Gate,
+    U3Gate,
+    CU3Gate,
+    XGate,
+    CXGate,
+    CCXGate,
+    YGate,
+    CYGate,
+    RYYGate,
+    ECRGate,
+    ZGate,
+    CZGate,
+    IGate,
+    CCZGate,
+    XXPlusYYGate,
+    XXMinusYYGate,
+)
+
+
+_sel = StandardEquivalenceLibrary = EquivalenceLibrary()
+
+
+def _cnot_rxx_decompose(plus_ry: bool = True, plus_rxx: bool = True):
+    """Decomposition of CNOT gate.
+
+    NOTE: this differs to CNOT by a global phase.
+    The matrix returned is given by exp(1j * pi/4) * CNOT
+
+    Args:
+        plus_ry (bool): positive initial RY rotation
+        plus_rxx (bool): positive RXX rotation.
+
+    Returns:
+        QuantumCircuit: The decomposed circuit for CNOT gate (up to
+        global phase).
+    """
+    # Convert boolean args to +/- 1 signs
+    if plus_ry:
+        sgn_ry = 1
+    else:
+        sgn_ry = -1
+    if plus_rxx:
+        sgn_rxx = 1
+    else:
+        sgn_rxx = -1
+    circuit = QuantumCircuit(2, global_phase=-sgn_ry * sgn_rxx * pi / 4)
+    circuit.append(RYGate(sgn_ry * pi / 2), [0])
+    circuit.append(RXXGate(sgn_rxx * pi / 2), [0, 1])
+    circuit.append(RXGate(-sgn_rxx * pi / 2), [0])
+    circuit.append(RXGate(-sgn_rxx * sgn_ry * pi / 2), [1])
+    circuit.append(RYGate(-sgn_ry * pi / 2), [0])
+    return circuit
+
+
+# Import existing gate definitions
+
+# HGate
+#
+#    ┌───┐        ┌─────────┐
+# q: ┤ H ├  ≡  q: ┤ U2(0,π) ├
+#    └───┘        └─────────┘
+q = QuantumRegister(1, "q")
+def_h = QuantumCircuit(q)
+def_h.append(U2Gate(0, pi), [q[0]], [])
+_sel.add_equivalence(HGate(), def_h)
+
+# CHGate
+#
+# q_0: ──■──     q_0: ─────────────────■─────────────────────
+#      ┌─┴─┐  ≡       ┌───┐┌───┐┌───┐┌─┴─┐┌─────┐┌───┐┌─────┐
+# q_1: ┤ H ├     q_1: ┤ S ├┤ H ├┤ T ├┤ X ├┤ Tdg ├┤ H ├┤ Sdg ├
+#      └───┘          └───┘└───┘└───┘└───┘└─────┘└───┘└─────┘
+q = QuantumRegister(2, "q")
+def_ch = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (SGate(), [q[1]], []),
+    (HGate(), [q[1]], []),
+    (TGate(), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (TdgGate(), [q[1]], []),
+    (HGate(), [q[1]], []),
+    (SdgGate(), [q[1]], []),
+]:
+    def_ch.append(inst, qargs, cargs)
+_sel.add_equivalence(CHGate(), def_ch)
+
+# PhaseGate
+#
+#    ┌──────┐        ┌───────┐
+# q: ┤ P(ϴ) ├  ≡  q: ┤ U1(ϴ) ├
+#    └──────┘        └───────┘
+q = QuantumRegister(1, "q")
+theta = Parameter("theta")
+phase_to_u1 = QuantumCircuit(q)
+phase_to_u1.append(U1Gate(theta), [0])
+_sel.add_equivalence(PhaseGate(theta), phase_to_u1)
+
+q = QuantumRegister(1, "q")
+theta = Parameter("theta")
+phase_to_u = QuantumCircuit(q)
+phase_to_u.u(0, 0, theta, 0)
+_sel.add_equivalence(PhaseGate(theta), phase_to_u)
+
+# CPhaseGate
+#                      ┌────────┐
+# q_0: ─■────     q_0: ┤ P(ϴ/2) ├──■───────────────■────────────
+#       │P(ϴ)  ≡       └────────┘┌─┴─┐┌─────────┐┌─┴─┐┌────────┐
+# q_1: ─■────     q_1: ──────────┤ X ├┤ P(-ϴ/2) ├┤ X ├┤ P(ϴ/2) ├
+#                                └───┘└─────────┘└───┘└────────┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+def_cphase = QuantumCircuit(q)
+def_cphase.p(theta / 2, 0)
+def_cphase.cx(0, 1)
+def_cphase.p(-theta / 2, 1)
+def_cphase.cx(0, 1)
+def_cphase.p(theta / 2, 1)
+_sel.add_equivalence(CPhaseGate(theta), def_cphase)
+
+# CPhaseGate
+#
+# q_0: ─■────     q_0: ─■────
+#       │P(ϴ)  ≡        │U1(ϴ)
+# q_1: ─■────     q_1: ─■────
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+cphase_to_cu1 = QuantumCircuit(q)
+cphase_to_cu1.append(CU1Gate(theta), [0, 1])
+_sel.add_equivalence(CPhaseGate(theta), cphase_to_cu1)
+
+# CPhaseGate
+#
+#                  global phase: ϴ/4
+#                                  ┌─────────┐
+#  q_0: ─■────     q_0: ─■─────────┤ Rz(ϴ/2) ├
+#        │P(ϴ)  ≡        │ZZ(-ϴ/2) ├─────────┤
+#  q_1: ─■────     q_1: ─■─────────┤ Rz(ϴ/2) ├
+#                                  └─────────┘
+theta = Parameter("theta")
+cphase_to_rzz = QuantumCircuit(2, global_phase=theta / 4)
+cphase_to_rzz.rzz(-theta / 2, 0, 1)
+cphase_to_rzz.rz(theta / 2, 0)
+cphase_to_rzz.rz(theta / 2, 1)
+_sel.add_equivalence(CPhaseGate(theta), cphase_to_rzz)
+
+# RGate
+#
+#    ┌────────┐        ┌───────────────────────┐
+# q: ┤ R(ϴ,φ) ├  ≡  q: ┤ U3(ϴ,φ - π/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]])
+_sel.add_equivalence(RGate(theta, phi), def_r)
+
+# IGate
+q = QuantumRegister(1, "q")
+def_id = QuantumCircuit(q)
+def_id.append(UGate(0, 0, 0), [q[0]])
+_sel.add_equivalence(IGate(), def_id)
+
+q = QuantumRegister(1, "q")
+def_id_rx = QuantumCircuit(q)
+def_id_rx.append(RXGate(0), [q[0]])
+_sel.add_equivalence(IGate(), def_id_rx)
+
+q = QuantumRegister(1, "q")
+def_id_ry = QuantumCircuit(q)
+def_id_ry.append(RYGate(0), [q[0]])
+_sel.add_equivalence(IGate(), def_id_ry)
+
+q = QuantumRegister(1, "q")
+def_id_rz = QuantumCircuit(q)
+def_id_rz.append(RZGate(0), [q[0]])
+_sel.add_equivalence(IGate(), def_id_rz)
+
+# RCCXGate
+#
+#      ┌───────┐
+# q_0: ┤0      ├     q_0: ────────────────────────■────────────────────────
+#      │       │                                  │
+# q_1: ┤1 Rccx ├  ≡  q_1: ────────────■───────────┼─────────■──────────────
+#      │       │          ┌───┐┌───┐┌─┴─┐┌─────┐┌─┴─┐┌───┐┌─┴─┐┌─────┐┌───┐
+# q_2: ┤2      ├     q_2: ┤ H ├┤ T ├┤ X ├┤ Tdg ├┤ X ├┤ T ├┤ X ├┤ Tdg ├┤ H ├
+#      └───────┘          └───┘└───┘└───┘└─────┘└───┘└───┘└───┘└─────┘└───┘
+q = QuantumRegister(3, "q")
+def_rccx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[2]], []),
+    (TGate(), [q[2]], []),
+    (CXGate(), [q[1], q[2]], []),
+    (TdgGate(), [q[2]], []),
+    (CXGate(), [q[0], q[2]], []),
+    (TGate(), [q[2]], []),
+    (CXGate(), [q[1], q[2]], []),
+    (TdgGate(), [q[2]], []),
+    (HGate(), [q[2]], []),
+]:
+    def_rccx.append(inst, qargs, cargs)
+_sel.add_equivalence(RCCXGate(), def_rccx)
+
+# RXGate
+#
+#    ┌───────┐        ┌────────┐
+# q: ┤ Rx(ϴ) ├  ≡  q: ┤ R(ϴ,0) ├
+#    └───────┘        └────────┘
+q = QuantumRegister(1, "q")
+theta = Parameter("theta")
+def_rx = QuantumCircuit(q)
+def_rx.append(RGate(theta, 0), [q[0]], [])
+_sel.add_equivalence(RXGate(theta), def_rx)
+
+# CRXGate
+#
+# q_0: ────■────     q_0: ─────────────■────────────────────■────────────────────
+#      ┌───┴───┐  ≡       ┌─────────┐┌─┴─┐┌──────────────┐┌─┴─┐┌────────────────┐
+# q_1: ┤ Rx(ϴ) ├     q_1: ┤ U1(π/2) ├┤ X ├┤ U3(-ϴ/2,0,0) ├┤ X ├┤ U3(ϴ/2,-π/2,0) ├
+#      └───────┘          └─────────┘└───┘└──────────────┘└───┘└────────────────┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+def_crx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (U1Gate(pi / 2), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (U3Gate(-theta / 2, 0, 0), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (U3Gate(theta / 2, -pi / 2, 0), [q[1]], []),
+]:
+    def_crx.append(inst, qargs, cargs)
+_sel.add_equivalence(CRXGate(theta), def_crx)
+
+# CRXGate
+#
+# q_0: ────■────     q_0: ───────■────────────────■────────────────────
+#      ┌───┴───┐  ≡       ┌───┐┌─┴─┐┌──────────┐┌─┴─┐┌─────────┐┌─────┐
+# q_1: ┤ Rx(ϴ) ├     q_1: ┤ S ├┤ X ├┤ Ry(-ϴ/2) ├┤ X ├┤ Ry(ϴ/2) ├┤ Sdg ├
+#      └───────┘          └───┘└───┘└──────────┘└───┘└─────────┘└─────┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+crx_to_srycx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (SGate(), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (RYGate(-theta / 2), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (RYGate(theta / 2), [q[1]], []),
+    (SdgGate(), [q[1]], []),
+]:
+    crx_to_srycx.append(inst, qargs, cargs)
+_sel.add_equivalence(CRXGate(theta), crx_to_srycx)
+
+# CRX in terms of one RXX
+#                          ┌───┐   ┌────────────┐┌───┐
+# q_0: ────■────   q_0: ───┤ H ├───┤0           ├┤ H ├
+#      ┌───┴───┐ ≡      ┌──┴───┴──┐│  Rxx(-ϴ/2) │└───┘
+# q_1: ┤ Rx(ϴ) ├   q_1: ┤ Rx(ϴ/2) ├┤1           ├─────
+#      └───────┘        └─────────┘└────────────┘
+theta = Parameter("theta")
+crx_to_rxx = QuantumCircuit(2)
+crx_to_rxx.h(0)
+crx_to_rxx.rx(theta / 2, 1)
+crx_to_rxx.rxx(-theta / 2, 0, 1)
+crx_to_rxx.h(0)
+_sel.add_equivalence(CRXGate(theta), crx_to_rxx)
+
+# CRX to CRZ
+#
+# q_0: ────■────     q_0: ─────────■─────────
+#      ┌───┴───┐  ≡       ┌───┐┌───┴───┐┌───┐
+# q_1: ┤ Rx(ϴ) ├     q_1: ┤ H ├┤ Rz(ϴ) ├┤ H ├
+#      └───────┘          └───┘└───────┘└───┘
+theta = Parameter("theta")
+crx_to_crz = QuantumCircuit(2)
+crx_to_crz.h(1)
+crx_to_crz.crz(theta, 0, 1)
+crx_to_crz.h(1)
+_sel.add_equivalence(CRXGate(theta), crx_to_crz)
+
+# RXXGate
+#
+#      ┌─────────┐          ┌───┐                   ┌───┐
+# q_0: ┤0        ├     q_0: ┤ H ├──■─────────────■──┤ H ├
+#      │  Rxx(ϴ) │  ≡       ├───┤┌─┴─┐┌───────┐┌─┴─┐├───┤
+# q_1: ┤1        ├     q_1: ┤ H ├┤ X ├┤ Rz(ϴ) ├┤ X ├┤ H ├
+#      └─────────┘          └───┘└───┘└───────┘└───┘└───┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+def_rxx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (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]], []),
+]:
+    def_rxx.append(inst, qargs, cargs)
+_sel.add_equivalence(RXXGate(theta), def_rxx)
+
+# RXX to RZX
+#      ┌─────────┐        ┌───┐┌─────────┐┌───┐
+# q_0: ┤0        ├   q_0: ┤ H ├┤0        ├┤ H ├
+#      │  Rxx(ϴ) │ ≡      └───┘│  Rzx(ϴ) │└───┘
+# q_1: ┤1        ├   q_1: ─────┤1        ├─────
+#      └─────────┘             └─────────┘
+theta = Parameter("theta")
+rxx_to_rzx = QuantumCircuit(2)
+rxx_to_rzx.h(0)
+rxx_to_rzx.rzx(theta, 0, 1)
+rxx_to_rzx.h(0)
+_sel.add_equivalence(RXXGate(theta), rxx_to_rzx)
+
+
+# RXX to RZZ
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+rxx_to_rzz = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[0]], []),
+    (HGate(), [q[1]], []),
+    (RZZGate(theta), [q[0], q[1]], []),
+    (HGate(), [q[0]], []),
+    (HGate(), [q[1]], []),
+]:
+    rxx_to_rzz.append(inst, qargs, cargs)
+_sel.add_equivalence(RXXGate(theta), rxx_to_rzz)
+
+# RZXGate
+#
+#      ┌─────────┐
+# q_0: ┤0        ├     q_0: ───────■─────────────■───────
+#      │  Rzx(ϴ) │  ≡       ┌───┐┌─┴─┐┌───────┐┌─┴─┐┌───┐
+# q_1: ┤1        ├     q_1: ┤ H ├┤ X ├┤ Rz(ϴ) ├┤ X ├┤ H ├
+#      └─────────┘          └───┘└───┘└───────┘└───┘└───┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+def_rzx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (RZGate(theta), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (HGate(), [q[1]], []),
+]:
+    def_rzx.append(inst, qargs, cargs)
+_sel.add_equivalence(RZXGate(theta), def_rzx)
+
+# RZXGate to RZZGate
+#      ┌─────────┐
+# q_0: ┤0        ├     q_0: ──────■───────────
+#      │  Rzx(ϴ) │  ≡       ┌───┐ │ZZ(ϴ) ┌───┐
+# q_1: ┤1        ├     q_1: ┤ H ├─■──────┤ H ├
+#      └─────────┘          └───┘        └───┘
+theta = Parameter("theta")
+rzx_to_rzz = QuantumCircuit(2)
+rzx_to_rzz.h(1)
+rzx_to_rzz.rzz(theta, 0, 1)
+rzx_to_rzz.h(1)
+_sel.add_equivalence(RZXGate(theta), rzx_to_rzz)
+
+
+# RYGate
+#
+#    ┌───────┐        ┌──────────┐
+# q: ┤ Ry(ϴ) ├  ≡  q: ┤ R(ϴ,π/2) ├
+#    └───────┘        └──────────┘
+q = QuantumRegister(1, "q")
+theta = Parameter("theta")
+def_ry = QuantumCircuit(q)
+def_ry.append(RGate(theta, pi / 2), [q[0]], [])
+_sel.add_equivalence(RYGate(theta), def_ry)
+
+q = QuantumRegister(1, "q")
+ry_to_rx = QuantumCircuit(q)
+ry_to_rx.sdg(0)
+ry_to_rx.rx(theta, 0)
+ry_to_rx.s(0)
+_sel.add_equivalence(RYGate(theta), ry_to_rx)
+
+# CRYGate
+#
+# q_0: ────■────      q_0: ─────────────■────────────────■──
+#      ┌───┴───┐   ≡       ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐
+# q_1: ┤ Ry(ϴ) ├      q_1: ┤ Ry(ϴ/2) ├┤ X ├┤ Ry(-ϴ/2) ├┤ X ├
+#      └───────┘           └─────────┘└───┘└──────────┘└───┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+def_cry = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (RYGate(theta / 2), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (RYGate(-theta / 2), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+]:
+    def_cry.append(inst, qargs, cargs)
+_sel.add_equivalence(CRYGate(theta), def_cry)
+
+# CRY to CRZ
+#
+# q_0: ────■────     q_0: ───────────────■────────────────
+#      ┌───┴───┐  ≡       ┌─────────┐┌───┴───┐┌──────────┐
+# q_1: ┤ Ry(ϴ) ├     q_1: ┤ Rx(π/2) ├┤ Rz(ϴ) ├┤ Rx(-π/2) ├
+#      └───────┘          └─────────┘└───────┘└──────────┘
+theta = Parameter("theta")
+cry_to_crz = QuantumCircuit(2)
+cry_to_crz.rx(pi / 2, 1)
+cry_to_crz.crz(theta, 0, 1)
+cry_to_crz.rx(-pi / 2, 1)
+_sel.add_equivalence(CRYGate(theta), cry_to_crz)
+
+# CRY to CRZ
+#
+# q_0: ────■────     q_0: ────────────────────■─────────────────────
+#      ┌───┴───┐  ≡       ┌───┐┌─────────┐┌───┴───┐┌──────────┐┌───┐
+# q_1: ┤ Ry(ϴ) ├     q_1: ┤ H ├┤ Rz(π/2) ├┤ Rx(ϴ) ├┤ Rz(-π/2) ├┤ H ├
+#      └───────┘          └───┘└─────────┘└───────┘└──────────┘└───┘
+theta = Parameter("theta")
+cry_to_crx = QuantumCircuit(2)
+cry_to_crx.h(1)
+cry_to_crx.rz(pi / 2, 1)
+cry_to_crx.crx(theta, 0, 1)
+cry_to_crx.rz(-pi / 2, 1)
+cry_to_crx.h(1)
+_sel.add_equivalence(CRYGate(theta), cry_to_crx)
+
+# CRY to RZZ
+#
+# q_0: ────■────    q_0: ────────────────────────■───────────────────
+#      ┌───┴───┐  ≡      ┌─────┐┌─────────┐┌───┐ │ZZ(-ϴ/2) ┌───┐┌───┐
+# q_1: ┤ Ry(ϴ) ├    q_1: ┤ Sdg ├┤ Rx(ϴ/2) ├┤ H ├─■─────────┤ H ├┤ S ├
+#      └───────┘         └─────┘└─────────┘└───┘           └───┘└───┘
+cry_to_rzz = QuantumCircuit(2)
+cry_to_rzz.sdg(1)
+cry_to_rzz.rx(theta / 2, 1)
+cry_to_rzz.h(1)
+cry_to_rzz.rzz(-theta / 2, 0, 1)
+cry_to_rzz.h(1)
+cry_to_rzz.s(1)
+_sel.add_equivalence(CRYGate(theta), cry_to_rzz)
+
+# RYYGate
+#
+#      ┌─────────┐          ┌─────────┐                   ┌──────────┐
+# q_0: ┤0        ├     q_0: ┤ Rx(π/2) ├──■─────────────■──┤ Rx(-π/2) ├
+#      │  Ryy(ϴ) │  ≡       ├─────────┤┌─┴─┐┌───────┐┌─┴─┐├──────────┤
+# q_1: ┤1        ├     q_1: ┤ Rx(π/2) ├┤ X ├┤ Rz(ϴ) ├┤ X ├┤ Rx(-π/2) ├
+#      └─────────┘          └─────────┘└───┘└───────┘└───┘└──────────┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+def_ryy = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (RXGate(pi / 2), [q[0]], []),
+    (RXGate(pi / 2), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (RZGate(theta), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (RXGate(-pi / 2), [q[0]], []),
+    (RXGate(-pi / 2), [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")
+ryy_to_rzz = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (RXGate(pi / 2), [q[0]], []),
+    (RXGate(pi / 2), [q[1]], []),
+    (RZZGate(theta), [q[0], q[1]], []),
+    (RXGate(-pi / 2), [q[0]], []),
+    (RXGate(-pi / 2), [q[1]], []),
+]:
+    ryy_to_rzz.append(inst, qargs, cargs)
+_sel.add_equivalence(RYYGate(theta), ryy_to_rzz)
+
+# RYY to RXX
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+ryy_to_rxx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (SdgGate(), [q[0]], []),
+    (SdgGate(), [q[1]], []),
+    (RXXGate(theta), [q[0], q[1]], []),
+    (SGate(), [q[0]], []),
+    (SGate(), [q[1]], []),
+]:
+    ryy_to_rxx.append(inst, qargs, cargs)
+_sel.add_equivalence(RYYGate(theta), ryy_to_rxx)
+
+# RZGate
+#                  global phase: -ϴ/2
+#    ┌───────┐        ┌───────┐
+# q: ┤ Rz(ϴ) ├  ≡  q: ┤ U1(ϴ) ├
+#    └───────┘        └───────┘
+q = QuantumRegister(1, "q")
+theta = Parameter("theta")
+def_rz = QuantumCircuit(q, global_phase=-theta / 2)
+def_rz.append(U1Gate(theta), [q[0]], [])
+_sel.add_equivalence(RZGate(theta), def_rz)
+
+# RZGate
+#
+#    ┌───────┐        ┌────┐┌────────┐┌──────┐
+# q: ┤ Rz(ϴ) ├  ≡  q: ┤ √X ├┤ Ry(-ϴ) ├┤ √Xdg ├
+#    └───────┘        └────┘└────────┘└──────┘
+q = QuantumRegister(1, "q")
+rz_to_sxry = QuantumCircuit(q)
+rz_to_sxry.sx(0)
+rz_to_sxry.ry(-theta, 0)
+rz_to_sxry.sxdg(0)
+_sel.add_equivalence(RZGate(theta), rz_to_sxry)
+
+q = QuantumRegister(1, "q")
+rz_to_rx = QuantumCircuit(q)
+rz_to_rx.h(0)
+rz_to_rx.rx(theta, 0)
+rz_to_rx.h(0)
+_sel.add_equivalence(RZGate(theta), rz_to_rx)
+
+# CRZGate
+#
+# q_0: ────■────     q_0: ─────────────■────────────────■──
+#      ┌───┴───┐  ≡       ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐
+# q_1: ┤ Rz(ϴ) ├     q_1: ┤ Rz(ϴ/2) ├┤ X ├┤ Rz(-ϴ/2) ├┤ X ├
+#      └───────┘          └─────────┘└───┘└──────────┘└───┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+def_crz = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (RZGate(theta / 2), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (RZGate(-theta / 2), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+]:
+    def_crz.append(inst, qargs, cargs)
+_sel.add_equivalence(CRZGate(theta), def_crz)
+
+# CRZ to CRY
+#
+# q_0: ────■────     q_0: ────────────────■───────────────
+#      ┌───┴───┐  ≡       ┌──────────┐┌───┴───┐┌─────────┐
+# q_1: ┤ Rz(ϴ) ├     q_1: ┤ Rx(-π/2) ├┤ Ry(ϴ) ├┤ Rx(π/2) ├
+#      └───────┘          └──────────┘└───────┘└─────────┘
+theta = Parameter("theta")
+crz_to_cry = QuantumCircuit(2)
+crz_to_cry.rx(-pi / 2, 1)
+crz_to_cry.cry(theta, 0, 1)
+crz_to_cry.rx(pi / 2, 1)
+_sel.add_equivalence(CRZGate(theta), crz_to_cry)
+
+# CRZ to CRX
+#
+# q_0: ────■────     q_0: ─────────■─────────
+#      ┌───┴───┐  ≡       ┌───┐┌───┴───┐┌───┐
+# q_1: ┤ Rz(ϴ) ├     q_1: ┤ H ├┤ Rx(ϴ) ├┤ H ├
+#      └───────┘          └───┘└───────┘└───┘
+theta = Parameter("theta")
+crz_to_crx = QuantumCircuit(2)
+crz_to_crx.h(1)
+crz_to_crx.crx(theta, 0, 1)
+crz_to_crx.h(1)
+_sel.add_equivalence(CRZGate(theta), crz_to_crx)
+
+# CRZ to RZZ
+#
+# q_0: ────■────    q_0: ────────────■────────
+#      ┌───┴───┐  ≡      ┌─────────┐ │ZZ(-ϴ/2)
+# q_1: ┤ Rz(ϴ) ├    q_1: ┤ Rz(ϴ/2) ├─■────────
+#      └───────┘         └─────────┘
+theta = Parameter("theta")
+crz_to_rzz = QuantumCircuit(2)
+crz_to_rzz.rz(theta / 2, 1)
+crz_to_rzz.rzz(-theta / 2, 0, 1)
+_sel.add_equivalence(CRZGate(theta), crz_to_rzz)
+
+# RZZGate
+#
+# q_0: ─■─────     q_0: ──■─────────────■──
+#       │ZZ(ϴ)  ≡       ┌─┴─┐┌───────┐┌─┴─┐
+# q_1: ─■─────     q_1: ┤ X ├┤ Rz(ϴ) ├┤ X ├
+#                       └───┘└───────┘└───┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+def_rzz = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (CXGate(), [q[0], q[1]], []),
+    (RZGate(theta), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+]:
+    def_rzz.append(inst, qargs, cargs)
+_sel.add_equivalence(RZZGate(theta), def_rzz)
+
+# RZZ to RXX
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+rzz_to_rxx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[0]], []),
+    (HGate(), [q[1]], []),
+    (RXXGate(theta), [q[0], q[1]], []),
+    (HGate(), [q[0]], []),
+    (HGate(), [q[1]], []),
+]:
+    rzz_to_rxx.append(inst, qargs, cargs)
+_sel.add_equivalence(RZZGate(theta), rzz_to_rxx)
+
+# RZZ to RZX
+#                          ┌─────────┐
+# q_0: ─■─────   q_0: ─────┤0        ├─────
+#       │ZZ(ϴ) ≡      ┌───┐│  Rzx(ϴ) │┌───┐
+# q_1: ─■─────   q_1: ┤ H ├┤1        ├┤ H ├
+#                     └───┘└─────────┘└───┘
+theta = Parameter("theta")
+rzz_to_rzx = QuantumCircuit(2)
+rzz_to_rzx.h(1)
+rzz_to_rzx.rzx(theta, 0, 1)
+rzz_to_rzx.h(1)
+_sel.add_equivalence(RZZGate(theta), rzz_to_rzx)
+
+# RZZ to CPhase
+#
+#                 global phase: ϴ/2
+#                                ┌───────┐
+#  q_0: ─■─────   q_0: ─■────────┤ Rz(ϴ) ├
+#        │ZZ(ϴ) ≡       │P(-2*ϴ) ├───────┤
+#  q_1: ─■─────   q_1: ─■────────┤ Rz(ϴ) ├
+#                                └───────┘
+theta = Parameter("theta")
+rzz_to_cphase = QuantumCircuit(2, global_phase=theta / 2)
+rzz_to_cphase.cp(-theta * 2, 0, 1)
+rzz_to_cphase.rz(theta, 0)
+rzz_to_cphase.rz(theta, 1)
+_sel.add_equivalence(RZZGate(theta), rzz_to_cphase)
+
+# RZZ to RYY
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+rzz_to_ryy = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (RXGate(-pi / 2), [q[0]], []),
+    (RXGate(-pi / 2), [q[1]], []),
+    (RYYGate(theta), [q[0], q[1]], []),
+    (RXGate(pi / 2), [q[0]], []),
+    (RXGate(pi / 2), [q[1]], []),
+]:
+    rzz_to_ryy.append(inst, qargs, cargs)
+_sel.add_equivalence(RZZGate(theta), rzz_to_ryy)
+
+# RZXGate
+#
+#      ┌─────────┐
+# q_0: ┤0        ├     q_0: ───────■─────────────■───────
+#      │  Rzx(ϴ) │  ≡       ┌───┐┌─┴─┐┌───────┐┌─┴─┐┌───┐
+# q_1: ┤1        ├     q_1: ┤ H ├┤ X ├┤ Rz(ϴ) ├┤ X ├┤ H ├
+#      └─────────┘          └───┘└───┘└───────┘└───┘└───┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+def_rzx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (RZGate(theta), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (HGate(), [q[1]], []),
+]:
+    def_rzx.append(inst, qargs, cargs)
+_sel.add_equivalence(RZXGate(theta), def_rzx)
+
+# ECRGate
+#
+#      ┌──────┐          ┌───────────┐┌───┐┌────────────┐
+# q_0: ┤0     ├     q_0: ┤0          ├┤ X ├┤0           ├
+#      │  Ecr │  ≡       │  Rzx(π/4) │└───┘│  Rzx(-π/4) │
+# q_1: ┤1     ├     q_1: ┤1          ├─────┤1           ├
+#      └──────┘          └───────────┘     └────────────┘
+q = QuantumRegister(2, "q")
+def_ecr = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (RZXGate(pi / 4), [q[0], q[1]], []),
+    (XGate(), [q[0]], []),
+    (RZXGate(-pi / 4), [q[0], q[1]], []),
+]:
+    def_ecr.append(inst, qargs, cargs)
+_sel.add_equivalence(ECRGate(), def_ecr)
+
+# ECRGate decomposed to Clifford gates (up to a global phase)
+#
+#                  global phase: 7π/4
+#      ┌──────┐         ┌───┐      ┌───┐
+# q_0: ┤0     ├    q_0: ┤ S ├───■──┤ X ├
+#      │  Ecr │  ≡      ├───┴┐┌─┴─┐└───┘
+# q_1: ┤1     ├    q_1: ┤ √X ├┤ X ├─────
+#      └──────┘         └────┘└───┘
+
+q = QuantumRegister(2, "q")
+def_ecr_cliff = QuantumCircuit(q, global_phase=-pi / 4)
+for inst, qargs, cargs in [
+    (SGate(), [q[0]], []),
+    (SXGate(), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (XGate(), [q[0]], []),
+]:
+    def_ecr_cliff.append(inst, qargs, cargs)
+_sel.add_equivalence(ECRGate(), def_ecr_cliff)
+
+# CXGate decomposed using an ECRGate and Clifford 1-qubit gates
+#                global phase: π/4
+# q_0: ──■──          ┌─────┐ ┌──────┐┌───┐
+#      ┌─┴─┐  ≡  q_0: ┤ Sdg ├─┤0     ├┤ X ├
+# q_1: ┤ X ├          ├─────┴┐│  Ecr │└───┘
+#      └───┘     q_1: ┤ √Xdg ├┤1     ├─────
+#                     └──────┘└──────┘
+
+q = QuantumRegister(2, "q")
+def_ecr_to_cx_cliff = QuantumCircuit(q, global_phase=pi / 4)
+for inst, qargs, cargs in [
+    (SdgGate(), [q[0]], []),
+    (SXdgGate(), [q[1]], []),
+    (ECRGate(), [q[0], q[1]], []),
+    (XGate(), [q[0]], []),
+]:
+    def_ecr_to_cx_cliff.append(inst, qargs, cargs)
+_sel.add_equivalence(CXGate(), def_ecr_to_cx_cliff)
+
+# SGate
+#
+#    ┌───┐        ┌─────────┐
+# q: ┤ S ├  ≡  q: ┤ U1(π/2) ├
+#    └───┘        └─────────┘
+q = QuantumRegister(1, "q")
+def_s = QuantumCircuit(q)
+def_s.append(U1Gate(pi / 2), [q[0]], [])
+_sel.add_equivalence(SGate(), def_s)
+
+# SdgGate
+#
+#    ┌─────┐        ┌──────────┐
+# q: ┤ Sdg ├  ≡  q: ┤ U1(-π/2) ├
+#    └─────┘        └──────────┘
+q = QuantumRegister(1, "q")
+def_sdg = QuantumCircuit(q)
+def_sdg.append(U1Gate(-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
+#
+#    ┌─────┐        ┌───┐┌───┐
+# q: ┤ Sdg ├  ≡  q: ┤ S ├┤ Z ├
+#    └─────┘        └───┘└───┘
+q = QuantumRegister(1, "q")
+def_sdg = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (SGate(), [q[0]], []),
+    (ZGate(), [q[0]], []),
+]:
+    def_sdg.append(inst, qargs, cargs)
+_sel.add_equivalence(SdgGate(), def_sdg)
+
+# SdgGate
+#
+#    ┌─────┐        ┌───┐┌───┐
+# q: ┤ Sdg ├  ≡  q: ┤ Z ├┤ S ├
+#    └─────┘        └───┘└───┘
+q = QuantumRegister(1, "q")
+def_sdg = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (ZGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+]:
+    def_sdg.append(inst, qargs, cargs)
+_sel.add_equivalence(SdgGate(), def_sdg)
+
+# SdgGate
+#
+#    ┌─────┐        ┌───┐┌───┐┌───┐
+# q: ┤ Sdg ├  ≡  q: ┤ S ├┤ S ├┤ S ├
+#    └─────┘        └───┘└───┘└───┘
+q = QuantumRegister(1, "q")
+def_sdg = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (SGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+]:
+    def_sdg.append(inst, qargs, cargs)
+_sel.add_equivalence(SdgGate(), def_sdg)
+
+# SwapGate
+#                        ┌───┐
+# q_0: ─X─     q_0: ──■──┤ X ├──■──
+#       │   ≡       ┌─┴─┐└─┬─┘┌─┴─┐
+# q_1: ─X─     q_1: ┤ X ├──■──┤ X ├
+#                   └───┘     └───┘
+q = QuantumRegister(2, "q")
+def_swap = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (CXGate(), [q[0], q[1]], []),
+    (CXGate(), [q[1], q[0]], []),
+    (CXGate(), [q[0], q[1]], []),
+]:
+    def_swap.append(inst, qargs, cargs)
+_sel.add_equivalence(SwapGate(), def_swap)
+
+# SwapGate
+#
+# q_0: ─X─
+#       │   ≡
+# q_1: ─X─
+#
+#      ┌──────────┐┌──────┐   ┌────┐   ┌──────┐┌──────────┐┌──────┐
+# q_0: ┤ Rz(-π/2) ├┤0     ├───┤ √X ├───┤1     ├┤ Rz(-π/2) ├┤0     ├
+#      └──┬────┬──┘│  Ecr │┌──┴────┴──┐│  Ecr │└──┬────┬──┘│  Ecr │
+# q_1: ───┤ √X ├───┤1     ├┤ Rz(-π/2) ├┤0     ├───┤ √X ├───┤1     ├
+#         └────┘   └──────┘└──────────┘└──────┘   └────┘   └──────┘
+#
+q = QuantumRegister(2, "q")
+def_swap_ecr = QuantumCircuit(q)
+def_swap_ecr.rz(-pi / 2, 0)
+def_swap_ecr.sx(1)
+def_swap_ecr.ecr(0, 1)
+def_swap_ecr.rz(-pi / 2, 1)
+def_swap_ecr.sx(0)
+def_swap_ecr.ecr(1, 0)
+def_swap_ecr.rz(-pi / 2, 0)
+def_swap_ecr.sx(1)
+def_swap_ecr.ecr(0, 1)
+_sel.add_equivalence(SwapGate(), def_swap_ecr)
+
+# SwapGate
+#
+# q_0: ─X─
+#       │   ≡
+# q_1: ─X─
+#
+# global phase: 3π/2
+#      ┌────┐   ┌────┐   ┌────┐
+# q_0: ┤ √X ├─■─┤ √X ├─■─┤ √X ├─■─
+#      ├────┤ │ ├────┤ │ ├────┤ │
+# q_1: ┤ √X ├─■─┤ √X ├─■─┤ √X ├─■─
+#      └────┘   └────┘   └────┘
+q = QuantumRegister(2, "q")
+def_swap_cz = QuantumCircuit(q, global_phase=-pi / 2)
+def_swap_cz.sx(0)
+def_swap_cz.sx(1)
+def_swap_cz.cz(0, 1)
+def_swap_cz.sx(0)
+def_swap_cz.sx(1)
+def_swap_cz.cz(0, 1)
+def_swap_cz.sx(0)
+def_swap_cz.sx(1)
+def_swap_cz.cz(0, 1)
+_sel.add_equivalence(SwapGate(), def_swap_cz)
+
+# iSwapGate
+#
+#      ┌────────┐          ┌───┐┌───┐     ┌───┐
+# q_0: ┤0       ├     q_0: ┤ S ├┤ H ├──■──┤ X ├─────
+#      │  Iswap │  ≡       ├───┤└───┘┌─┴─┐└─┬─┘┌───┐
+# q_1: ┤1       ├     q_1: ┤ S ├─────┤ X ├──■──┤ H ├
+#      └────────┘          └───┘     └───┘     └───┘
+q = QuantumRegister(2, "q")
+def_iswap = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (SGate(), [q[0]], []),
+    (SGate(), [q[1]], []),
+    (HGate(), [q[0]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (CXGate(), [q[1], q[0]], []),
+    (HGate(), [q[1]], []),
+]:
+    def_iswap.append(inst, qargs, cargs)
+_sel.add_equivalence(iSwapGate(), def_iswap)
+
+# SXGate
+#               global phase: π/4
+#    ┌────┐        ┌─────┐┌───┐┌─────┐
+# q: ┤ √X ├  ≡  q: ┤ Sdg ├┤ H ├┤ Sdg ├
+#    └────┘        └─────┘└───┘└─────┘
+q = QuantumRegister(1, "q")
+def_sx = QuantumCircuit(q, global_phase=pi / 4)
+for inst, qargs, cargs in [(SdgGate(), [q[0]], []), (HGate(), [q[0]], []), (SdgGate(), [q[0]], [])]:
+    def_sx.append(inst, qargs, cargs)
+_sel.add_equivalence(SXGate(), def_sx)
+
+# HGate decomposed into SXGate and SGate
+#              global phase: -π/4
+#    ┌───┐        ┌───┐┌────┐┌───┐
+# q: ┤ H ├  ≡  q: ┤ S ├┤ √X ├┤ S ├
+#    └───┘        └───┘└────┘└───┘
+q = QuantumRegister(1, "q")
+def_h_to_sx = QuantumCircuit(q, global_phase=-pi / 4)
+for inst, qargs, cargs in [(SGate(), [q[0]], []), (SXGate(), [q[0]], []), (SGate(), [q[0]], [])]:
+    def_h_to_sx.append(inst, qargs, cargs)
+_sel.add_equivalence(HGate(), def_h_to_sx)
+
+# SXGate
+#               global phase: π/4
+#    ┌────┐        ┌─────────┐
+# q: ┤ √X ├  ≡  q: ┤ Rx(π/2) ├
+#    └────┘        └─────────┘
+q = QuantumRegister(1, "q")
+sx_to_rx = QuantumCircuit(q, global_phase=pi / 4)
+sx_to_rx.rx(pi / 2, 0)
+_sel.add_equivalence(SXGate(), sx_to_rx)
+
+# SXdgGate
+#                 global phase: 7π/4
+#    ┌──────┐        ┌───┐┌───┐┌───┐
+# q: ┤ √Xdg ├  ≡  q: ┤ S ├┤ H ├┤ S ├
+#    └──────┘        └───┘└───┘└───┘
+q = QuantumRegister(1, "q")
+def_sxdg = QuantumCircuit(q, global_phase=-pi / 4)
+for inst, qargs, cargs in [(SGate(), [q[0]], []), (HGate(), [q[0]], []), (SGate(), [q[0]], [])]:
+    def_sxdg.append(inst, qargs, cargs)
+_sel.add_equivalence(SXdgGate(), def_sxdg)
+
+# HGate decomposed into SXdgGate and SdgGate
+#              global phase: π/4
+#    ┌───┐        ┌─────┐┌──────┐┌─────┐
+# q: ┤ H ├  ≡  q: ┤ Sdg ├┤ √Xdg ├┤ Sdg ├
+#    └───┘        └─────┘└──────┘└─────┘
+q = QuantumRegister(1, "q")
+def_h_to_sxdg = QuantumCircuit(q, global_phase=pi / 4)
+for inst, qargs, cargs in [
+    (SdgGate(), [q[0]], []),
+    (SXdgGate(), [q[0]], []),
+    (SdgGate(), [q[0]], []),
+]:
+    def_h_to_sxdg.append(inst, qargs, cargs)
+_sel.add_equivalence(HGate(), def_h_to_sxdg)
+
+# SXdgGate
+#                 global phase: 7π/4
+#    ┌──────┐        ┌──────────┐
+# q: ┤ √Xdg ├  ≡  q: ┤ Rx(-π/2) ├
+#    └──────┘        └──────────┘
+q = QuantumRegister(1, "q")
+sxdg_to_rx = QuantumCircuit(q, global_phase=-pi / 4)
+sxdg_to_rx.rx(-pi / 2, 0)
+_sel.add_equivalence(SXdgGate(), sxdg_to_rx)
+
+# CSXGate
+#
+# q_0: ──■───     q_0: ──────■─────────────
+#      ┌─┴──┐  ≡       ┌───┐ │U1(π/2) ┌───┐
+# q_1: ┤ Sx ├     q_1: ┤ H ├─■────────┤ H ├
+#      └────┘          └───┘          └───┘
+q = QuantumRegister(2, "q")
+def_csx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[1]], []),
+    (CU1Gate(pi / 2), [q[0], q[1]], []),
+    (HGate(), [q[1]], []),
+]:
+    def_csx.append(inst, qargs, cargs)
+_sel.add_equivalence(CSXGate(), def_csx)
+
+# CSXGate
+#                 global phase: π/8
+#                      ┌───┐┌───────────┐ ┌─────┐  ┌───┐
+# q_0: ──■───     q_0: ┤ X ├┤0          ├─┤ Tdg ├──┤ X ├
+#      ┌─┴──┐  ≡       └───┘│  Rzx(π/4) │┌┴─────┴─┐└───┘
+# q_1: ┤ Sx ├     q_1: ─────┤1          ├┤ sx^0.5 ├─────
+#      └────┘               └───────────┘└────────┘
+q = QuantumRegister(2, "q")
+csx_to_zx45 = QuantumCircuit(q, global_phase=pi / 4)
+for inst, qargs, cargs in [
+    (XGate(), [q[0]], []),
+    (RZXGate(pi / 4), [q[0], q[1]], []),
+    (TdgGate(), [q[0]], []),
+    (XGate(), [q[0]], []),
+    (RXGate(pi / 4), [q[1]], []),
+]:
+    csx_to_zx45.append(inst, qargs, cargs)
+_sel.add_equivalence(CSXGate(), csx_to_zx45)
+
+
+# DCXGate
+#
+#      ┌──────┐               ┌───┐
+# q_0: ┤0     ├     q_0: ──■──┤ X ├
+#      │  Dcx │  ≡       ┌─┴─┐└─┬─┘
+# q_1: ┤1     ├     q_1: ┤ X ├──■──
+#      └──────┘          └───┘
+q = QuantumRegister(2, "q")
+def_dcx = QuantumCircuit(q)
+for inst, qargs, cargs in [(CXGate(), [q[0], q[1]], []), (CXGate(), [q[1], q[0]], [])]:
+    def_dcx.append(inst, qargs, cargs)
+_sel.add_equivalence(DCXGate(), def_dcx)
+
+# DCXGate
+#
+#      ┌──────┐           ┌───┐ ┌─────┐┌────────┐
+# q_0: ┤0     ├     q_0: ─┤ H ├─┤ Sdg ├┤0       ├─────
+#      │  Dcx │  ≡       ┌┴───┴┐└─────┘│  Iswap │┌───┐
+# q_1: ┤1     ├     q_1: ┤ Sdg ├───────┤1       ├┤ H ├
+#      └──────┘          └─────┘       └────────┘└───┘
+q = QuantumRegister(2, "q")
+dcx_to_iswap = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[0]], []),
+    (SdgGate(), [q[0]], []),
+    (SdgGate(), [q[1]], []),
+    (iSwapGate(), [q[0], q[1]], []),
+    (HGate(), [q[1]], []),
+]:
+    dcx_to_iswap.append(inst, qargs, cargs)
+_sel.add_equivalence(DCXGate(), dcx_to_iswap)
+
+# CSwapGate
+#
+# q_0: ─■─     q_0: ───────■───────
+#       │           ┌───┐  │  ┌───┐
+# q_1: ─X─  ≡  q_1: ┤ X ├──■──┤ X ├
+#       │           └─┬─┘┌─┴─┐└─┬─┘
+# q_2: ─X─     q_2: ──■──┤ X ├──■──
+#                        └───┘
+q = QuantumRegister(3, "q")
+def_cswap = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (CXGate(), [q[2], q[1]], []),
+    (CCXGate(), [q[0], q[1], q[2]], []),
+    (CXGate(), [q[2], q[1]], []),
+]:
+    def_cswap.append(inst, qargs, cargs)
+_sel.add_equivalence(CSwapGate(), def_cswap)
+
+# TGate
+#
+#    ┌───┐        ┌─────────┐
+# q: ┤ T ├  ≡  q: ┤ U1(π/4) ├
+#    └───┘        └─────────┘
+q = QuantumRegister(1, "q")
+def_t = QuantumCircuit(q)
+def_t.append(U1Gate(pi / 4), [q[0]], [])
+_sel.add_equivalence(TGate(), def_t)
+
+# TdgGate
+#
+#    ┌─────┐        ┌──────────┐
+# q: ┤ Tdg ├  ≡  q: ┤ U1(-π/4) ├
+#    └─────┘        └──────────┘
+q = QuantumRegister(1, "q")
+def_tdg = QuantumCircuit(q)
+def_tdg.append(U1Gate(-pi / 4), [q[0]], [])
+_sel.add_equivalence(TdgGate(), def_tdg)
+
+# UGate
+#
+#    ┌──────────┐        ┌───────────┐
+# q: ┤ U(θ,ϕ,λ) ├  ≡  q: ┤ U3(θ,ϕ,λ) ├
+#    └──────────┘        └───────────┘
+q = QuantumRegister(1, "q")
+theta = Parameter("theta")
+phi = Parameter("phi")
+lam = Parameter("lam")
+u_to_u3 = QuantumCircuit(q)
+u_to_u3.append(U3Gate(theta, phi, lam), [0])
+_sel.add_equivalence(UGate(theta, phi, lam), u_to_u3)
+
+# CUGate
+#                                  ┌──────┐    ┌──────────────┐     »
+# q_0: ──────■───────     q_0: ────┤ P(γ) ├────┤ P(λ/2 + ϕ/2) ├──■──»
+#      ┌─────┴──────┐  ≡       ┌───┴──────┴───┐└──────────────┘┌─┴─┐»
+# q_1: ┤ U(θ,ϕ,λ,γ) ├     q_1: ┤ P(λ/2 - ϕ/2) ├────────────────┤ X ├»
+#      └────────────┘          └──────────────┘                └───┘»
+# «
+# «q_0: ──────────────────────────■────────────────
+# «     ┌──────────────────────┐┌─┴─┐┌────────────┐
+# «q_1: ┤ U(-θ/2,ϕ,-λ/2 - ϕ/2) ├┤ X ├┤ U(θ/2,ϕ,0) ├
+# «     └──────────────────────┘└───┘└────────────┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+phi = Parameter("phi")
+lam = Parameter("lam")
+gamma = Parameter("gamma")
+def_cu = QuantumCircuit(q)
+def_cu.p(gamma, 0)
+def_cu.p((lam + phi) / 2, 0)
+def_cu.p((lam - phi) / 2, 1)
+def_cu.cx(0, 1)
+def_cu.u(-theta / 2, 0, -(phi + lam) / 2, 1)
+def_cu.cx(0, 1)
+def_cu.u(theta / 2, phi, 0, 1)
+_sel.add_equivalence(CUGate(theta, phi, lam, gamma), def_cu)
+
+# CUGate
+#                              ┌──────┐
+# q_0: ──────■───────     q_0: ┤ P(γ) ├──────■──────
+#      ┌─────┴──────┐  ≡       └──────┘┌─────┴─────┐
+# q_1: ┤ U(θ,ϕ,λ,γ) ├     q_1: ────────┤ U3(θ,ϕ,λ) ├
+#      └────────────┘                  └───────────┘
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+phi = Parameter("phi")
+lam = Parameter("lam")
+gamma = Parameter("gamma")
+cu_to_cu3 = QuantumCircuit(q)
+cu_to_cu3.p(gamma, 0)
+cu_to_cu3.append(CU3Gate(theta, phi, lam), [0, 1])
+_sel.add_equivalence(CUGate(theta, phi, lam, gamma), cu_to_cu3)
+
+# U1Gate
+#
+#    ┌───────┐        ┌───────────┐
+# q: ┤ U1(θ) ├  ≡  q: ┤ U3(0,0,θ) ├
+#    └───────┘        └───────────┘
+q = QuantumRegister(1, "q")
+theta = Parameter("theta")
+def_u1 = QuantumCircuit(q)
+def_u1.append(U3Gate(0, 0, theta), [q[0]], [])
+_sel.add_equivalence(U1Gate(theta), def_u1)
+
+# U1Gate
+#
+#    ┌───────┐        ┌──────┐
+# q: ┤ U1(θ) ├  ≡  q: ┤ P(0) ├
+#    └───────┘        └──────┘
+q = QuantumRegister(1, "q")
+theta = Parameter("theta")
+u1_to_phase = QuantumCircuit(q)
+u1_to_phase.p(theta, 0)
+_sel.add_equivalence(U1Gate(theta), u1_to_phase)
+
+# U1Gate
+#                  global phase: θ/2
+#    ┌───────┐        ┌───────┐
+# q: ┤ U1(θ) ├  ≡  q: ┤ Rz(θ) ├
+#    └───────┘        └───────┘
+q = QuantumRegister(1, "q")
+theta = Parameter("theta")
+u1_to_rz = QuantumCircuit(q, global_phase=theta / 2)
+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 = QuantumRegister(2, "q")
+theta = Parameter("theta")
+def_cu1 = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (U1Gate(theta / 2), [q[0]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (U1Gate(-theta / 2), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (U1Gate(theta / 2), [q[1]], []),
+]:
+    def_cu1.append(inst, qargs, cargs)
+_sel.add_equivalence(CU1Gate(theta), def_cu1)
+
+# U2Gate
+#
+#    ┌─────────┐        ┌─────────────┐
+# q: ┤ U2(ϕ,λ) ├  ≡  q: ┤ U3(π/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]], [])
+_sel.add_equivalence(U2Gate(phi, lam), def_u2)
+
+# U2Gate
+#                    global phase: 7π/4
+#    ┌─────────┐        ┌─────────────┐┌────┐┌─────────────┐
+# q: ┤ U2(ϕ,λ) ├  ≡  q: ┤ U1(λ - π/2) ├┤ √X ├┤ U1(ϕ + π/2) ├
+#    └─────────┘        └─────────────┘└────┘└─────────────┘
+q = QuantumRegister(1, "q")
+phi = Parameter("phi")
+lam = Parameter("lam")
+u2_to_u1sx = QuantumCircuit(q, global_phase=-pi / 4)
+u2_to_u1sx.append(U1Gate(lam - pi / 2), [0])
+u2_to_u1sx.sx(0)
+u2_to_u1sx.append(U1Gate(phi + pi / 2), [0])
+_sel.add_equivalence(U2Gate(phi, lam), u2_to_u1sx)
+
+# U3Gate
+#                         global phase: λ/2 + ϕ/2 - π/2
+#    ┌───────────┐        ┌───────┐┌────┐┌───────────┐┌────┐┌────────────┐
+# q: ┤ U3(θ,ϕ,λ) ├  ≡  q: ┤ Rz(λ) ├┤ √X ├┤ Rz(θ + π) ├┤ √X ├┤ Rz(ϕ + 3π) ├
+#    └───────────┘        └───────┘└────┘└───────────┘└────┘└────────────┘
+q = QuantumRegister(1, "q")
+theta = Parameter("theta")
+phi = Parameter("phi")
+lam = Parameter("lam")
+u3_qasm_def = QuantumCircuit(q, global_phase=(lam + phi - pi) / 2)
+u3_qasm_def.rz(lam, 0)
+u3_qasm_def.sx(0)
+u3_qasm_def.rz(theta + pi, 0)
+u3_qasm_def.sx(0)
+u3_qasm_def.rz(phi + 3 * pi, 0)
+_sel.add_equivalence(U3Gate(theta, phi, lam), u3_qasm_def)
+
+# U3Gate
+#
+#    ┌───────────┐        ┌──────────┐
+# q: ┤ U3(θ,ϕ,λ) ├  ≡  q: ┤ U(θ,ϕ,λ) ├
+#    └───────────┘        └──────────┘
+q = QuantumRegister(1, "q")
+theta = Parameter("theta")
+phi = Parameter("phi")
+lam = Parameter("lam")
+u3_to_u = QuantumCircuit(q)
+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_1: ┤ U3(θ/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]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (U3Gate(-theta / 2, 0, -(phi + lam) / 2), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (U3Gate(theta / 2, phi, 0), [q[1]], []),
+]:
+    def_cu3.append(inst, qargs, cargs)
+_sel.add_equivalence(CU3Gate(theta, phi, lam), def_cu3)
+
+q = QuantumRegister(2, "q")
+theta = Parameter("theta")
+phi = Parameter("phi")
+lam = Parameter("lam")
+cu3_to_cu = QuantumCircuit(q)
+cu3_to_cu.cu(theta, phi, lam, 0, 0, 1)
+_sel.add_equivalence(CU3Gate(theta, phi, lam), cu3_to_cu)
+
+# XGate
+#
+#    ┌───┐        ┌───────────┐
+# q: ┤ X ├  ≡  q: ┤ U3(π,0,π) ├
+#    └───┘        └───────────┘
+q = QuantumRegister(1, "q")
+def_x = QuantumCircuit(q)
+def_x.append(U3Gate(pi, 0, pi), [q[0]], [])
+_sel.add_equivalence(XGate(), def_x)
+
+# XGate
+#
+#    ┌───┐        ┌───┐┌───┐┌───┐┌───┐
+# q: ┤ X ├  ≡  q: ┤ H ├┤ S ├┤ S ├┤ H ├
+#    └───┘        └───┘└───┘└───┘└───┘
+q = QuantumRegister(1, "q")
+def_x = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+    (HGate(), [q[0]], []),
+]:
+    def_x.append(inst, qargs, cargs)
+_sel.add_equivalence(XGate(), def_x)
+
+# XGate
+#                 global phase: π/2
+#    ┌───┐        ┌───┐┌───┐
+# q: ┤ X ├  ≡  q: ┤ Y ├┤ Z ├
+#    └───┘        └───┘└───┘
+def_x = QuantumCircuit(1, global_phase=pi / 2)
+def_x.y(0)
+def_x.z(0)
+_sel.add_equivalence(XGate(), def_x)
+
+# CXGate
+
+for pos_ry in [False, True]:
+    for pos_rxx in [False, True]:
+        cx_to_rxx = _cnot_rxx_decompose(pos_ry, pos_rxx)
+        _sel.add_equivalence(CXGate(), cx_to_rxx)
+
+# CXGate
+#
+# q_0: ──■──     q_0: ──────■──────
+#      ┌─┴─┐  ≡       ┌───┐ │ ┌───┐
+# q_1: ┤ X ├     q_1: ┤ H ├─■─┤ H ├
+#      └───┘          └───┘   └───┘
+q = QuantumRegister(2, "q")
+cx_to_cz = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[1]], []),
+    (CZGate(), [q[0], q[1]], []),
+    (HGate(), [q[1]], []),
+]:
+    cx_to_cz.append(inst, qargs, cargs)
+_sel.add_equivalence(CXGate(), cx_to_cz)
+
+# CXGate
+#                global phase: 3π/4
+#                     ┌───┐     ┌────────┐┌───┐     ┌────────┐┌───┐┌───┐
+# q_0: ──■──     q_0: ┤ H ├─────┤0       ├┤ X ├─────┤0       ├┤ H ├┤ S ├─────
+#      ┌─┴─┐  ≡       ├───┤┌───┐│  Iswap │├───┤┌───┐│  Iswap │├───┤├───┤┌───┐
+# q_1: ┤ X ├     q_1: ┤ X ├┤ H ├┤1       ├┤ X ├┤ H ├┤1       ├┤ S ├┤ X ├┤ H ├
+#      └───┘          └───┘└───┘└────────┘└───┘└───┘└────────┘└───┘└───┘└───┘
+q = QuantumRegister(2, "q")
+cx_to_iswap = QuantumCircuit(q, global_phase=3 * pi / 4)
+for inst, qargs, cargs in [
+    (HGate(), [q[0]], []),
+    (XGate(), [q[1]], []),
+    (HGate(), [q[1]], []),
+    (iSwapGate(), [q[0], q[1]], []),
+    (XGate(), [q[0]], []),
+    (XGate(), [q[1]], []),
+    (HGate(), [q[1]], []),
+    (iSwapGate(), [q[0], q[1]], []),
+    (HGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+    (SGate(), [q[1]], []),
+    (XGate(), [q[1]], []),
+    (HGate(), [q[1]], []),
+]:
+    cx_to_iswap.append(inst, qargs, cargs)
+_sel.add_equivalence(CXGate(), cx_to_iswap)
+
+# CXGate
+#                global phase: 7π/4
+#                     ┌──────────┐┌───────┐┌──────┐
+# q_0: ──■──     q_0: ┤ Rz(-π/2) ├┤ Ry(π) ├┤0     ├
+#      ┌─┴─┐  ≡       ├─────────┬┘└───────┘│  Ecr │
+# q_1: ┤ X ├     q_1: ┤ Rx(π/2) ├──────────┤1     ├
+#      └───┘          └─────────┘          └──────┘
+q = QuantumRegister(2, "q")
+cx_to_ecr = QuantumCircuit(q, global_phase=-pi / 4)
+for inst, qargs, cargs in [
+    (RZGate(-pi / 2), [q[0]], []),
+    (RYGate(pi), [q[0]], []),
+    (RXGate(pi / 2), [q[1]], []),
+    (ECRGate(), [q[0], q[1]], []),
+]:
+    cx_to_ecr.append(inst, qargs, cargs)
+_sel.add_equivalence(CXGate(), cx_to_ecr)
+
+# CXGate
+# q_0: ──■──     q_0: ───────────────■───────────────────
+#      ┌─┴─┐  ≡       ┌────────────┐ │P(π) ┌────────────┐
+# q_1: ┤ X ├     q_1: ┤ U(π/2,0,π) ├─■─────┤ U(π/2,0,π) ├
+#      └───┘          └────────────┘       └────────────┘
+q = QuantumRegister(2, "q")
+cx_to_cp = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (UGate(pi / 2, 0, pi), [q[1]], []),
+    (CPhaseGate(pi), [q[0], q[1]], []),
+    (UGate(pi / 2, 0, pi), [q[1]], []),
+]:
+    cx_to_cp.append(inst, qargs, cargs)
+_sel.add_equivalence(CXGate(), cx_to_cp)
+
+# CXGate
+#                     ┌────────────┐
+# q_0: ──■──     q_0: ┤ U(0,0,π/2) ├────■──────────────────
+#      ┌─┴─┐  ≡       ├────────────┤┌───┴───┐┌────────────┐
+# q_1: ┤ X ├     q_1: ┤ U(π/2,0,π) ├┤ Rz(π) ├┤ U(π/2,0,π) ├
+#      └───┘          └────────────┘└───────┘└────────────┘
+q = QuantumRegister(2, "q")
+cx_to_crz = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (UGate(pi / 2, 0, pi), [q[1]], []),
+    (UGate(0, 0, pi / 2), [q[0]], []),
+    (CRZGate(pi), [q[0], q[1]], []),
+    (UGate(pi / 2, 0, pi), [q[1]], []),
+]:
+    cx_to_crz.append(inst, qargs, cargs)
+_sel.add_equivalence(CXGate(), cx_to_crz)
+
+# CXGate
+#                global phase: π/4
+#                     ┌───────────┐┌─────┐
+# q_0: ──■──     q_0: ┤0          ├┤ Sdg ├─
+#      ┌─┴─┐  ≡       │  Rzx(π/2) │├─────┴┐
+# q_1: ┤ X ├     q_1: ┤1          ├┤ √Xdg ├
+#      └───┘          └───────────┘└──────┘
+q = QuantumRegister(2, "q")
+cx_to_zx90 = QuantumCircuit(q, global_phase=pi / 4)
+for inst, qargs, cargs in [
+    (RZXGate(pi / 2), [q[0], q[1]], []),
+    (SdgGate(), [q[0]], []),
+    (SXdgGate(), [q[1]], []),
+]:
+    cx_to_zx90.append(inst, qargs, cargs)
+_sel.add_equivalence(CXGate(), cx_to_zx90)
+
+# CCXGate
+#                                                                       ┌───┐
+# q_0: ──■──     q_0: ───────────────────■─────────────────────■────■───┤ T ├───■──
+#        │                               │             ┌───┐   │  ┌─┴─┐┌┴───┴┐┌─┴─┐
+# q_1: ──■──  ≡  q_1: ───────■───────────┼─────────■───┤ T ├───┼──┤ X ├┤ Tdg ├┤ X ├
+#      ┌─┴─┐          ┌───┐┌─┴─┐┌─────┐┌─┴─┐┌───┐┌─┴─┐┌┴───┴┐┌─┴─┐├───┤└┬───┬┘└───┘
+# q_2: ┤ X ├     q_2: ┤ H ├┤ X ├┤ Tdg ├┤ X ├┤ T ├┤ X ├┤ Tdg ├┤ X ├┤ T ├─┤ H ├──────
+#      └───┘          └───┘└───┘└─────┘└───┘└───┘└───┘└─────┘└───┘└───┘ └───┘
+q = QuantumRegister(3, "q")
+def_ccx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[2]], []),
+    (CXGate(), [q[1], q[2]], []),
+    (TdgGate(), [q[2]], []),
+    (CXGate(), [q[0], q[2]], []),
+    (TGate(), [q[2]], []),
+    (CXGate(), [q[1], q[2]], []),
+    (TdgGate(), [q[2]], []),
+    (CXGate(), [q[0], q[2]], []),
+    (TGate(), [q[1]], []),
+    (TGate(), [q[2]], []),
+    (HGate(), [q[2]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (TGate(), [q[0]], []),
+    (TdgGate(), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+]:
+    def_ccx.append(inst, qargs, cargs)
+_sel.add_equivalence(CCXGate(), def_ccx)
+
+# CCXGate
+#
+# q_0: ──■──     q_0: ────────■─────────────────■────■───
+#        │                  ┌─┴─┐┌─────┐      ┌─┴─┐  │
+# q_1: ──■──  ≡  q_1: ──■───┤ X ├┤ Sdg ├──■───┤ X ├──┼───
+#      ┌─┴─┐          ┌─┴──┐├───┤└─────┘┌─┴──┐├───┤┌─┴──┐
+# q_2: ┤ X ├     q_2: ┤ Sx ├┤ Z ├───────┤ Sx ├┤ Z ├┤ Sx ├
+#      └───┘          └────┘└───┘       └────┘└───┘└────┘
+q = QuantumRegister(3, "q")
+ccx_to_cx_csx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (CSXGate(), [q[1], q[2]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (ZGate(), [q[2]], []),
+    (SdgGate(), [q[1]], []),
+    (CSXGate(), [q[1], q[2]], []),
+    (ZGate(), [q[2]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (CSXGate(), [q[0], q[2]], []),
+]:
+    ccx_to_cx_csx.append(inst, qargs, cargs)
+_sel.add_equivalence(CCXGate(), ccx_to_cx_csx)
+
+# YGate
+#
+#    ┌───┐        ┌───────────────┐
+# q: ┤ Y ├  ≡  q: ┤ U3(π,π/2,π/2) ├
+#    └───┘        └───────────────┘
+q = QuantumRegister(1, "q")
+def_y = QuantumCircuit(q)
+def_y.append(U3Gate(pi, pi / 2, pi / 2), [q[0]], [])
+_sel.add_equivalence(YGate(), def_y)
+
+# YGate
+#              global phase: 3π/2
+#    ┌───┐        ┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐
+# q: ┤ Y ├  ≡  q: ┤ H ├┤ S ├┤ S ├┤ H ├┤ S ├┤ S ├
+#    └───┘        └───┘└───┘└───┘└───┘└───┘└───┘
+q = QuantumRegister(1, "q")
+def_y = QuantumCircuit(q)
+def_y.global_phase = 3 * pi / 2
+for inst, qargs, cargs in [
+    (HGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+    (HGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+]:
+    def_y.append(inst, qargs, cargs)
+_sel.add_equivalence(YGate(), def_y)
+
+# YGate
+#              global phase: π/2
+#    ┌───┐        ┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐
+# q: ┤ Y ├  ≡  q: ┤ S ├┤ S ├┤ H ├┤ S ├┤ S ├┤ H ├
+#    └───┘        └───┘└───┘└───┘└───┘└───┘└───┘
+q = QuantumRegister(1, "q")
+def_y = QuantumCircuit(q)
+def_y.global_phase = pi / 2
+for inst, qargs, cargs in [
+    (SGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+    (HGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+    (HGate(), [q[0]], []),
+]:
+    def_y.append(inst, qargs, cargs)
+_sel.add_equivalence(YGate(), def_y)
+
+# YGate
+#                 global phase: π/2
+#    ┌───┐        ┌───┐┌───┐
+# q: ┤ Y ├  ≡  q: ┤ Z ├┤ X ├
+#    └───┘        └───┘└───┘
+def_y = QuantumCircuit(1, global_phase=pi / 2)
+def_y.z(0)
+def_y.x(0)
+_sel.add_equivalence(YGate(), def_y)
+
+# CYGate
+#
+# q_0: ──■──     q_0: ─────────■───────
+#      ┌─┴─┐  ≡       ┌─────┐┌─┴─┐┌───┐
+# q_1: ┤ Y ├     q_1: ┤ Sdg ├┤ X ├┤ S ├
+#      └───┘          └─────┘└───┘└───┘
+q = QuantumRegister(2, "q")
+def_cy = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (SdgGate(), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (SGate(), [q[1]], []),
+]:
+    def_cy.append(inst, qargs, cargs)
+_sel.add_equivalence(CYGate(), def_cy)
+
+# ZGate
+#
+#    ┌───┐        ┌───────┐
+# q: ┤ Z ├  ≡  q: ┤ U1(π) ├
+#    └───┘        └───────┘
+q = QuantumRegister(1, "q")
+def_z = QuantumCircuit(q)
+def_z.append(U1Gate(pi), [q[0]], [])
+_sel.add_equivalence(ZGate(), def_z)
+
+# ZGate
+#
+#    ┌───┐        ┌───┐┌───┐
+# q: ┤ Z ├  ≡  q: ┤ S ├┤ S ├
+#    └───┘        └───┘└───┘
+q = QuantumRegister(1, "q")
+def_z = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (SGate(), [q[0]], []),
+    (SGate(), [q[0]], []),
+]:
+    def_z.append(inst, qargs, cargs)
+_sel.add_equivalence(ZGate(), def_z)
+
+# ZGate
+#                 global phase: π/2
+#    ┌───┐        ┌───┐┌───┐
+# q: ┤ Z ├  ≡  q: ┤ X ├┤ Y ├
+#    └───┘        └───┘└───┘
+def_z = QuantumCircuit(1, global_phase=pi / 2)
+def_z.x(0)
+def_z.y(0)
+_sel.add_equivalence(ZGate(), def_z)
+
+# CZGate
+#
+# q_0: ─■─     q_0: ───────■───────
+#       │   ≡       ┌───┐┌─┴─┐┌───┐
+# q_1: ─■─     q_1: ┤ H ├┤ X ├┤ H ├
+#                   └───┘└───┘└───┘
+q = QuantumRegister(2, "q")
+def_cz = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (HGate(), [q[1]], []),
+]:
+    def_cz.append(inst, qargs, cargs)
+_sel.add_equivalence(CZGate(), def_cz)
+
+# CCZGate
+#
+# q_0: ─■─   q_0: ───────■───────
+#       │                │
+# q_1: ─■─ = q_1: ───────■───────
+#       │         ┌───┐┌─┴─┐┌───┐
+# q_2: ─■─   q_2: ┤ H ├┤ X ├┤ H ├
+#                 └───┘└───┘└───┘
+q = QuantumRegister(3, "q")
+def_ccz = QuantumCircuit(q)
+for inst, qargs, cargs in [
+    (HGate(), [q[2]], []),
+    (CCXGate(), [q[0], q[1], q[2]], []),
+    (HGate(), [q[2]], []),
+]:
+    def_ccz.append(inst, qargs, cargs)
+_sel.add_equivalence(CCZGate(), def_ccz)
+
+# XGate
+#              global phase: π/2
+#    ┌───┐        ┌───────┐
+# q: ┤ X ├  ≡  q: ┤ Rx(π) ├
+#    └───┘        └───────┘
+q = QuantumRegister(1, "q")
+x_to_rx = QuantumCircuit(q)
+x_to_rx.append(RXGate(theta=pi), [q[0]])
+x_to_rx.global_phase = pi / 2
+_sel.add_equivalence(XGate(), x_to_rx)
+
+# YGate
+#              global phase: π/2
+#    ┌───┐        ┌───────┐
+# q: ┤ Y ├  ≡  q: ┤ Ry(π) ├
+#    └───┘        └───────┘
+q = QuantumRegister(1, "q")
+y_to_ry = QuantumCircuit(q)
+y_to_ry.append(RYGate(theta=pi), [q[0]])
+y_to_ry.global_phase = pi / 2
+_sel.add_equivalence(YGate(), y_to_ry)
+
+# HGate
+#              global phase: π/2
+#    ┌───┐        ┌─────────┐┌───────┐
+# q: ┤ H ├  ≡  q: ┤ Ry(π/2) ├┤ Rx(π) ├
+#    └───┘        └─────────┘└───────┘
+q = QuantumRegister(1, "q")
+h_to_rxry = QuantumCircuit(q)
+h_to_rxry.append(RYGate(theta=pi / 2), [q[0]])
+h_to_rxry.append(RXGate(theta=pi), [q[0]])
+h_to_rxry.global_phase = pi / 2
+_sel.add_equivalence(HGate(), h_to_rxry)
+
+# HGate
+#              global phase: π/2
+#    ┌───┐        ┌────────────┐┌────────┐
+# q: ┤ H ├  ≡  q: ┤ R(π/2,π/2) ├┤ R(π,0) ├
+#    └───┘        └────────────┘└────────┘
+q = QuantumRegister(1, "q")
+h_to_rr = QuantumCircuit(q)
+h_to_rr.append(RGate(theta=pi / 2, phi=pi / 2), [q[0]])
+h_to_rr.append(RGate(theta=pi, phi=0), [q[0]])
+h_to_rr.global_phase = pi / 2
+_sel.add_equivalence(HGate(), h_to_rr)
+
+# XXPlusYYGate
+# ┌───────────────┐
+# ┤0              ├
+# │  {XX+YY}(θ,β) │
+# ┤1              ├
+# └───────────────┘
+#    ┌───────┐  ┌───┐            ┌───┐┌────────────┐┌───┐  ┌─────┐   ┌────────────┐
+#   ─┤ Rz(β) ├──┤ S ├────────────┤ X ├┤ Ry(-0.5*θ) ├┤ X ├──┤ Sdg ├───┤ Rz(-1.0*β) ├───────────
+# ≡ ┌┴───────┴─┐├───┴┐┌─────────┐└─┬─┘├────────────┤└─┬─┘┌─┴─────┴──┐└──┬──────┬──┘┌─────────┐
+#   ┤ Rz(-π/2) ├┤ √X ├┤ Rz(π/2) ├──■──┤ Ry(-0.5*θ) ├──■──┤ Rz(-π/2) ├───┤ √Xdg ├───┤ Rz(π/2) ├
+#   └──────────┘└────┘└─────────┘     └────────────┘     └──────────┘   └──────┘   └─────────┘
+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]], []),
+    (RZGate(-pi / 2), [q[1]], []),
+    (SXGate(), [q[1]], []),
+    (RZGate(pi / 2), [q[1]], []),
+    (SGate(), [q[0]], []),
+    (CXGate(), [q[1], q[0]], []),
+    (RYGate(-theta / 2), [q[1]], []),
+    (RYGate(-theta / 2), [q[0]], []),
+    (CXGate(), [q[1], q[0]], []),
+    (SdgGate(), [q[0]], []),
+    (RZGate(-pi / 2), [q[1]], []),
+    (SXdgGate(), [q[1]], []),
+    (RZGate(pi / 2), [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              ├
+# │  {XX-YY}(θ,β) │
+# ┤1              ├
+# └───────────────┘
+#    ┌──────────┐ ┌────┐┌─────────┐      ┌─────────┐       ┌──────────┐ ┌──────┐┌─────────┐
+#   ─┤ Rz(-π/2) ├─┤ √X ├┤ Rz(π/2) ├──■───┤ Ry(θ/2) ├────■──┤ Rz(-π/2) ├─┤ √Xdg ├┤ Rz(π/2) ├
+# ≡ ┌┴──────────┴┐├───┬┘└─────────┘┌─┴─┐┌┴─────────┴─┐┌─┴─┐└─┬─────┬──┘┌┴──────┤└─────────┘
+#   ┤ Rz(-1.0*β) ├┤ S ├────────────┤ X ├┤ Ry(-0.5*θ) ├┤ X ├──┤ Sdg ├───┤ Rz(β) ├───────────
+#   └────────────┘└───┘            └───┘└────────────┘└───┘  └─────┘   └───────┘
+q = QuantumRegister(2, "q")
+xxminusyy = QuantumCircuit(q)
+beta = Parameter("beta")
+theta = Parameter("theta")
+rules: list[tuple[Gate, list[Qubit], list[Clbit]]] = [
+    (RZGate(-beta), [q[1]], []),
+    (RZGate(-pi / 2), [q[0]], []),
+    (SXGate(), [q[0]], []),
+    (RZGate(pi / 2), [q[0]], []),
+    (SGate(), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (RYGate(theta / 2), [q[0]], []),
+    (RYGate(-theta / 2), [q[1]], []),
+    (CXGate(), [q[0], q[1]], []),
+    (SdgGate(), [q[1]], []),
+    (RZGate(-pi / 2), [q[0]], []),
+    (SXdgGate(), [q[0]], []),
+    (RZGate(pi / 2), [q[0]], []),
+    (RZGate(beta), [q[1]], []),
+]
+for instr, qargs, cargs in rules:
+    xxminusyy._append(instr, qargs, cargs)
+_sel.add_equivalence(XXMinusYYGate(theta, beta), xxminusyy)