qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/circuit/library/phase_estimation.py

@@ -0,0 +1,99 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Phase estimation circuit."""
+
+from typing import Optional
+
+from qiskit.circuit import QuantumCircuit, QuantumRegister
+
+from .basis_change import QFT
+
+
+class PhaseEstimation(QuantumCircuit):
+    r"""Phase Estimation circuit.
+
+    In the Quantum Phase Estimation (QPE) algorithm [1, 2, 3], the Phase Estimation circuit is used
+    to estimate the phase :math:`\phi` of an eigenvalue :math:`e^{2\pi i\phi}` of a unitary operator
+    :math:`U`, provided with the corresponding eigenstate :math:`|psi\rangle`.
+    That is
+
+    .. math::
+
+        U|\psi\rangle = e^{2\pi i\phi} |\psi\rangle
+
+    This estimation (and thereby this circuit) is a central routine to several well-known
+    algorithms, such as Shor's algorithm or Quantum Amplitude Estimation.
+
+    **References:**
+
+    [1]: Kitaev, A. Y. (1995). Quantum measurements and the Abelian Stabilizer Problem. 1–22.
+        `quant-ph/9511026 <http://arxiv.org/abs/quant-ph/9511026>`_
+
+    [2]: Michael A. Nielsen and Isaac L. Chuang. 2011.
+         Quantum Computation and Quantum Information: 10th Anniversary Edition (10th ed.).
+         Cambridge University Press, New York, NY, USA.
+
+    [3]: Qiskit
+        `textbook <https://github.com/Qiskit/textbook/blob/main/notebooks/ch-algorithms/
+        quantum-phase-estimation.ipynb>`_
+
+    """
+
+    def __init__(
+        self,
+        num_evaluation_qubits: int,
+        unitary: QuantumCircuit,
+        iqft: Optional[QuantumCircuit] = None,
+        name: str = "QPE",
+    ) -> None:
+        """
+        Args:
+            num_evaluation_qubits: The number of evaluation qubits.
+            unitary: The unitary operation :math:`U` which will be repeated and controlled.
+            iqft: A inverse Quantum Fourier Transform, per default the inverse of
+                :class:`~qiskit.circuit.library.QFT` is used. Note that the QFT should not include
+                the usual swaps!
+            name: The name of the circuit.
+
+        .. note::
+
+            The inverse QFT should not include a swap of the qubit order.
+
+        Reference Circuit:
+            .. plot::
+
+               from qiskit.circuit import QuantumCircuit
+               from qiskit.circuit.library import PhaseEstimation
+               from qiskit.tools.jupyter.library import _generate_circuit_library_visualization
+               unitary = QuantumCircuit(2)
+               unitary.x(0)
+               unitary.y(1)
+               circuit = PhaseEstimation(3, unitary)
+               _generate_circuit_library_visualization(circuit)
+        """
+        qr_eval = QuantumRegister(num_evaluation_qubits, "eval")
+        qr_state = QuantumRegister(unitary.num_qubits, "q")
+        circuit = QuantumCircuit(qr_eval, qr_state, name=name)
+
+        if iqft is None:
+            iqft = QFT(num_evaluation_qubits, inverse=True, do_swaps=False).reverse_bits()
+
+        circuit.h(qr_eval)  # hadamards on evaluation qubits
+
+        for j in range(num_evaluation_qubits):  # controlled powers
+            circuit.compose(unitary.power(2**j).control(), qubits=[j] + qr_state[:], inplace=True)
+
+        circuit.compose(iqft, qubits=qr_eval[:], inplace=True)  # final QFT
+
+        super().__init__(*circuit.qregs, name=circuit.name)
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)

qiskit/circuit/library/phase_oracle.py

@@ -0,0 +1,153 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Phase Oracle object."""
+
+# Needed to avoid type hints from erroring when `classicalfunction` might not be available.
+from __future__ import annotations
+
+from typing import Union, Callable, Optional, TYPE_CHECKING
+
+from qiskit.circuit import QuantumCircuit
+from qiskit.utils import optionals as _optionals
+
+if TYPE_CHECKING:
+    from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
+    from qiskit.circuit.classicalfunction.classical_element import ClassicalElement
+
+
+@_optionals.HAS_TWEEDLEDUM.require_in_instance
+class PhaseOracle(QuantumCircuit):
+    r"""Phase Oracle.
+
+    The Phase Oracle object constructs circuits for any arbitrary
+    input logical expressions. A logical expression is composed of logical operators
+    `&` (`AND`), `|` (`OR`), `~` (`NOT`), and `^` (`XOR`).
+    as well as symbols for literals (variables).
+    For example, `'a & b'`, and `(v0 | ~v1) & (~v2 & v3)`
+    are both valid string representation of boolean logical expressions.
+
+    For convenience, this oracle, in addition to parsing arbitrary logical expressions,
+    also supports input strings in the `DIMACS CNF format
+    <http://www.satcompetition.org/2009/format-benchmarks2009.html>`__,
+    which is the standard format for specifying SATisfiability (SAT) problem instances in
+    `Conjunctive Normal Form (CNF) <https://en.wikipedia.org/wiki/Conjunctive_normal_form>`__,
+    which is a conjunction of one or more clauses, where a clause is a disjunction of one
+    or more literals. See :meth:`qiskit.circuit.library.phase_oracle.PhaseOracle.from_dimacs_file`.
+
+    From 16 variables on, possible performance issues should be expected when using the
+    default synthesizer.
+    """
+
+    def __init__(
+        self,
+        expression: Union[str, ClassicalElement],
+        synthesizer: Optional[Callable[[BooleanExpression], QuantumCircuit]] = None,
+        var_order: list = None,
+    ) -> None:
+        """Creates a PhaseOracle object
+
+        Args:
+            expression: A Python-like boolean expression.
+            synthesizer: Optional. A function to convert a BooleanExpression into a QuantumCircuit
+               If None is provided, Tweedledum's `pkrm_synth` with `phase_esop` will be used.
+            var_order(list): A list with the order in which variables will be created.
+               (default: by appearance)
+        """
+        from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
+        from qiskit.circuit.classicalfunction.classical_element import ClassicalElement
+
+        if not isinstance(expression, ClassicalElement):
+            expression = BooleanExpression(expression, var_order=var_order)
+
+        self.boolean_expression = expression
+
+        if synthesizer is None:
+
+            def synthesizer(boolean_expression):
+                from tweedledum.synthesis import pkrm_synth  # pylint: disable=import-error
+                from qiskit.circuit.classicalfunction.utils import tweedledum2qiskit
+
+                truth_table = boolean_expression._tweedledum_bool_expression.truth_table(
+                    output_bit=0
+                )
+                tweedledum_circuit = pkrm_synth(truth_table, {"pkrm_synth": {"phase_esop": True}})
+                return tweedledum2qiskit(tweedledum_circuit)
+
+        oracle = expression.synth(synthesizer=synthesizer)
+
+        super().__init__(oracle.num_qubits, name="Phase Oracle")
+
+        self.compose(oracle, inplace=True)
+
+    def evaluate_bitstring(self, bitstring: str) -> bool:
+        """Evaluate the oracle on a bitstring.
+        This evaluation is done classically without any quantum circuit.
+
+        Args:
+            bitstring: The bitstring for which to evaluate. The input bitstring is expected to be
+                in little-endian order.
+
+        Returns:
+            True if the bitstring is a good state, False otherwise.
+        """
+        return self.boolean_expression.simulate(bitstring[::-1])
+
+    @classmethod
+    def from_dimacs_file(cls, filename: str):
+        r"""Create a PhaseOracle from the string in the DIMACS format.
+
+        It is possible to build a PhaseOracle from a file in `DIMACS CNF format
+        <http://www.satcompetition.org/2009/format-benchmarks2009.html>`__,
+        which is the standard format for specifying SATisfiability (SAT) problem instances in
+        `Conjunctive Normal Form (CNF) <https://en.wikipedia.org/wiki/Conjunctive_normal_form>`__,
+        which is a conjunction of one or more clauses, where a clause is a disjunction of one
+        or more literals.
+
+        The following is an example of a CNF expressed in the DIMACS format:
+
+        .. code:: text
+
+          c DIMACS CNF file with 3 satisfying assignments: 1 -2 3, -1 -2 -3, 1 2 -3.
+          p cnf 3 5
+          -1 -2 -3 0
+          1 -2 3 0
+          1 2 -3 0
+          1 -2 -3 0
+          -1 2 3 0
+
+        The first line, following the `c` character, is a comment. The second line specifies that
+        the CNF is over three boolean variables --- let us call them  :math:`x_1, x_2, x_3`, and
+        contains five clauses.  The five clauses, listed afterwards, are implicitly joined by the
+        logical `AND` operator, :math:`\land`, while the variables in each clause, represented by
+        their indices, are implicitly disjoined by the logical `OR` operator, :math:`lor`. The
+        :math:`-` symbol preceding a boolean variable index corresponds to the logical `NOT`
+        operator, :math:`lnot`. Character `0` (zero) marks the end of each clause.  Essentially,
+        the code above corresponds to the following CNF:
+
+        :math:`(\lnot x_1 \lor \lnot x_2 \lor \lnot x_3)
+        \land (x_1 \lor \lnot x_2 \lor x_3)
+        \land (x_1 \lor x_2 \lor \lnot x_3)
+        \land (x_1 \lor \lnot x_2 \lor \lnot x_3)
+        \land (\lnot x_1 \lor x_2 \lor x_3)`.
+
+
+        Args:
+            filename: A file in DIMACS format.
+
+        Returns:
+            PhaseOracle: A quantum circuit with a phase oracle.
+        """
+        from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
+
+        expr = BooleanExpression.from_dimacs_file(filename)
+        return cls(expr)

