Add support for generating subexperiments with LO's translated to a native gate set

circuit_knitting/cutting/cutting_experiments.py

@@ -41,6 +41,7 @@ def generate_cutting_experiments(
     circuits: QuantumCircuit | dict[Hashable, QuantumCircuit],
     observables: PauliList | dict[Hashable, PauliList],
     num_samples: int | float,
+    translate_to_qpu: str | None = None,
 ) -> tuple[
     list[QuantumCircuit] | dict[Hashable, list[QuantumCircuit]],
     list[tuple[float, WeightType]],
@@ -74,6 +75,8 @@ def generate_cutting_experiments(
         num_samples: The number of samples to draw from the quasi-probability distribution. If set
             to infinity, the weights will be generated rigorously rather than by sampling from
             the distribution.
+        translate_to_qpu: A QPU architecture for which the sampled instructions should be
+            translated. Supported inputs are: {"heron", "eagle", None}
     Returns:
         A tuple containing the cutting experiments and their associated coefficients.
         If the input circuits is a :class:`QuantumCircuit` instance, the output subexperiments
@@ -161,7 +164,11 @@ def generate_cutting_experiments(
             for j, cog in enumerate(so.groups):
                 new_qc = _append_measurement_register(subcircuit, cog)
                 decompose_qpd_instructions(
-                    new_qc, subcirc_qpd_gate_ids[label], map_ids_tmp, inplace=True
+                    new_qc,
+                    subcirc_qpd_gate_ids[label],
+                    map_ids_tmp,
+                    translate_to_qpu=translate_to_qpu,
+                    inplace=True,
                 )
                 _append_measurement_circuit(new_qc, cog, inplace=True)
                 subexperiments_dict[label].append(new_qc)

circuit_knitting/cutting/qpd/decompose.py

@@ -23,13 +23,15 @@
 )
 
 from .instructions import BaseQPDGate, TwoQubitQPDGate
+from ...utils.equivalence import equivalence_libraries
 
 
 def decompose_qpd_instructions(
     circuit: QuantumCircuit,
     instruction_ids: Sequence[Sequence[int]],
     map_ids: Sequence[int] | None = None,
     *,
+    translate_to_qpu: str | None = None,
     inplace: bool = False,
 ) -> QuantumCircuit:
     r"""
@@ -43,6 +45,9 @@ def decompose_qpd_instructions(
         map_ids: Indices to a specific linear mapping to be applied to the decompositions
             in the circuit. If no map IDs are provided, the circuit will be decomposed randomly
             according to the decompositions' joint probability distribution.
+        translate_to_qpu: A QPU architecture for which the sampled instructions should be
+            translated. Supported inputs are: {"heron", "eagle", None}
+        inplace: Whether to modify the input circuit directly
 
     Returns:
         Circuit which has had all its :class:`BaseQPDGate` instances decomposed into local operations.
@@ -76,7 +81,9 @@ def decompose_qpd_instructions(
                 circuit.data[gate_id].operation.basis_id = map_ids[i]
 
     # Convert all instances of BaseQPDGate in the circuit to Qiskit instructions
-    _decompose_qpd_instructions(circuit, instruction_ids)
+    _decompose_qpd_instructions(
+        circuit, instruction_ids, translate_to_qpu=translate_to_qpu
+    )
 
     return circuit
 
@@ -170,6 +177,7 @@ def _decompose_qpd_instructions(
     circuit: QuantumCircuit,
     instruction_ids: Sequence[Sequence[int]],
     inplace: bool = True,
+    translate_to_qpu: str | None = None,
 ) -> QuantumCircuit:
     """Decompose all BaseQPDGate instances, ignoring QPDMeasure()."""
     if not inplace:
@@ -198,6 +206,13 @@ def _decompose_qpd_instructions(
         data_id_offset += 1
         circuit.data.insert(i + data_id_offset, inst2)
 
+    # Get equivalence library
+    if translate_to_qpu is not None:
+        translate_to_qpu = translate_to_qpu.lower()
+    else:
+        translate_to_qpu = "standard"
+    equivalence = equivalence_libraries[translate_to_qpu]
+
     # Decompose all the QPDGates (should all be single qubit now) into Qiskit operations
     new_instruction_ids = []
     for i, inst in enumerate(circuit.data):
@@ -214,7 +229,23 @@ def _decompose_qpd_instructions(
         for data in inst.operation.definition.data:
             # Can ignore clbits here, as QPDGates don't use clbits directly
             assert data.clbits == ()
-            tmp_data.append(CircuitInstruction(data.operation, qubits=[qubits[0]]))
+            if equivalence is None:
+                tmp_data.append(CircuitInstruction(data.operation, qubits=[qubits[0]]))
+            else:
+                equiv_entry = equivalence.get_entry(data.operation)
+                # CKT SELs currently only provide at most one translation
+                assert len(equiv_entry) <= 1
+                if equiv_entry == []:
+                    tmp_data.append(
+                        CircuitInstruction(data.operation, qubits=[qubits[0]])
+                    )
+                else:
+                    new_insts = equiv_entry[0]
+                    for d in new_insts.data:
+                        tmp_data.append(
+                            CircuitInstruction(d.operation, qubits=[qubits[0]])
+                        )
+
         # Replace QPDGate with local operations
         if tmp_data:
             # Overwrite the QPDGate with first instruction

circuit_knitting/utils/__init__.py

@@ -59,4 +59,10 @@
 ===================================================================
 
 .. automodule:: circuit_knitting.utils.transpiler_passes
+
+===================================================================
+Gate equivalence rules (:mod:`circuit_knitting.utils.equivalence`)
+===================================================================
+
+.. automodule:: circuit_knitting.utils.equivalence
 """

circuit_knitting/utils/equivalence.py

@@ -0,0 +1,132 @@
+# This code is a Qiskit project.
+
+# (C) Copyright IBM 2024.
+
+# 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.
+
+"""
+Equivalence utilities.
+
+.. currentmodule:: circuit_knitting.utils.equivalence
+
+.. autosummary::
+   :toctree: ../stubs/
+
+"""
+from collections import defaultdict
+
+import numpy as np
+from qiskit.circuit import (
+    EquivalenceLibrary,
+    QuantumCircuit,
+    QuantumRegister,
+    Parameter,
+)
+from qiskit.circuit.library.standard_gates import (
+    RZGate,
+    XGate,
+    YGate,
+    ZGate,
+    HGate,
+    SGate,
+    SdgGate,
+    SXGate,
+    SXdgGate,
+    TGate,
+    TdgGate,
+    RXGate,
+    RYGate,
+    PhaseGate,
+)
+
+_eagle_sel = HeronEquivalenceLibrary = EagleEquivalenceLibrary = EquivalenceLibrary()
+equivalence_libraries = defaultdict(
+    lambda: None, {"heron": HeronEquivalenceLibrary, "eagle": EagleEquivalenceLibrary}
+)
+
+######################################################################
+
+# YGate
+q = QuantumRegister(1, "q")
+def_y = QuantumCircuit(q)
+for inst in [RZGate(np.pi), XGate()]:
+    def_y.append(inst, [0], [])
+_eagle_sel.add_equivalence(YGate(), def_y)
+
+# ZGate
+q = QuantumRegister(1, "q")
+def_z = QuantumCircuit(q)
+def_z.append(RZGate(np.pi), [0], [])
+_eagle_sel.add_equivalence(ZGate(), def_z)
+
+# HGate
+q = QuantumRegister(1, "q")
+def_h = QuantumCircuit(q)
+for inst in [RZGate(np.pi / 2), SXGate(), RZGate(np.pi / 2)]:
+    def_h.append(inst, [0], [])
+_eagle_sel.add_equivalence(HGate(), def_h)
+
+# SGate
+q = QuantumRegister(1, "q")
+def_s = QuantumCircuit(q)
+def_s.append(RZGate(np.pi / 2), [0], [])
+_eagle_sel.add_equivalence(SGate(), def_s)
+
+# SdgGate
+q = QuantumRegister(1, "q")
+def_sdg = QuantumCircuit(q)
+def_sdg.append(RZGate(-np.pi / 2), [0], [])
+_eagle_sel.add_equivalence(SdgGate(), def_sdg)
+
+# SXdgGate
+q = QuantumRegister(1, "q")
+def_sxdg = QuantumCircuit(q)
+for inst in [
+    RZGate(np.pi / 2),
+    RZGate(np.pi / 2),
+    SXGate(),
+    RZGate(np.pi / 2),
+    RZGate(np.pi / 2),
+]:
+    def_sxdg.append(inst, [0], [])
+_eagle_sel.add_equivalence(SXdgGate(), def_sxdg)
+
+# TGate
+q = QuantumRegister(1, "q")
+def_t = QuantumCircuit(q)
+def_t.append(RZGate(np.pi / 4), [0], [])
+_eagle_sel.add_equivalence(TGate(), def_t)
+
+# TdgGate
+q = QuantumRegister(1, "q")
+def_tdg = QuantumCircuit(q)
+def_tdg.append(RZGate(-np.pi / 4), [0], [])
+_eagle_sel.add_equivalence(TdgGate(), def_tdg)
+
+# RXGate
+q = QuantumRegister(1, "q")
+def_rx = QuantumCircuit(q)
+theta = Parameter("theta")
+for inst in [RZGate(np.pi / 2), SXGate(), RZGate(theta + np.pi), SXGate(), RZGate(5 * np.pi / 2)]:
+    def_rx.append(inst, [0], [])
+_eagle_sel.add_equivalence(RXGate(theta), def_rx)
+
+# RYGate
+q = QuantumRegister(1, "q")
+def_ry = QuantumCircuit(q)
+theta = Parameter("theta")
+for inst in [SXGate(), RZGate(theta + np.pi), SXGate(), RZGate(3 * np.pi)]:
+    def_ry.append(inst, [0], [])
+_eagle_sel.add_equivalence(RYGate(theta), def_ry)
+
+# PhaseGate
+q = QuantumRegister(1, "q")
+def_p = QuantumCircuit(q)
+theta = Parameter("theta")
+def_p.append(RZGate(theta), [0], [])
+_eagle_sel.add_equivalence(PhaseGate(theta), def_p)