Add strip_undecomposable_errors=False to decomposition (#218)

The decomposer code written by Oscar is very nice because it is quite
careful not to make any mistakes. For instance in a situation like this:
```
error D0 D1
error D0
```
if we label D0 as X and D1 as Z type, it will raise a ValueError due to
D1 not appearing on its own in the error model. This prevents at least
one possible issue, which is putting the logical flip (if present) onto
the wrong component.

Anyways, sometimes we want to produce an error model anyways, and we
don't care about these errors. In these situations we may as well strip
such undecomposable errors entirely.

Alternative considered: we could also try harder to decompose them and
workaround the lack of a single error with that component's worth of
symptoms in the DEM. I tried this first but I feel it is somewhat higher
risk since it could be silently failing and putting badly-decomposed
errors into the DEM. So I think the best practice should be to strip
them out entirely.

Author: noajshu

.gitignore

@@ -37,3 +37,5 @@ user.bazelrc
 
 # Ignore python extension module produced by CMake.
 src/tesseract_decoder*.so
+
+MODULE.bazel.lock

src/py/_tesseract_py_util/decompose_errors.py

@@ -89,7 +89,9 @@ def get_component_obs_matching_undecomposed_obs(
 
 
 def decompose_errors_using_detector_assignment(
-    dem: stim.DetectorErrorModel, detector_component_func: Callable[[int], int]
+    dem: stim.DetectorErrorModel,
+    detector_component_func: Callable[[int], int],
+    strip_undecomposable_errors: bool = False,
 ) -> stim.DetectorErrorModel:
     """Decomposes errors in the detector error model `dem` based on an assignment of
     detectors to components by the function `detector_component_func`.
@@ -112,6 +114,9 @@ def decompose_errors_using_detector_assignment(
     detector_component_func : Callable[[int], int]
         A function that maps a detector id to its component. i.e. This could map
         a detector index to 0 if it is X-type or to 1 if it is Z-type.
+    strip_undecomposable_errors : bool
+        If True, errors that cannot be decomposed due to a missing component error
+        will be stripped from the output DEM instead of raising a ValueError.
 
     Returns
     -------
@@ -150,21 +155,29 @@ def decompose_errors_using_detector_assignment(
         dets_by_component = []
         obs_options_by_component = []
 
+        is_undecomposable = False
         for c in unique_components:
             component_dets = tuple(
                 sorted(d for d in detectors if det_components[d] == c)
             )
             if component_dets not in single_component_dets_to_obs:
-                raise ValueError(
-                    f"The dem error `{instruction}` needs to be decomposed into components, however "
-                    f"the component with detectors {component_dets} is not present as its own error "
-                    "in the dem."
-                )
+                if strip_undecomposable_errors:
+                    is_undecomposable = True
+                    break
+                else:
+                    raise ValueError(
+                        f"The dem error `{instruction}` needs to be decomposed into components, however "
+                        f"the component with detectors {component_dets} is not present as its own error "
+                        "in the dem."
+                    )
             dets_by_component.append(component_dets)
             obs_options_by_component.append(
                 single_component_dets_to_obs[component_dets]
             )
 
+        if is_undecomposable:
+            continue
+
         # Assign observables to each component, such that they are consistent with the
         # observables of the undecomposed error
         consistent_obs_by_component = get_component_obs_matching_undecomposed_obs(
@@ -202,7 +215,9 @@ def decompose_errors_using_detector_assignment(
 
 
 def decompose_errors_using_detector_coordinate_assignment(
-    dem: stim.DetectorErrorModel, coord_to_component_func: Callable[[list[float]], int]
+    dem: stim.DetectorErrorModel,
+    coord_to_component_func: Callable[[list[float]], int],
+    strip_undecomposable_errors: bool = False,
 ) -> stim.DetectorErrorModel:
     """Decomposes errors in the detector error model `dem` based on an assignment of
     detectors to components using a function of the detector coordinates.
@@ -225,6 +240,9 @@ def decompose_errors_using_detector_coordinate_assignment(
         A function that coordinates of a detector to an integer corresponding to
         the index of a component, to be used for the decomposition. The coordinates
         are provided as a list of floats.
+    strip_undecomposable_errors : bool
+        If True, errors that cannot be decomposed due to a missing component error
+        will be stripped from the output DEM instead of raising a ValueError.
 
     Returns
     -------
@@ -237,7 +255,9 @@ def component_using_coords(detector_id: int) -> int:
         return coord_to_component_func(detector_coords[detector_id])
 
     return decompose_errors_using_detector_assignment(
-        dem=dem, detector_component_func=component_using_coords
+        dem=dem,
+        detector_component_func=component_using_coords,
+        strip_undecomposable_errors=strip_undecomposable_errors,
     )
 
 
@@ -252,6 +272,7 @@ def detector_coord_to_basis_for_stim_surface_code_convention(coord: tuple[int])
 
 def decompose_errors_using_last_coordinate_index(
     dem: stim.DetectorErrorModel,
+    strip_undecomposable_errors: bool = False,
 ) -> stim.DetectorErrorModel:
     """Decomposes errors in the detector error model `dem` based on an assignment of
     detectors to components by the last element of each detector coordinate.
@@ -269,6 +290,9 @@ def decompose_errors_using_last_coordinate_index(
     ----------
     dem : stim.DetectorErrorModel
         The detector error model to decompose.
+    strip_undecomposable_errors : bool
+        If True, errors that cannot be decomposed due to a missing component error
+        will be stripped from the output DEM instead of raising a ValueError.
 
     Returns
     -------
@@ -281,12 +305,15 @@ def last_coordinate_component(detector_id: int) -> int:
         return detector_coords[detector_id][-1]
 
     return decompose_errors_using_detector_assignment(
-        dem=dem, detector_component_func=last_coordinate_component
+        dem=dem,
+        detector_component_func=last_coordinate_component,
+        strip_undecomposable_errors=strip_undecomposable_errors,
     )
 
 
 def decompose_errors_for_stim_surface_code_coords(
     dem: stim.DetectorErrorModel,
+    strip_undecomposable_errors: bool = False,
 ) -> stim.DetectorErrorModel:
     """Decomposes the errors in the dem, such that each component
     of a decomposed error only triggers detectors of one basis (X or Z)
@@ -302,6 +329,9 @@ def decompose_errors_for_stim_surface_code_coords(
     ----------
     dem : stim.DetectorErrorModel
         The detector error model to decompose
+    strip_undecomposable_errors : bool
+        If True, errors that cannot be decomposed due to a missing component error
+        will be stripped from the output DEM instead of raising a ValueError.
 
     Returns
     -------
@@ -316,7 +346,9 @@ def stim_surface_code_det_component(detector_id: int) -> int:
         )
 
     return decompose_errors_using_detector_assignment(
-        dem=dem, detector_component_func=stim_surface_code_det_component
+        dem=dem,
+        detector_component_func=stim_surface_code_det_component,
+        strip_undecomposable_errors=strip_undecomposable_errors,
     )
 
 

src/py/_tesseract_py_util/decompose_errors_test.py

@@ -185,6 +185,32 @@ def test_undecompose_errors_surface_code():
     assert dem_decomposed_using_coords_func == dem_decomposed_using_coords
 
 
+def test_decompose_errors_strip_undecomposable_errors():
+    dem = stim.DetectorErrorModel("""
+detector(0) D0
+detector(1) D1
+# Error with multiple components (D0 and D1)
+error(0.1) D0 D1
+# D0 exists as a standalone error
+error(0.1) D0
+# D1 DOES NOT exist as a standalone error
+""")
+
+    # Should fail by default
+    with pytest.raises(ValueError, match="needs to be decomposed into components"):
+        decompose_errors_using_last_coordinate_index(dem)
+
+    # Should pass with strip_undecomposable_errors=True, but D0 D1 error is removed
+    decomposed_dem = decompose_errors_using_last_coordinate_index(dem, strip_undecomposable_errors=True)
+    
+    expected_dem = stim.DetectorErrorModel("""
+detector(0) D0
+detector(1) D1
+error(0.1) D0
+""")
+    assert str(decomposed_dem) == str(expected_dem)
+
+
 def test_undecompose_errors_with_repeat_block():
     dem = stim.DetectorErrorModel("""error(0.1) D2 D5 ^ D10 L1
 repeat 10 {

src/py/_tesseract_py_util/demutil.py

@@ -23,13 +23,19 @@
 
 
 def decompose_errors(
-    dem: stim.DetectorErrorModel, method: str = "stim-surfacecode-coords"
+    dem: stim.DetectorErrorModel,
+    method: str = "stim-surfacecode-coords",
+    strip_undecomposable_errors: bool = False,
 ) -> stim.DetectorErrorModel:
     """Dispatch decomposition strategy by method name."""
     if method == "stim-surfacecode-coords":
-        return decompose_errors_for_stim_surface_code_coords(dem)
+        return decompose_errors_for_stim_surface_code_coords(
+            dem, strip_undecomposable_errors=strip_undecomposable_errors
+        )
     if method == "last-coordinate-index":
-        return decompose_errors_using_last_coordinate_index(dem)
+        return decompose_errors_using_last_coordinate_index(
+            dem, strip_undecomposable_errors=strip_undecomposable_errors
+        )
     raise ValueError(
         "Unknown decomposition method "
         f"{method!r}. Expected 'stim-surfacecode-coords' or 'last-coordinate-index'."

src/py/_tesseract_py_util/demutil_test.py

@@ -67,5 +67,29 @@ def test_regeneralize_spatial_dem_averages_template_probabilities():
     assert probs == pytest.approx([0.2, 0.3])
 
 
+def test_decompose_errors_top_level_strip_undecomposable_errors():
+    dem = stim.DetectorErrorModel("""
+detector(0) D0
+detector(1) D1
+# Error with multiple components (D0 and D1)
+error(0.1) D0 D1
+# D0 exists as a standalone error
+error(0.1) D0
+# D1 DOES NOT exist as a standalone error
+""")
+
+    # Should pass with strip_undecomposable_errors=True
+    decomposed_dem = demutil.decompose_errors(
+        dem, method="last-coordinate-index", strip_undecomposable_errors=True
+    )
+    
+    expected_dem = stim.DetectorErrorModel("""
+detector(0) D0
+detector(1) D1
+error(0.1) D0
+""")
+    assert str(decomposed_dem) == str(expected_dem)
+
+
 if __name__ == "__main__":
     raise SystemExit(pytest.main([__file__]))