qiskit/circuit/library/quantum_volume.py

@@ -0,0 +1,114 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Quantum Volume model circuit."""
+
+from typing import Optional, Union
+
+import numpy as np
+from qiskit.quantum_info.random import random_unitary
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit.library.generalized_gates.permutation import Permutation
+
+
+class QuantumVolume(QuantumCircuit):
+    """A quantum volume model circuit.
+
+    The model circuits are random instances of circuits used to measure
+    the Quantum Volume metric, as introduced in [1].
+
+    The model circuits consist of layers of Haar random
+    elements of SU(4) applied between corresponding pairs
+    of qubits in a random bipartition.
+
+    **Reference Circuit:**
+
+    .. plot::
+
+       from qiskit.circuit.library import QuantumVolume
+       circuit = QuantumVolume(5, 6, seed=10)
+       circuit.draw('mpl')
+
+    **Expanded Circuit:**
+
+    .. plot::
+
+       from qiskit.circuit.library import QuantumVolume
+       from qiskit.tools.jupyter.library import _generate_circuit_library_visualization
+       circuit = QuantumVolume(5, 6, seed=10, classical_permutation=False)
+       _generate_circuit_library_visualization(circuit.decompose())
+
+    **References:**
+
+    [1] A. Cross et al. Validating quantum computers using
+    randomized model circuits, Phys. Rev. A 100, 032328 (2019).
+    [`arXiv:1811.12926 <https://arxiv.org/abs/1811.12926>`_]
+    """
+
+    def __init__(
+        self,
+        num_qubits: int,
+        depth: Optional[int] = None,
+        seed: Optional[Union[int, np.random.Generator]] = None,
+        classical_permutation: bool = True,
+    ) -> None:
+        """Create quantum volume model circuit of size num_qubits x depth.
+
+        Args:
+            num_qubits: number of active qubits in model circuit.
+            depth: layers of SU(4) operations in model circuit.
+            seed: Random number generator or generator seed.
+            classical_permutation: use classical permutations at every layer,
+                rather than quantum.
+        """
+        # Initialize RNG
+        if seed is None:
+            rng_set = np.random.default_rng()
+            seed = rng_set.integers(low=1, high=1000)
+        if isinstance(seed, np.random.Generator):
+            rng = seed
+        else:
+            rng = np.random.default_rng(seed)
+
+        # Parameters
+        depth = depth or num_qubits  # how many layers of SU(4)
+        width = int(np.floor(num_qubits / 2))  # how many SU(4)s fit in each layer
+        name = "quantum_volume_" + str([num_qubits, depth, seed]).replace(" ", "")
+
+        # Generator random unitary seeds in advance.
+        # Note that this means we are constructing multiple new generator
+        # objects from low-entropy integer seeds rather than pass the shared
+        # generator object to the random_unitary function. This is done so
+        # that we can use the integer seed as a label for the generated gates.
+        unitary_seeds = rng.integers(low=1, high=1000, size=[depth, width])
+
+        # For each layer, generate a permutation of qubits
+        # Then generate and apply a Haar-random SU(4) to each pair
+        circuit = QuantumCircuit(num_qubits, name=name)
+        perm_0 = list(range(num_qubits))
+        for d in range(depth):
+            perm = rng.permutation(perm_0)
+            if not classical_permutation:
+                layer_perm = Permutation(num_qubits, perm)
+                circuit.compose(layer_perm, inplace=True)
+            for w in range(width):
+                seed_u = unitary_seeds[d][w]
+                su4 = random_unitary(4, seed=seed_u).to_instruction()
+                su4.label = "su4_" + str(seed_u)
+                if classical_permutation:
+                    physical_qubits = int(perm[2 * w]), int(perm[2 * w + 1])
+                    circuit.compose(su4, [physical_qubits[0], physical_qubits[1]], inplace=True)
+                else:
+                    circuit.compose(su4, [2 * w, 2 * w + 1], inplace=True)
+
+        super().__init__(*circuit.qregs, name=circuit.name)
+        self.compose(circuit.to_instruction(), qubits=self.qubits, inplace=True)

qiskit/circuit/library/standard_gates/__init__.py

@@ -0,0 +1,116 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Standard gates
+"""
+
+from .h import HGate, CHGate
+from .i import IGate
+from .p import PhaseGate, CPhaseGate, MCPhaseGate
+from .r import RGate
+from .rx import RXGate, CRXGate
+from .rxx import RXXGate
+from .ry import RYGate, CRYGate
+from .ryy import RYYGate
+from .rz import RZGate, CRZGate
+from .rzz import RZZGate
+from .rzx import RZXGate
+from .xx_minus_yy import XXMinusYYGate
+from .xx_plus_yy import XXPlusYYGate
+from .ecr import ECRGate
+from .s import SGate, SdgGate, CSGate, CSdgGate
+from .swap import SwapGate, CSwapGate
+from .iswap import iSwapGate
+from .sx import SXGate, SXdgGate, CSXGate
+from .dcx import DCXGate
+from .t import TGate, TdgGate
+from .u import UGate, CUGate
+from .u1 import U1Gate, CU1Gate, MCU1Gate
+from .u2 import U2Gate
+from .u3 import U3Gate, CU3Gate
+from .x import XGate, CXGate, CCXGate, C3XGate, C3SXGate, C4XGate, RCCXGate, RC3XGate
+from .x import MCXGate, MCXGrayCode, MCXRecursive, MCXVChain
+from .y import YGate, CYGate
+from .z import ZGate, CZGate, CCZGate
+from .global_phase import GlobalPhaseGate
+from .multi_control_rotation_gates import mcrx, mcry, mcrz
+
+
+def get_standard_gate_name_mapping():
+    """Return a dictionary mapping the name of standard gates and instructions to an object for
+    that name."""
+    from qiskit.circuit.parameter import Parameter
+    from qiskit.circuit.measure import Measure
+    from qiskit.circuit.delay import Delay
+    from qiskit.circuit.reset import Reset
+
+    # Standard gates library mapping, multicontrolled gates not included since they're
+    # variable width
+    gates = [
+        IGate(),
+        SXGate(),
+        XGate(),
+        CXGate(),
+        RZGate(Parameter("λ")),
+        RGate(Parameter("ϴ"), Parameter("φ")),
+        Reset(),
+        C3SXGate(),
+        CCXGate(),
+        DCXGate(),
+        CHGate(),
+        CPhaseGate(Parameter("ϴ")),
+        CRXGate(Parameter("ϴ")),
+        CRYGate(Parameter("ϴ")),
+        CRZGate(Parameter("ϴ")),
+        CSwapGate(),
+        CSXGate(),
+        CUGate(Parameter("ϴ"), Parameter("φ"), Parameter("λ"), Parameter("γ")),
+        CU1Gate(Parameter("λ")),
+        CU3Gate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
+        CYGate(),
+        CZGate(),
+        CCZGate(),
+        GlobalPhaseGate(Parameter("ϴ")),
+        HGate(),
+        PhaseGate(Parameter("ϴ")),
+        RCCXGate(),
+        RC3XGate(),
+        RXGate(Parameter("ϴ")),
+        RXXGate(Parameter("ϴ")),
+        RYGate(Parameter("ϴ")),
+        RYYGate(Parameter("ϴ")),
+        RZZGate(Parameter("ϴ")),
+        RZXGate(Parameter("ϴ")),
+        XXMinusYYGate(Parameter("ϴ")),
+        XXPlusYYGate(Parameter("ϴ")),
+        ECRGate(),
+        SGate(),
+        SdgGate(),
+        CSGate(),
+        CSdgGate(),
+        SwapGate(),
+        iSwapGate(),
+        SXdgGate(),
+        TGate(),
+        TdgGate(),
+        UGate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
+        U1Gate(Parameter("λ")),
+        U2Gate(Parameter("φ"), Parameter("λ")),
+        U3Gate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
+        YGate(),
+        ZGate(),
+        Delay(Parameter("t")),
+        Measure(),
+    ]
+    name_mapping = {gate.name: gate for gate in gates}
+    return name_mapping

