EchoRZXWeylDecomposition Transpiler Pass

qiskit/quantum_info/synthesis/two_qubit_decompose.py

@@ -547,6 +547,95 @@ def specialize(self):
         self.K2r = np.asarray(RYGate(k2rtheta)) @ np.asarray(RXGate(k2rlambda))
 
 
+class TwoQubitWeylEchoRZX:
+    """Decompose two-qubit unitary in terms of echoed cross-resonance gates."""
+
+    _default_1q_basis = "XYX"
+
+    def __init__(self, unitary, is_native: bool):
+        """Initialize the KAK decomposition.
+
+        Args:
+            is_native: If True then the CX schedule on qubits (q0, q1)
+                is shorter than the schedule on (q1, q0).
+        """
+        self.is_native = is_native
+
+        self.decomposer = TwoQubitWeylDecomposition(unitary)
+
+    def circuit(self, *, euler_basis: Optional[str] = None, atol=DEFAULT_ATOL) -> QuantumCircuit:
+        """Returns Weyl decomposition in circuit form.
+
+        simplify, atol arguments are passed to OneQubitEulerDecomposer"""
+        if euler_basis is None:
+            euler_basis = self._default_1q_basis
+        oneq_decompose = OneQubitEulerDecomposer(euler_basis)
+        c1l, c1r, c2l, c2r = (
+            oneq_decompose(k, atol=atol)
+            for k in (
+                self.decomposer.K1l,
+                self.decomposer.K1r,
+                self.decomposer.K2l,
+                self.decomposer.K2r,
+            )
+        )
+        circ = QuantumCircuit(2, global_phase=self.decomposer.global_phase)
+        circ.compose(c2r, [0], inplace=True)
+        circ.compose(c2l, [1], inplace=True)
+        self._weyl_gate(circ, atol)
+        circ.compose(c1r, [0], inplace=True)
+        circ.compose(c1l, [1], inplace=True)
+        return circ
+
+    @staticmethod
+    def _apply_rzx(circ: QuantumCircuit, angle: float):
+        """Echoed RZX gate"""
+        circ.rzx(-angle, 0, 1)
+        circ.x(0)
+        circ.rzx(angle, 0, 1)
+        circ.x(0)
+
+    @staticmethod
+    def _apply_reverse_rzx(circ: QuantumCircuit, angle: float):
+        """Reverse direction of the echoed RZX gate"""
+        circ.h(0)
+        circ.h(1)
+        circ.rzx(-angle, 1, 0)
+        circ.x(1)
+        circ.rzx(angle, 1, 0)
+        circ.x(1)
+        circ.h(0)
+        circ.h(1)
+
+    def _weyl_gate(self, circ: QuantumCircuit, atol=1.0e-13):
+        """Appends Ud(a, b, c) to the circuit."""
+        circ.h(0)
+        if abs(self.decomposer.a) > atol:
+            if self.is_native:
+                self._apply_rzx(circ, self.decomposer.a)
+            else:
+                self._apply_reverse_rzx(circ, self.decomposer.a)
+        circ.h(0)
+        circ.sdg(0)
+        circ.h(0)
+        circ.sdg(1)
+        if abs(self.decomposer.b) > atol:
+            if self.is_native:
+                self._apply_rzx(circ, self.decomposer.b)
+            else:
+                self._apply_reverse_rzx(circ, self.decomposer.b)
+        circ.h(0)
+        circ.s(0)
+        circ.s(1)
+        circ.h(1)
+        if abs(self.decomposer.c) > atol:
+            if self.is_native:
+                self._apply_rzx(circ, self.decomposer.c)
+            else:
+                self._apply_reverse_rzx(circ, self.decomposer.c)
+        circ.h(1)
+
+
 class TwoQubitWeylMirrorControlledEquiv(TwoQubitWeylDecomposition):
     """U ~ Ud(𝜋/4, 𝜋/4, α) ~ SWAP . Ctrl-U
 

qiskit/transpiler/passes/optimization/echo_rzx_weyl_decomposition.py

@@ -0,0 +1,90 @@
+# 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.
+
+"""Weyl decomposition of two-qubit gates in terms of echoed cross-resonance gates."""
+
+from typing import Tuple
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.converters import circuit_to_dag
+
+from qiskit.transpiler.layout import Layout
+
+import qiskit.quantum_info as qi
+
+from qiskit.quantum_info.synthesis.two_qubit_decompose import TwoQubitWeylEchoRZX
+
+
+class EchoRZXWeylDecomposition(TransformationPass):
+    """Rewrite two-qubit gates using the Weyl decomposition.
+
+    This transpiler pass rewrites two-qubit gates in terms of echoed cross-resonance gates according
+    to the Weyl decomposition. A two-qubit gate will be replaced with at most six non-echoed RZXGates.
+    Each pair of RZXGates forms an echoed RZXGate.
+    """
+
+    def __init__(self, inst_map):
+        """EchoRZXWeylDecomposition pass."""
+        self.inst_map = inst_map
+        super().__init__()
+
+    def _is_native(self, qubit_pair: Tuple) -> bool:
+        """Return the direction of the qubit pair that is native, i.e. with the shortest schedule."""
+        cx1 = self.inst_map.get("cx", qubit_pair)
+        cx2 = self.inst_map.get("cx", qubit_pair[::-1])
+        return cx1.duration < cx2.duration
+
+    def run(self, dag: DAGCircuit):
+        """Run the EchoRZXWeylDecomposition pass on `dag`.
+
+        Rewrites two-qubit gates in an arbitrary circuit in terms of echoed cross-resonance
+        gates by computing the Weyl decomposition of the corresponding unitary. Modifies the
+        input dag.
+
+        Args:
+            dag (DAGCircuit): DAG to map.
+
+        Returns:
+            DAGCircuit: The rearranged dag.
+
+        Raises:
+            TranspilerError: If the circuit cannot be mapped.
+        """
+
+        if len(dag.qregs) > 1:
+            raise TranspilerError(
+                "EchoRZXWeylDecomposition expects a single qreg input DAG,"
+                f"but input DAG had qregs: {dag.qregs}."
+            )
+
+        trivial_layout = Layout.generate_trivial_layout(*dag.qregs.values())
+
+        for node in dag.two_qubit_ops():
+            if node.type == "op":
+                control = node.qargs[0]
+                target = node.qargs[1]
+
+                physical_q0 = trivial_layout[control]
+                physical_q1 = trivial_layout[target]
+
+                is_native = self._is_native((physical_q0, physical_q1))
+
+                unitary = qi.Operator(node.op).data
+                dag_weyl = circuit_to_dag(
+                    TwoQubitWeylEchoRZX(unitary, is_native=is_native).circuit()
+                )
+                dag.substitute_node_with_dag(node, dag_weyl)
+
+        return dag

qiskit/transpiler/passes/scheduling/calibration_creators.py

@@ -13,7 +13,7 @@
 """Calibration creators."""
 
 import math
-from typing import List, Union
+from typing import List, Union, Optional, Dict, Tuple
 from abc import abstractmethod
 import numpy as np
 
@@ -28,7 +28,7 @@
 )
 from qiskit.pulse.instructions.instruction import Instruction
 from qiskit.exceptions import QiskitError
-from qiskit.providers import basebackend
+from qiskit.providers import BaseBackend
 from qiskit.dagcircuit import DAGNode
 from qiskit.circuit.library.standard_gates import RZXGate
 from qiskit.transpiler.basepasses import TransformationPass
@@ -64,7 +64,7 @@ def run(self, dag):
 
                     schedule = self.get_calibration(params, qubits)
 
-                    dag.add_calibration(node.op, qubits, schedule, params=params)
+                    dag.add_calibration(node.op.name, qubits, schedule, params=params)
 
         return dag
 
@@ -82,26 +82,35 @@ class RZXCalibrationBuilder(CalibrationCreator):
     angle. Additional details can be found in https://arxiv.org/abs/2012.11660.
     """
 
