update sliding window tests to cope with same-H diff-O

Signed-off-by: Kaiqi Yan <kaiqiy@nvidia.com>

Author: kaiqiy-nv

libs/qec/lib/detector_error_model.cpp

@@ -96,6 +96,12 @@ void detector_error_model::canonicalize_for_rounds(
         "or the detector_error_matrix  was computed incorrectly.");
   }
 
+  // Cap the number of "same syndrome, different observable" warnings emitted
+  // per invocation. Short-distance codes can have many such mechanisms, and
+  // logging every one of them would spam the console.
+  constexpr std::size_t max_same_syndrome_diff_obs_warnings = 10;
+  std::size_t num_same_syndrome_diff_obs = 0;
+
   for (std::size_t c = 0; c < num_cols; c++) {
     auto column_index = column_order[c];
     auto &curr_row_indices = row_indices[column_index];
@@ -140,12 +146,14 @@ void detector_error_model::canonicalize_for_rounds(
         // Either the syndrome differs, or the same syndrome has a different
         // observable flip. In both cases this is a distinct error mechanism.
         if (prev_row_indices == curr_row_indices) {
-          cudaq::warn(
-              "detector_error_model::canonicalize_for_rounds: identical "
-              "syndromes exist in detector_error_matrix but have different "
-              "observables in observables_flips_matrix; keeping column {} as a "
-              "distinct error mechanism (previous column {})",
-              column_index, previous_column);
+          if (num_same_syndrome_diff_obs < max_same_syndrome_diff_obs_warnings)
+            cudaq::warn(
+                "detector_error_model::canonicalize_for_rounds: identical "
+                "syndromes exist in detector_error_matrix but have different "
+                "observables in observables_flips_matrix; keeping column {} as "
+                "a distinct error mechanism (previous column {})",
+                column_index, previous_column);
+          num_same_syndrome_diff_obs++;
         }
         new_row_indices.push_back(curr_row_indices);
         new_weights.push_back(error_rates[column_index]);
@@ -156,6 +164,16 @@ void detector_error_model::canonicalize_for_rounds(
     }
   }
 
+  // Emit a single summary if we suppressed any per-column warnings above.
+  if (num_same_syndrome_diff_obs > max_same_syndrome_diff_obs_warnings)
+    cudaq::warn(
+        "detector_error_model::canonicalize_for_rounds: found {} columns with "
+        "identical syndromes but different observables; suppressed {} "
+        "additional warnings (only the first {} were shown).",
+        num_same_syndrome_diff_obs,
+        num_same_syndrome_diff_obs - max_same_syndrome_diff_obs_warnings,
+        max_same_syndrome_diff_obs_warnings);
+
   std::swap(this->error_rates, new_weights);
   if (has_error_ids)
     std::swap(*this->error_ids, new_error_ids);

libs/qec/python/tests/test_sliding_window.py

@@ -46,10 +46,20 @@ def test_sliding_window_1(decoder_name, batched, num_rounds, num_windows):
         col = np.random.randint(0, dem.detector_error_matrix.shape[1])
         syndromes[shot, :] = dem.detector_error_matrix[:, col].T
 
-    # First compare the results of the full decoder to the sliding window
-    # decoder using an inner decoder of the full window size. The results should
-    # be the same.
-    full_decoder = qec.get_decoder(decoder_name, dem.detector_error_matrix)
+    # Compare the full decoder against the sliding window decoder (configured as
+    # a single full-size window). For column-space decoders (single_error_lut)
+    # the corrections must be identical; for matching decoders (pymatching),
+    # same-H/different-O degeneracy makes the exact error column non-unique, so
+    # we instead require each correction to reproduce the input syndrome.
+    if decoder_name == "pymatching":
+        # canonicalize_for_rounds keeps same-syndrome/different-observable
+        # columns distinct; these are parallel edges in the matching graph that
+        # PyMatching's default 'disallow' strategy rejects, so merge them.
+        full_decoder = qec.get_decoder(decoder_name,
+                                       dem.detector_error_matrix,
+                                       merge_strategy="independent")
+    else:
+        full_decoder = qec.get_decoder(decoder_name, dem.detector_error_matrix)
     num_syndromes_per_round = dem.detector_error_matrix.shape[0] // num_rounds
 
     sw_as_full_decoder = qec.get_decoder(
@@ -67,18 +77,69 @@ def test_sliding_window_1(decoder_name, batched, num_rounds, num_windows):
             'merge_strategy': 'smallest_weight'
         })
 