qiskit/circuit/library/standard_gates/dcx.py

@@ -0,0 +1,71 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Double-CNOT gate."""
+
+from qiskit.circuit.singleton import SingletonGate, stdlib_singleton_key
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit._utils import with_gate_array
+
+
+@with_gate_array([[1, 0, 0, 0], [0, 0, 0, 1], [0, 1, 0, 0], [0, 0, 1, 0]])
+class DCXGate(SingletonGate):
+    r"""Double-CNOT gate.
+
+    A 2-qubit Clifford gate consisting of two back-to-back
+    CNOTs with alternate controls.
+
+    Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
+    with the :meth:`~qiskit.circuit.QuantumCircuit.dcx` method.
+
+    .. parsed-literal::
+                  ┌───┐
+        q_0: ──■──┤ X ├
+             ┌─┴─┐└─┬─┘
+        q_1: ┤ X ├──■──
+             └───┘
+
+    This is a classical logic gate, equivalent to a CNOT-SWAP (CNS) sequence,
+    and locally equivalent to an iSWAP.
+
+    .. math::
+
+        DCX\ q_0, q_1 =
+            \begin{pmatrix}
+                1 & 0 & 0 & 0 \\
+                0 & 0 & 0 & 1 \\
+                0 & 1 & 0 & 0 \\
+                0 & 0 & 1 & 0
+            \end{pmatrix}
+    """
+
+    def __init__(self, label=None, *, duration=None, unit="dt"):
+        """Create new DCX gate."""
+        super().__init__("dcx", 2, [], label=label, duration=duration, unit=unit)
+
+    _singleton_lookup_key = stdlib_singleton_key()
+
+    def _define(self):
+        """
+        gate dcx a, b { cx a, b; cx b, a; }
+        """
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from .x import CXGate
+
+        q = QuantumRegister(2, "q")
+        qc = QuantumCircuit(q, name=self.name)
+        rules = [(CXGate(), [q[0], q[1]], []), (CXGate(), [q[1], q[0]], [])]
+        for instr, qargs, cargs in rules:
+            qc._append(instr, qargs, cargs)
+
+        self.definition = qc

qiskit/circuit/library/standard_gates/ecr.py

@@ -0,0 +1,114 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Two-qubit ZX-rotation gate."""
+from math import sqrt
+import numpy as np
+
+from qiskit.circuit._utils import with_gate_array
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.singleton import SingletonGate, stdlib_singleton_key
+from .rzx import RZXGate
+from .x import XGate
+
+
+@with_gate_array(
+    sqrt(0.5) * np.array([[0, 1, 0, 1.0j], [1, 0, -1.0j, 0], [0, 1.0j, 0, 1], [-1.0j, 0, 1, 0]])
+)
+class ECRGate(SingletonGate):
+    r"""An echoed cross-resonance gate.
+
+    This gate is maximally entangling and is equivalent to a CNOT up to
+    single-qubit pre-rotations. The echoing procedure mitigates some
+    unwanted terms (terms other than ZX) to cancel in an experiment.
+    More specifically, this gate implements :math:`\frac{1}{\sqrt{2}}(IX-XY)`.
+
+    Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
+    with the :meth:`~qiskit.circuit.QuantumCircuit.ecr` method.
+
+    **Circuit Symbol:**
+
+    .. parsed-literal::
+
+             ┌─────────┐            ┌────────────┐┌────────┐┌─────────────┐
+        q_0: ┤0        ├       q_0: ┤0           ├┤ RX(pi) ├┤0            ├
+             │   ECR   │   =        │  RZX(pi/4) │└────────┘│  RZX(-pi/4) │
+        q_1: ┤1        ├       q_1: ┤1           ├──────────┤1            ├
+             └─────────┘            └────────────┘          └─────────────┘
+
+    **Matrix Representation:**
+
+    .. math::
+
+        ECR\ q_0, q_1 = \frac{1}{\sqrt{2}}
+            \begin{pmatrix}
+                0   & 1   &  0  & i \\
+                1   & 0   &  -i & 0 \\
+                0   & i   &  0  & 1 \\
+                -i  & 0   &  1  & 0
+            \end{pmatrix}
+
+    .. note::
+
+        In Qiskit's convention, higher qubit indices are more significant
+        (little endian convention). In the above example we apply the gate
+        on (q_0, q_1) which results in the :math:`X \otimes Z` tensor order.
+        Instead, if we apply it on (q_1, q_0), the matrix will
+        be :math:`Z \otimes X`:
+
+        .. parsed-literal::
+
+                 ┌─────────┐
+            q_0: ┤1        ├
+                 │   ECR   │
+            q_1: ┤0        ├
+                 └─────────┘
+
+        .. math::
+
+            ECR\ q_0, q_1 = \frac{1}{\sqrt{2}}
+                \begin{pmatrix}
+                    0   & 0   &  1  & i \\
+                    0   & 0   &  i  & 1 \\
+                    1   & -i  &  0  & 0 \\
+                    -i  & 1   &  0  & 0
+                \end{pmatrix}
+    """
+
+    def __init__(self, label=None, *, duration=None, unit="dt"):
+        """Create new ECR gate."""
+        super().__init__("ecr", 2, [], label=label, duration=duration, unit=unit)
+
+    _singleton_lookup_key = stdlib_singleton_key()
+
+    def _define(self):
+        """
+        gate ecr a, b { rzx(pi/4) a, b; x a; rzx(-pi/4) a, b;}
+        """
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+        q = QuantumRegister(2, "q")
+        qc = QuantumCircuit(q, name=self.name)
+        rules = [
+            (RZXGate(np.pi / 4), [q[0], q[1]], []),
+            (XGate(), [q[0]], []),
+            (RZXGate(-np.pi / 4), [q[0], q[1]], []),
+        ]
+        for instr, qargs, cargs in rules:
+            qc._append(instr, qargs, cargs)
+
+        self.definition = qc
+
+    def inverse(self):
+        """Return inverse ECR gate (itself)."""
+        return ECRGate()  # self-inverse