[WIP] Pulse-efficient Transpiler Passes

qiskit/compiler/transpiler.py

@@ -35,6 +35,7 @@
 from qiskit.transpiler.passmanager_config import PassManagerConfig
 from qiskit.transpiler.preset_passmanagers import (
     level_0_pass_manager,
+    pulse_efficient_pass_manager,
     level_1_pass_manager,
     level_2_pass_manager,
     level_3_pass_manager,
@@ -58,7 +59,8 @@ def transpile(
     dt: Optional[float] = None,
     approximation_degree: Optional[float] = None,
     seed_transpiler: Optional[int] = None,
-    optimization_level: Optional[int] = None,
+    inst_map: Dict[str, Dict[Tuple[int], Schedule]] = None,
+    optimization_level: Union[Optional[int], Optional[str]] = None,
     pass_manager: Optional[PassManager] = None,
     callback: Optional[Callable[[BasePass, DAGCircuit, float, PropertySet, int], Any]] = None,
     output_name: Optional[Union[str, List[str]]] = None,
@@ -186,6 +188,7 @@ def callback_func(**kwargs):
 
         output_name: A list with strings to identify the output circuits. The length of
             the list should be exactly the length of the ``circuits`` parameter.
+        inst_map: Instruction schedule map.
 
     Returns:
         The transpiled circuit(s).
@@ -221,6 +224,7 @@ def callback_func(**kwargs):
             translation_method=translation_method,
             approximation_degree=approximation_degree,
             backend=backend,
+            inst_map=inst_map,
         )
 
         warnings.warn(
@@ -260,6 +264,7 @@ def callback_func(**kwargs):
         dt,
         approximation_degree,
         seed_transpiler,
+        inst_map,
         optimization_level,
         callback,
         output_name,
@@ -352,8 +357,12 @@ def _transpile_circuit(circuit_config_tuple: Tuple[QuantumCircuit, Dict]) -> Qua
         pass_manager = level_2_pass_manager(pass_manager_config)
     elif level == 3:
         pass_manager = level_3_pass_manager(pass_manager_config)
+    elif level == "pulse_efficient":
+        pass_manager = pulse_efficient_pass_manager(pass_manager_config)
     else:
-        raise TranspilerError("optimization_level can range from 0 to 3.")
+        raise TranspilerError(
+            "optimization_level can range from 0 to 3, or can be 'pulse_efficient'."
+        )
 
     result = pass_manager.run(
         circuit, callback=transpile_config["callback"], output_name=transpile_config["output_name"]
@@ -440,6 +449,7 @@ def _parse_transpile_args(
     dt,
     approximation_degree,
     seed_transpiler,
+    inst_map,
     optimization_level,
     callback,
     output_name,
@@ -475,6 +485,7 @@ def _parse_transpile_args(
     translation_method = _parse_translation_method(translation_method, num_circuits)
     approximation_degree = _parse_approximation_degree(approximation_degree, num_circuits)
     seed_transpiler = _parse_seed_transpiler(seed_transpiler, num_circuits)
+    inst_map = _parse_inst_map(inst_map, backend, num_circuits)
     optimization_level = _parse_optimization_level(optimization_level, num_circuits)
     output_name = _parse_output_name(output_name, circuits)
     callback = _parse_callback(callback, num_circuits)
@@ -499,6 +510,7 @@ def _parse_transpile_args(
         durations,
         approximation_degree,
         seed_transpiler,
+        inst_map,
         optimization_level,
         output_name,
         callback,
@@ -518,12 +530,13 @@ def _parse_transpile_args(
                 instruction_durations=args[8],
                 approximation_degree=args[9],
                 seed_transpiler=args[10],
+                inst_map=args[11],
             ),
-            "optimization_level": args[11],
-            "output_name": args[12],
-            "callback": args[13],
-            "backend_num_qubits": args[14],
-            "faulty_qubits_map": args[15],
+            "optimization_level": args[12],
+            "output_name": args[13],
+            "callback": args[14],
+            "backend_num_qubits": args[15],
+            "faulty_qubits_map": args[16],
         }
         list_transpile_args.append(transpile_args)
 
@@ -770,6 +783,16 @@ def _parse_seed_transpiler(seed_transpiler, num_circuits):
     return seed_transpiler
 
 
+def _parse_inst_map(inst_map, backend, num_circuits):
+    if inst_map is None:
+        if backend.defaults():
+            backend_defaults = backend.defaults()
+            inst_map = backend_defaults.instruction_schedule_map
+    if not isinstance(inst_map, list):
+        inst_map = [inst_map] * num_circuits
+    return inst_map
+
+
 def _parse_optimization_level(optimization_level, num_circuits):
     if not isinstance(optimization_level, list):
         optimization_level = [optimization_level] * num_circuits

qiskit/quantum_info/synthesis/two_qubit_decompose.py

@@ -28,7 +28,7 @@
 import io
 import base64
 import warnings
-from typing import ClassVar, Optional
+from typing import ClassVar, Optional, Tuple
 
 import logging
 
@@ -129,12 +129,12 @@ def __init_subclass__(cls, **kwargs):
 
         Make explicitly-instantiated subclass __new__  call base __new__ with fidelity=None"""
         super().__init_subclass__(**kwargs)
-        cls.__new__ = lambda cls, *a, fidelity=None, **k: TwoQubitWeylDecomposition.__new__(
-            cls, *a, fidelity=None, **k
+        cls.__new__ = lambda cls, *a, fidelity=None, inst_map=None, qubit_pair=None, **k: TwoQubitWeylDecomposition.__new__(
+            cls, *a, fidelity=None, inst_map=None, qubit_pair=None, **k
         )
 
     @staticmethod
-    def __new__(cls, unitary_matrix, *, fidelity=(1.0 - 1.0e-9)):
+    def __new__(cls, unitary_matrix, *, fidelity=(1.0 - 1.0e-9), inst_map=None, qubit_pair=None):
         """Perform the Weyl chamber decomposition, and optionally choose a specialized subclass.
 
         The flip into the Weyl Chamber is described in B. Kraus and J. I. Cirac, Phys. Rev. A 63,
@@ -544,6 +544,71 @@ def specialize(self):
         self.K2r = np.asarray(RYGate(k2rtheta)) @ np.asarray(RXGate(k2rlambda))
 
 
+class TwoQubitWeylEchoRZX(TwoQubitWeylGeneral):
+    """Decompose two-qubit unitary in terms of echoed cross-resonance gates."""
+
+    def __init__(self, unitary, inst_map, qubit_pair: Tuple):
+        self.inst_map = inst_map
+        self.qubit_pair = qubit_pair
+        super().__init__(unitary)
+
+
+    @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 is_native_cx(self, qubit_pair: Tuple) -> bool:
+        """Check that a CX for a qubit pair is native."""
+        cx1 = self.inst_map.get("cx", qubit_pair)
+        cx2 = self.inst_map.get("cx", qubit_pair[::-1])
+        return cx1.duration < cx2.duration
+
+    def _weyl_gate(self, simplify, circ: QuantumCircuit, atol):
+        """Appends Ud(a, b, c) to the circuit."""
+        del simplify
+        circ.h(0)
+        if abs(self.a) > atol:
+            if self.is_native_cx(self.qubit_pair):
+                self._apply_rzx(circ, self.a)
+            else:
+                self._apply_reverse_rzx(circ, self.a)
+        circ.h(0)
+        circ.sdg(0)
+        circ.h(0)
+        circ.sdg(1)
+        if abs(self.b) > atol:
+            if self.is_native_cx(self.qubit_pair):
+                self._apply_rzx(circ, self.b)
+            else:
+                self._apply_reverse_rzx(circ, self.b)
+        circ.h(0)
+        circ.s(0)
+        circ.s(1)
+        circ.h(1)
+        if abs(self.c) > atol:
+            if self.is_native_cx(self.qubit_pair):
+                self._apply_rzx(circ, self.c)
+            else:
+                self._apply_reverse_rzx(circ, self.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,84 @@
+# 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 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 run(self, dag):
+        """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]
+
+                qubit_pair = (physical_q0, physical_q1)
+
+                unitary = qi.Operator(node.op).data
+                dag_weyl = circuit_to_dag(
+                    TwoQubitWeylEchoRZX(
+                        unitary, inst_map=self.inst_map, qubit_pair=qubit_pair
+                    ).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,37 @@ 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:
+
+        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(
-                "Calibrations can only be added to Pulse-enabled backends, "
-                "but {} is not enabled with Pulse.".format(backend.name())
-            )
+                    "Either a backend or an instruction schedule map must be specified.")
 
-        self._inst_map = backend.defaults().instruction_schedule_map
-        self._config = backend.configuration()
-        self._channel_map = backend.configuration().qubit_channel_mapping
+        # self._inst_map = inst_map
 
     def supported(self, node_op: DAGNode) -> bool:
         """
@@ -328,6 +339,7 @@ def get_calibration(self, params: List, qubits: List) -> Schedule:
                 support the specified direction of the cx.
         """
         theta = params[0]
+
         q1, q2 = qubits[0], qubits[1]
 
         if not self._inst_map.has("cx", qubits):

qiskit/transpiler/passmanager_config.py

@@ -29,6 +29,7 @@ def __init__(
         backend_properties=None,
         approximation_degree=None,
         seed_transpiler=None,
+        inst_map=None,
     ):
         """Initialize a PassManagerConfig object
 
@@ -54,6 +55,7 @@ def __init__(
                 (1.0=no approximation, 0.0=maximal approximation)
             seed_transpiler (int): Sets random seed for the stochastic parts of
                 the transpiler.
+            inst_map (Dict[str, Dict[Tuple[int], Schedule]]): Schedule instructions
         """
         self.initial_layout = initial_layout
         self.basis_gates = basis_gates
@@ -66,3 +68,4 @@ def __init__(
         self.backend_properties = backend_properties
         self.approximation_degree = approximation_degree
         self.seed_transpiler = seed_transpiler
+        self.inst_map = inst_map