Preserve ordering of gates when translating

Author: caleb-johnson

python/qiskit_paulice/checks.py

@@ -378,31 +378,56 @@ def _input_basis_gates(circuit: QuantumCircuit) -> list[str]:
 
 
 def _translate_to_basis(circuit: QuantumCircuit, basis_gates: list[str]) -> QuantumCircuit:
-    """Re-express ``circuit`` in ``basis_gates`` via basis translation only.
-
-    No coupling map or target is supplied, so this performs a local gate-set
-    translation without any routing or relayout -- qubit placement (and any ISA
-    layout) is preserved. Registers and measurements pass through unchanged.
+    """Re-express ``circuit`` in ``basis_gates`` while **preserving gate order**.
+
+    Running ``BasisTranslator`` on the whole circuit round-trips through a DAG and
+    re-emits gates in a topological order that reshuffles independent (parallel)
+    gates -- which would smear the entangling-layer structure the check picker
+    carefully preserved. Instead each instruction is translated on its own and
+    appended in the circuit's original order, so that structure survives. No
+    coupling map or target is supplied, so there is no routing or relayout; qubit
+    placement (and any ISA layout) is preserved, and measurements pass through.
     """
     pm = PassManager(
         [
             UnrollCustomDefinitions(_SEL, basis_gates),
             BasisTranslator(_SEL, basis_gates),
         ]
     )
-    try:
-        return pm.run(circuit)
-    except TranspilerError:
-        # The input basis can't express the checks the picker inserted -- it is
-        # not universal (e.g. {h, cx}, with no phase gate, as for a virtual GHZ).
-        # Leave the circuit in the package's internal Clifford basis.
-        warnings.warn(
-            f"Could not re-express the output in the input gate set {sorted(basis_gates)}; "
-            "it is not universal for the inserted checks. Returning the circuit in the "
-            "internal Clifford basis instead.",
-            stacklevel=2,
-        )
-        return circuit
+    keep = set(basis_gates) | {"measure", "barrier"}
+    # Translate each unique gate once (Clifford gates carry no parameters, so the name
+    # is a complete key); ``None`` marks a gate the basis cannot express.
+    translated_block: dict[str, QuantumCircuit | None] = {}
+    out = circuit.copy_empty_like()
+    for instruction in circuit.data:
+        op = instruction.operation
+        if op.name in keep:
+            out.append(instruction)
+            continue
+        if op.name not in translated_block:
+            block = QuantumCircuit(op.num_qubits)
+            block.append(op, range(op.num_qubits))
+            try:
+                translated_block[op.name] = pm.run(block)
+            except TranspilerError:
+                translated_block[op.name] = None
+        block = translated_block[op.name]
+        if block is None:
+            # The input basis can't express the checks the picker inserted -- it is not
+            # universal (e.g. {h, cx}, with no phase gate, as for a virtual GHZ). Leave
+            # the circuit in the package's internal Clifford basis (already order-preserved).
+            warnings.warn(
+                f"Could not re-express the output in the input gate set {sorted(basis_gates)}; "
+                "it is not universal for the inserted checks. Returning the circuit in the "
+                "internal Clifford basis instead.",
+                stacklevel=2,
+            )
+            return circuit
+        for sub in block.data:
+            out.append(
+                sub.operation, [instruction.qubits[block.find_bit(q).index] for q in sub.qubits]
+            )
+    return out
 
 
 def _strip_measurements_cregs_barriers(circuit: QuantumCircuit):

releasenotes/notes/order-preserving-translation-7c2e91d4a5b8f012.yaml

@@ -0,0 +1,5 @@
+---
+fixes:
+  - |
+    :func:`qiskit_paulice.add_pauli_checks` now translates its output to the input circuit's gate
+    set gate-by-gate, preserving gate order and the circuit's layer structure.

test/test_checks.py

@@ -130,6 +130,38 @@ def test_non_universal_input_basis_falls_back(self):
             out = _translate_to_basis(qc, ["h", "cx"])
         self.assertEqual(_gate_names(out), {"sx"})
 
+    def test_translation_preserves_gate_order(self):
+        # Whole-circuit BasisTranslator round-trips through a DAG and re-emits
+        # independent gates in topological order, which groups an interleaved
+        # brickwork [(0,1), (2,3), (0,1), (2,3)] into [(0,1), (0,1), (2,3),
+        # (2,3)] and smears the entangling-layer structure the picker preserved.
+        # Translation must keep every payload gate in its original position.
+        num_qubits = 4
+        qc = QuantumCircuit(num_qubits)
+        qc.h(range(num_qubits))
+        for _ in range(3):
+            qc.cx(0, 1)
+            qc.cx(2, 3)
+            for qubit in range(num_qubits):
+                qc.s(qubit)
+        qc.measure_all()
+        checked = add_pauli_checks(qc, [0], _DEFAULT_NOISE, seed=7)[-1]
+
+        def two_qubit_pairs(circuit, payload_only=False):
+            pairs = []
+            for instruction in circuit.data:
+                if len(instruction.qubits) != 2:
+                    continue
+                pair = tuple(sorted(circuit.find_bit(q).index for q in instruction.qubits))
+                if payload_only and max(pair) >= num_qubits:
+                    continue
+                pairs.append(pair)
+            return pairs
+
+        self.assertEqual(
+            two_qubit_pairs(checked.circuit, payload_only=True), two_qubit_pairs(qc)
+        )
+
 
 class TestAddPauliChecksShallowWires(unittest.TestCase):
     """GHZ circuits stress the picker: per-qubit wires are very shallow."""