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

circuit_knitting/cutting/cutting_experiments.py

@@ -37,6 +37,7 @@ def generate_cutting_experiments(
     circuits: QuantumCircuit | dict[Hashable, QuantumCircuit],
     observables: PauliList | dict[Hashable, PauliList],
     num_samples: int | float,
+    basis_gate_set: str | None = None,
 ) -> tuple[
     list[QuantumCircuit] | dict[Hashable, list[QuantumCircuit]],
     list[tuple[float, WeightType]],
@@ -64,6 +65,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.
+        basis_gate_set: 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
@@ -151,7 +154,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,
+                    basis_gate_set=basis_gate_set,
+                    inplace=True,
                 )
                 _append_measurement_circuit(new_qc, cog, inplace=True)
                 subexperiments_dict[label].append(new_qc)

circuit_knitting/cutting/qpd/__init__.py

@@ -24,11 +24,13 @@
     TwoQubitQPDGate,
     QPDMeasure,
 )
+from .translation import translate_qpd_gate
 
 __all__ = [
     "qpdbasis_from_instruction",
     "generate_qpd_weights",
     "decompose_qpd_instructions",
+    "translate_qpd_gate",
     "QPDBasis",
     "BaseQPDGate",
     "TwoQubitQPDGate",

circuit_knitting/cutting/qpd/decompose.py

@@ -23,13 +23,15 @@
 )
 
 from .instructions import BaseQPDGate, TwoQubitQPDGate
+from .translation import translate_qpd_gate
 
 
 def decompose_qpd_instructions(
     circuit: QuantumCircuit,
     instruction_ids: Sequence[Sequence[int]],
     map_ids: Sequence[int] | None = None,
     *,
+    basis_gate_set: 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.
+        basis_gate_set: 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,7 @@ 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, basis_gate_set=basis_gate_set)
 
     return circuit
 
@@ -170,6 +175,7 @@ def _decompose_qpd_instructions(
     circuit: QuantumCircuit,
     instruction_ids: Sequence[Sequence[int]],
     inplace: bool = True,
+    basis_gate_set: str | None = None,
 ) -> QuantumCircuit:
     """Decompose all BaseQPDGate instances, ignoring QPDMeasure()."""
     if not inplace:
@@ -198,6 +204,10 @@ def _decompose_qpd_instructions(
         data_id_offset += 1
         circuit.data.insert(i + data_id_offset, inst2)
 
+    # Get equivalence library
+    if basis_gate_set is not None:
+        basis_gate_set = basis_gate_set.lower()
+
     # 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 +224,13 @@ 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 basis_gate_set is None or data.operation.name in {"qpd_measure"}:
+                tmp_data.append(CircuitInstruction(data.operation, qubits=[qubits[0]]))
+            else:
+                equiv_circ = translate_qpd_gate(data.operation, basis_gate_set)
+                for d in equiv_circ.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/cutting/qpd/translation.py

@@ -0,0 +1,227 @@
+# 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.cutting.qpd.equivalence
+
+.. autosummary::
+   :toctree: ../stubs/
+
+"""
+from __future__ import annotations
+
+from collections.abc import Callable
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit, QuantumRegister, Gate
+from qiskit.circuit.library.standard_gates import (
+    RZGate,
+    XGate,
+    YGate,
+    ZGate,
+    HGate,
+    SGate,
+    SdgGate,
+    SXGate,
+    SXdgGate,
+    TGate,
+    TdgGate,
+    RXGate,
+    RYGate,
+    PhaseGate,
+)
+
+
+_equivalence_from_gate_funcs: dict[str, Callable[[Gate], QuantumCircuit]] = {}
+
+
+def _register_gate(*args):
+    def g(f):
+        for name in args:
+            _equivalence_from_gate_funcs[name] = f
+        return f
+
+    return g
+
+
+def translate_qpd_gate(gate: Gate, basis_gate_set: str, /) -> QuantumCircuit:
+    """
+    Translate a ``gate`` into a given basis gate set.
+
+    This function is designed to handle only the gates to which a :class:`.QPDBasis` can
+    decompose; therefore, not every Qiskit gate is supported by this function.
+
+    Args:
+        gate: The gate to translate
+
+    Returns:
+        A :class:`qiskit.QuantumCircuit` implementing the gate in the given basis gate set.
+
+    Raises:
+        ValueError: Unsupported basis gate set
+        ValueError: Unsupported gate
+    """
+    # We otherwise ignore this arg for now since our only two equivalences are equivalent :)
+    if basis_gate_set not in {"heron", "eagle"}:
+        raise ValueError(f"Unknown basis gate set: {basis_gate_set}")
+    try:
+        f = _equivalence_from_gate_funcs[gate.name]
+    except KeyError as exc:
+        raise ValueError(f"Cannot translate gate: {gate.name}") from exc
+    else:
+        return f(gate)
+
+
+# XGate
+@_register_gate("x")
+def _(gate: XGate):
+    q = QuantumRegister(1, "q")
+    def_x = QuantumCircuit(q)
+    def_x.append(gate, [0], [])
+    return def_x
+
+
+# SXGate
+@_register_gate("sx")
+def _(gate: SXGate):
+    q = QuantumRegister(1, "q")
+    def_sx = QuantumCircuit(q)
+    def_sx.append(gate, [0], [])
+    return def_sx
+
+
+# RZGate
+@_register_gate("rz")
+def _(gate: RZGate):
+    q = QuantumRegister(1, "q")
+    def_rz = QuantumCircuit(q)
+    def_rz.append(gate, [0], [])
+    return def_rz
+
+
+# YGate
+@_register_gate("y")
+def _(_: YGate):
+    q = QuantumRegister(1, "q")
+    def_y = QuantumCircuit(q)
+    for inst in [RZGate(np.pi), XGate()]:
+        def_y.append(inst, [0], [])
+    return def_y
+
+
+# ZGate
+@_register_gate("z")
+def _(_: ZGate):
+    q = QuantumRegister(1, "q")
+    def_z = QuantumCircuit(q)
+    def_z.append(RZGate(np.pi), [0], [])
+    return def_z
+
+
+# HGate
+@_register_gate("h")
+def _(_: 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], [])
+    return def_h
+
+
+# SGate
+@_register_gate("s")
+def _(_: SGate):
+    q = QuantumRegister(1, "q")
+    def_s = QuantumCircuit(q)
+    def_s.append(RZGate(np.pi / 2), [0], [])
+    return def_s
+
+
+# SdgGate
+@_register_gate("sdg")
+def _(_: SdgGate):
+    q = QuantumRegister(1, "q")
+    def_sdg = QuantumCircuit(q)
+    def_sdg.append(RZGate(-np.pi / 2), [0], [])
+    return def_sdg
+
+
+# SXdgGate
+@_register_gate("sxdg")
+def _(_: 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], [])
+    return def_sxdg
+
+
+# TGate
+@_register_gate("t")
+def _(_: TGate):
+    q = QuantumRegister(1, "q")
+    def_t = QuantumCircuit(q)
+    def_t.append(RZGate(np.pi / 4), [0], [])
+    return def_t
+
+
+# TdgGate
+@_register_gate("tdg")
+def _(_: TdgGate):
+    q = QuantumRegister(1, "q")
+    def_tdg = QuantumCircuit(q)
+    def_tdg.append(RZGate(-np.pi / 4), [0], [])
+    return def_tdg
+
+
+# RXGate
+@_register_gate("rx")
+def _(gate: RXGate):
+    q = QuantumRegister(1, "q")
+    def_rx = QuantumCircuit(q)
+    param = gate.params[0]
+    for inst in [
+        RZGate(np.pi / 2),
+        SXGate(),
+        RZGate(param + np.pi),
+        SXGate(),
+        RZGate(5 * np.pi / 2),
+    ]:
+        def_rx.append(inst, [0], [])
+    return def_rx
+
+
+# RYGate
+@_register_gate("ry")
+def _(gate: RYGate):
+    q = QuantumRegister(1, "q")
+    def_ry = QuantumCircuit(q)
+    param = gate.params[0]
+    for inst in [SXGate(), RZGate(param + np.pi), SXGate(), RZGate(3 * np.pi)]:
+        def_ry.append(inst, [0], [])
+
+
+# PhaseGate
+@_register_gate("p")
+def _(gate: PhaseGate):
+    q = QuantumRegister(1, "q")
+    def_p = QuantumCircuit(q)
+    param = gate.params[0]
+    def_p.append(RZGate(param), [0], [])
+    return def_p