-    def __init__(self, backend: basebackend):
+    def __init__(
+        self,
+        backend: Optional[BaseBackend] = None,
+        inst_map: Optional[Dict[str, Dict[Tuple[int], Schedule]]] = None,
+    ):
         """
         Initializes a RZXGate calibration builder.
 
         Args:
+            inst_map: Instruction schedule map.
             backend: Backend for which to construct the gates.
 
         Raises:
             QiskitError: if open pulse is not supported by the backend.
         """
+
         super().__init__()
-        if not backend.configuration().open_pulse:
-            raise QiskitError(
-                "Calibrations can only be added to Pulse-enabled backends, "
-                "but {} is not enabled with Pulse.".format(backend.name())
-            )
 
-        self._inst_map = backend.defaults().instruction_schedule_map
-        self._config = backend.configuration()
-        self._channel_map = backend.configuration().qubit_channel_mapping
+        if backend is not None:
+            self._inst_map = backend.defaults().instruction_schedule_map
+            if not backend.configuration().open_pulse:
+                raise QiskitError(
+                    "Calibrations can only be added to Pulse-enabled backends, "
+                    "but {} is not enabled with Pulse.".format(backend.name())
+                )
+        elif inst_map is not None:
+            self._inst_map = inst_map
+        else:
+            raise QiskitError("Either a backend or an instruction schedule map must be specified.")
 
     def supported(self, node_op: DAGNode) -> bool:
         """
@@ -272,10 +281,10 @@ class RZXCalibrationBuilderNoEcho(RZXCalibrationBuilder):
 
     The ``RZXCalibrationBuilderNoEcho`` is a variation of the
     :class:`~qiskit.transpiler.passes.RZXCalibrationBuilder` pass
-    that creates calibrations for the cross-resonance pulses without inserting
+    as it creates calibrations for the cross-resonance pulses without inserting
     the echo pulses in the pulse schedule. This enables exposing the echo in
     the cross-resonance sequence as gates so that the transpiler can simplify them.
-    The ``RZXCalibrationBuilderNoEcho`` only supports the hardware-native direction
+    The RZXCalibrationBuilderNoEcho only supports the hardware-native direction
     of the CX gate.
     """
 
@@ -289,7 +298,7 @@ def _filter_control(inst: (int, Union["Schedule", Instruction])) -> bool:
 
         Returns:
             match: True if the instruction is a Play instruction with
-                a Gaussian square pulse on the ControlChannel.
+            a Gaussian square pulse on the ControlChannel.
         """
         if isinstance(inst[1], Play):
             if isinstance(inst[1].pulse, GaussianSquare) and isinstance(
@@ -309,7 +318,7 @@ def _filter_drive(inst: (int, Union["Schedule", Instruction])) -> bool:
 
         Returns:
             match: True if the instruction is a Play instruction with
-                a Gaussian square pulse on the DriveChannel.
+            a Gaussian square pulse on the DriveChannel.
         """
         if isinstance(inst[1], Play):
             if isinstance(inst[1].pulse, GaussianSquare) and isinstance(