From b3d657293206bdb535084504b424fffc13841385 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Thu, 1 Oct 2026 13:40:07 +0000
Subject: [PATCH] [qec] Share Stim measure-line emission in the emitter module

Both builders call stim_emit::emit_measure_line. Single-block memory still chooses MZ or MX. Lattice surgery still passes MZ and keeps its record count. Closing detectors stay in the builder. Checked-in Stim gold stays byte-identical.

Refs #473

Co-authored-by: Arnab Ghosh <ag2583@cornell.edu>
---
 quon_qec/src/experiment.rs           | 26 +++++++------------
 quon_qec/src/experiment/stim_emit.rs | 39 +++++++++++++++++++++++-----
 2 files changed, 41 insertions(+), 24 deletions(-)

diff --git a/quon_qec/src/experiment.rs b/quon_qec/src/experiment.rs
index 255e6e0..a8d7425 100644
--- a/quon_qec/src/experiment.rs
+++ b/quon_qec/src/experiment.rs
@@ -555,15 +555,15 @@ fn emit_stim_single_block_memory(expanded: &ExpandedWorkload) -> Result<String,
         block.data_atoms.clone()
     };
 
+    let mut data_ids = Vec::with_capacity(data_atoms.len());
+    for atom in &data_atoms {
+        data_ids.push(atom.0);
+    }
     let measure_op = match measure_basis {
         LogicalBasis::Z => "MZ",
         LogicalBasis::X => "MX",
     };
-    out.push_str(measure_op);
-    for atom in &data_atoms {
-        out.push_str(&format!(" {}", atom.0));
-    }
-    out.push('\n');
+    stim_emit::emit_measure_line(&mut out, measure_op, &data_ids);
 
     // Close detectors in the measure basis against final data measurements.
     let closing_indices: Vec<usize> = match measure_basis {
@@ -591,10 +591,6 @@ fn emit_stim_single_block_memory(expanded: &ExpandedWorkload) -> Result<String,
     }
 
     let obs_atoms = logical_observable_atoms(block, measure_basis);
-    let mut data_ids = Vec::with_capacity(data_atoms.len());
-    for atom in &data_atoms {
-        data_ids.push(atom.0);
-    }
     stim_emit::emit_observable_include(&mut out, 0, &data_ids, &obs_atoms)?;
     out.push('\n');
 
@@ -659,8 +655,8 @@ fn emit_stim_lattice_surgery_cx(expanded: &ExpandedWorkload) -> Result<String, E
 
     // Round kinds append through [`stim_emit::StimRoundEmitter`]. Byproduct
     // handles and deferred measure-logical rounds come back out so the
-    // builder can write measure lines and frame records around
-    // [`stim_emit::emit_observable_include`].
+    // builder can count records and append frame targets around
+    // [`stim_emit::emit_measure_line`] and [`stim_emit::emit_observable_include`].
     let mut ctx = stim_emit::LatticeSurgeryCtx::new(expanded, control, target, ancilla, out);
     for round in &expanded.rounds {
         stim_emit::lattice_round_emitter(round.kind).emit(&mut ctx, round)?;
@@ -687,12 +683,8 @@ fn emit_stim_lattice_surgery_cx(expanded: &ExpandedWorkload) -> Result<String, E
         if data_atoms.is_empty() {
             continue;
         }
-        out.push_str("MZ");
-        for id in &data_atoms {
-            out.push_str(&format!(" {id}"));
-            rec_count += 1;
-        }
-        out.push('\n');
+        stim_emit::emit_measure_line(&mut out, "MZ", &data_atoms);
+        rec_count += data_atoms.len() as i32;
         let block = expanded
             .blocks
             .iter()
diff --git a/quon_qec/src/experiment/stim_emit.rs b/quon_qec/src/experiment/stim_emit.rs
index b3e69f0..644dcb2 100644
--- a/quon_qec/src/experiment/stim_emit.rs
+++ b/quon_qec/src/experiment/stim_emit.rs
@@ -10,11 +10,12 @@
 //! kind is a new impl plus one arm in [`lattice_round_emitter`].
 //!
 //! Both builders share [`emit_reset_tick`] for the prepare-`R` / `TICK` line,
-//! [`emit_qubit_coords`] for `QUBIT_COORDS`, [`emit_single_block_header`] /
+//! [`emit_qubit_coords`] for `QUBIT_COORDS`, [`emit_measure_line`] for the
+//! final `MZ` / `MX` line, [`emit_single_block_header`] /
 //! [`emit_lattice_surgery_header`] for the comment preamble, and
 //! [`emit_observable_include`] for `OBSERVABLE_INCLUDE` record offsets.
-//! Measure lines and closing detectors stay in the builders. Lattice surgery
-//! still appends frame-byproduct records after the shared observable line.
+//! Closing detectors stay in the single-block builder. Lattice surgery still
+//! appends frame-byproduct records after the shared observable line.
 
 use std::collections::HashMap;
 
@@ -38,6 +39,19 @@ pub(crate) fn emit_reset_tick(out: &mut String, atom_ids: &[u32]) {
     out.push_str("\nTICK\n");
 }
 
+/// Write `{op} <ids>\n` in caller order.
+///
+/// Single-block memory passes `MZ` or `MX`. Lattice surgery passes `MZ` and
+/// keeps its own record counter. This function does not reorder or skip an
+/// empty id list: an empty list is `{op}\n`.
+pub(crate) fn emit_measure_line(out: &mut String, op: &str, atom_ids: &[u32]) {
+    out.push_str(op);
+    for id in atom_ids {
+        out.push_str(&format!(" {id}"));
+    }
+    out.push('\n');
+}
+
 /// Write `OBSERVABLE_INCLUDE({obs_id})` and one `rec[-(d - pos)]` per
 /// observable atom.
 ///
@@ -150,10 +164,11 @@ impl<'a> LatticeSurgeryCtx<'a> {
 
 /// Stim state for one single-block memory circuit.
 ///
-/// The builder still writes the final measure line and closing detectors.
-/// [`emit_single_block_header`] writes the comment preamble before this
-/// context exists. Round impls append construct locals, memory rounds, and
-/// the measure-logical record. [`emit_observable_include`] writes the observable.
+/// The builder still writes closing detectors. [`emit_single_block_header`]
+/// writes the comment preamble before this context exists. Round impls append
+/// construct locals, memory rounds, and the measure-logical record.
+/// [`emit_measure_line`] writes the final measure line.
+/// [`emit_observable_include`] writes the observable.
 pub(crate) struct SingleBlockCtx<'a> {
     pub(crate) out: String,
     pub(crate) n_checks: usize,
@@ -805,6 +820,16 @@ mod tests {
         );
     }
 
+    #[test]
+    fn measure_line_keeps_caller_order() {
+        let mut out = String::new();
+        emit_measure_line(&mut out, "MZ", &[4, 0, 4]);
+        assert_eq!(out, "MZ 4 0 4\n");
+        let mut empty = String::new();
+        emit_measure_line(&mut empty, "MX", &[]);
+        assert_eq!(empty, "MX\n");
+    }
+
     #[test]
     fn qubit_coords_keep_caller_order() {
         let mut out = String::new();