Fix measurement count for MPP (#48)

In the current implementation, the number of measurements in one
measurement instruction is counted as the number of targets in this
instruction. But it is wrong if the measurement instruction is MPP. For
example
```
MPP X0 * X1
```
will have three targets but only one measurement.

This PR fixed this issue and was used in STAR simulation.

Author: ChenZhao44

src/tsim/noise/dem.py

@@ -122,7 +122,15 @@ def get_detector_error_model(
             "MY",
             "MZ",
         ]:
-            num_meas = len(instruction.targets_copy())
+            targets = instruction.targets_copy()
+            if instruction.name == "MPP":
+                # MPP produces one measurement per Pauli product.
+                # Products are separated by spaces; within a product, Paulis are joined by '*' (combiners).
+                # num_measurements = num_non_combiner_targets - num_combiners
+                num_combiners = sum(1 for t in targets if t.is_combiner)
+                num_meas = len(targets) - 2 * num_combiners
+            else:
+                num_meas = len(targets)
             for idx in obs:
                 # update measurement rec indices for the OBSERVABLE_INCLUDE instructions
                 obs[idx] = [t - num_meas for t in obs[idx]]
@@ -162,6 +170,7 @@ def get_detector_error_model(
     )
 
     new_dem = stim.DetectorErrorModel()
+
     for instruction in dem:
         assert not isinstance(instruction, stim.DemRepeatBlock)
 
@@ -170,7 +179,7 @@ def get_detector_error_model(
         for t in instruction.targets_copy():
             if (
                 isinstance(t, stim.DemTarget)
-                and t.is_relative_detector_id
+                and t.is_relative_detector_id()
                 and t.val in mapping
             ):
                 new_targets.append(stim.target_logical_observable_id(mapping[t.val]))
@@ -185,9 +194,16 @@ def get_detector_error_model(
             new_targets,
         )
 
+        # Remove gauge statements that only affect logical observables (e.g., "error(0.5) L0").
+        # These arise from non-deterministic observables and should not appear in the final DEM.
         if instruction.args_copy() == [0.5]:
-            # remove gauge statements "error(0.5) L<idx>"
-            continue
+            # Check if all targets are logical observables (no detectors)
+            all_logical = all(
+                isinstance(t, stim.DemTarget) and t.is_logical_observable_id()
+                for t in new_targets
+            )
+            if all_logical:
+                continue
 
         new_dem.append(new_instruction)
 

test/unit/noise/test_dem.py

@@ -72,8 +72,11 @@ def test_get_detector_error_model_with_gauge_detectors():
         DETECTOR rec[-2]
         """
     )
+    # Gauge errors that only trigger observables (error(0.5) L0) are removed,
+    # but gauge errors that trigger detectors (error(0.5) D0) are kept.
     assert get_detector_error_model(c).approx_equals(
-        stim.DetectorErrorModel("error(0.01) D0 L0"), atol=1e-12
+        stim.DetectorErrorModel("error(0.5) D0\n error(0.01) D0 L0"),
+        atol=1e-12,
     )
 
 
@@ -111,7 +114,6 @@ def test_get_detector_error_model_no_errors():
 
 
 def test_get_detector_error_model_with_logical_observables():
-
     with pytest.raises(
         ValueError, match="The number of observables changed after conversion."
     ):
@@ -125,3 +127,95 @@ def test_get_detector_error_model_with_logical_observables():
             """
         )
         get_detector_error_model(c)
+
+
+def test_get_detector_error_model_with_mpp_single_product():
+    """Test that a single MPP product is correctly counted as 1 measurement."""
+    # MPP X0*X1*X2 measures a single Pauli product and produces exactly 1 measurement
+    c = stim.Circuit(
+        """
+        R 0 1 2
+        H 0 1 2
+        X_ERROR(0.01) 0
+        MPP X0*X1*X2
+        OBSERVABLE_INCLUDE(0) rec[-1]
+        M 0
+        DETECTOR rec[-1] rec[-2]
+        """
+    )
+    dem = get_detector_error_model(c)
+    assert dem.num_detectors == 1
+    assert dem.num_observables == 1
+    assert "D0" in str(dem)
+    assert "L0" in str(dem)
+
+
+def test_get_detector_error_model_with_mpp_multiple_products():
+    """Test that MPP with multiple products produces one measurement per product.
+
+    MPP X0*X1 Z2*Z3 Y4 produces 3 measurements (one per space-separated product).
+    """
+    c = stim.Circuit(
+        """
+        R 0 1 2 3 4
+        H 0 1 2 3 4
+        X_ERROR(0.01) 0
+        MPP X0*X1 Z2*Z3 Y4
+        OBSERVABLE_INCLUDE(0) rec[-3]
+        M 0
+        DETECTOR rec[-1] rec[-4]
+        """
+    )
+    dem = get_detector_error_model(c)
+    # rec[-3] refers to the first MPP product (X0*X1) since MPP produces 3 measurements
+    # and then M produces 1, so rec[-4] is X0*X1, rec[-3] is Z2*Z3, rec[-2] is Y4, rec[-1] is M
+    assert dem.num_detectors == 1
+    assert dem.num_observables == 1
+
+
+def test_get_detector_error_model_with_multiple_mpp_instructions():
+    """Test multiple separate MPP instructions with OBSERVABLE_INCLUDE between them."""
+    c = stim.Circuit(
+        """
+        R 0 1 2 3
+        H 0 1 2 3
+        X_ERROR(0.01) 0
+        MPP X0*X1
+        OBSERVABLE_INCLUDE(0) rec[-1]
+        MPP X2*X3
+        DETECTOR rec[-1] rec[-2]
+        """
+    )
+    dem = get_detector_error_model(c)
+    assert dem.num_detectors == 1
+    assert dem.num_observables == 1
+
+
+def test_get_detector_error_model_mpp_measurement_counting():
+    """Test correct measurement counting for MPP vs regular M measurements.
+
+    This test verifies that rec indices are correctly adjusted when MPP instructions
+    produce multiple measurements. The circuit has a non-deterministic observable
+    (Z2*Z3 measured on |++⟩ state), which should raise a ValueError because stim
+    interprets it as a gauge and eliminates it.
+    """
+    # Circuit with MPP producing 2 measurements + M producing 2 measurements
+    c = stim.Circuit(
+        """
+        R 0 1 2 3
+        H 0 1 2 3
+        Z_ERROR(0.01) 0
+        MPP Z0*Z1 Z2*Z3
+        M 0 1
+        OBSERVABLE_INCLUDE(0) rec[-3]
+        DETECTOR rec[-4] rec[-2] rec[-1]
+        """
+    )
+    # MPP Z0*Z1 Z2*Z3 produces 2 measurements: rec[-4] and rec[-3] (before M)
+    # M 0 1 produces 2 measurements: rec[-2] and rec[-1]
+    # OBSERVABLE_INCLUDE(0) rec[-3] refers to the Z2*Z3 measurement
+    # Since the observable is non-deterministic (gauge), it gets eliminated
+    with pytest.raises(
+        ValueError, match="The number of observables changed after conversion."
+    ):
+        get_detector_error_model(c)