Add UCC+DDD compiler

benchmarks/simulation_benchmarks.toml

@@ -13,6 +13,8 @@ description = "Benchmarks to measure impact of compiling on circuit-specific obs
 [[compilers]]
 id = "ucc"
 [[compilers]]
+id = "ucc-ddd"
+[[compilers]]
 id = "pytket-peep"
 [[compilers]]
 id = "qiskit-default"

pyproject.toml

@@ -16,6 +16,7 @@ dependencies = [
     "qbraid>=0.9.10",
     "qiskit-aer>=0.17.0",
     "qiskit>=1.4.2",
+    "mitiq>=0.44.0",
     "ucc>=0.4.3",
     "pandas>=2.2.3",
     "tabulate>=0.9.0",

src/ucc_bench/compilers/__init__.py

@@ -4,6 +4,7 @@
 from .cirq_compiler import CirqCompiler as CirqCompiler
 from .pytket_compiler import PytketPeepCompiler as PytketPeepCompiler
 from .ucc_compiler import UCCCompiler as UCCCompiler
+from .ucc_ddd_compiler import UCCDDDCompiler as UCCDDDCompiler
 from .pyqpanda3_compiler import (
     PyQPanda3Compiler as PyQPanda3Compiler,
     PYQPANDA3_AVAILABLE as PYQPANDA3_AVAILABLE,

src/ucc_bench/compilers/ucc_ddd_compiler.py

@@ -0,0 +1,49 @@
+from .base_compiler import BaseCompiler
+from qiskit import QuantumCircuit
+from qiskit.providers import Backend
+from typing import Optional
+from qbraid import transpile as qb_transpile
+
+from ucc import __version__ as ucc_version
+from ucc import compile as ucc_compile
+
+from ..registry import register
+
+from mitiq import __version__ as mitiq_version
+from mitiq.ddd import construct_circuits as ddd_construct_circuits
+from mitiq.ddd import rules as ddd_rules
+
+
+@register.compiler("ucc-ddd")
+class UCCDDDCompiler(BaseCompiler[QuantumCircuit]):
+    """
+    UCC compiler followed by Digital Dynamical Decoupling using Mitiq.
+    """
+
+    @classmethod
+    def version(cls) -> str:
+        return f"UCC:{ucc_version}+mitiq:{mitiq_version}"
+
+    def qasm_to_native(self, qasm: str) -> QuantumCircuit:
+        return qb_transpile(qasm, "qiskit")
+
+    def compile(
+        self, circuit: QuantumCircuit, target_device: Optional[Backend] = None
+    ) -> QuantumCircuit:
+        if target_device is not None:
+            compiled = ucc_compile(circuit, target_backend=target_device)
+        else:
+            compiled = ucc_compile(
+                circuit,
+                target_gateset={"rx", "ry", "rz", "h", "cx"},
+            )
+
+        ddd_circuits = ddd_construct_circuits(
+            compiled,
+            rule=ddd_rules.xx,
+            num_trials=1,  # one circuit = no post-processing
+        )
+        return ddd_circuits[0]
+
+    def count_multi_qubit_gates(self, circuit: QuantumCircuit) -> int:
+        return circuit.num_nonlocal_gates()