+    # H maps an error (column space) to the syndrome it produces (mod 2).
+    H = np.asarray(dem.detector_error_matrix, dtype=np.int64)
+    # pymatching is a graph/matching decoder: for degenerate same-H/different-O
+    # groups it cannot return a unique column, so validate by syndrome
+    # reproduction rather than exact column equality.
+    check_syndrome_only = decoder_name == "pymatching"
+
     if batched:
         full_results = full_decoder.decode_batch(syndromes)
         sw_results = sw_as_full_decoder.decode_batch(syndromes)
-        num_mismatches = np.count_nonzero(
-            np.any(full_results.result != sw_results.result, axis=1))
-        assert num_mismatches == 0
+        if check_syndrome_only:
+            full_e = np.asarray(full_results.result, dtype=np.int64)
+            sw_e = np.asarray(sw_results.result, dtype=np.int64)
+            target = syndromes.astype(np.int64)
+            # ASSERT: every correction (full and windowed) explains the observed
+            # syndrome, i.e. (H @ e) % 2 == syndrome for all shots.
+            assert np.array_equal((full_e @ H.T) % 2, target)
+            assert np.array_equal((sw_e @ H.T) % 2, target)
+        else:
+            # ASSERT: column-space decoders produce identical corrections.
+            num_mismatches = np.count_nonzero(
+                np.any(full_results.result != sw_results.result, axis=1))
+            assert num_mismatches == 0
 
     else:
         num_mismatches = 0
         for syndrome in syndromes:
             r1 = full_decoder.decode(syndrome)
             r2 = sw_as_full_decoder.decode(syndrome)
-            if not np.array_equal(r1.result, r2.result):
+            if check_syndrome_only:
+                # A correction is valid if it reproduces the observed syndrome
+                # via H (mod 2); count a mismatch if either decoder fails to.
+                target = np.asarray(syndrome, dtype=np.int64)
+                e1 = np.asarray(r1.result, dtype=np.int64)
+                e2 = np.asarray(r2.result, dtype=np.int64)
+                if not (np.array_equal((H @ e1) % 2, target) and np.array_equal(
+                    (H @ e2) % 2, target)):
+                    num_mismatches += 1
+            elif not np.array_equal(r1.result, r2.result):
                 num_mismatches += 1
         assert num_mismatches == 0
+
+
+def test_pymatching_parallel_edges_use_observable_faults():
+    # Same detector syndrome with different observable flips represents
+    # distinct logical fault mechanisms. H-only PyMatching cannot distinguish
+    # them, so the observable-aware path must preserve O and merge parallel
+    # graph edges inside PyMatching rather than dropping DEM columns.
+    H = np.array([[1, 1]], dtype=np.uint8)
+    O = np.array([[1, 0], [0, 1]], dtype=np.uint8)
+    error_rates = np.array([0.1, 0.2], dtype=np.float64)
+
+    with pytest.raises(ValueError, match="Parallel edges not permitted"):
+        qec.get_decoder("pymatching", H)
+
+    decoder = qec.get_decoder("pymatching",
+                              H,
+                              O=O,
+                              error_rate_vec=error_rates,
+                              merge_strategy="independent")
+    result = decoder.decode_batch(np.array([[1]], dtype=np.uint8))
+
+    assert isinstance(result, qec.BatchDecoderResult)
+    assert result.result.shape[0] == 1
+    assert result.result.shape[1] > 0
+    assert result.converged.tolist() == [True]