fix ci failure

Signed-off-by: vedika-saravanan <vsaravanan@nvidia.com>

Author: vedika-saravanan

libs/qec/include/cudaq/qec/decoder.h

@@ -431,11 +431,29 @@ std::unique_ptr<decoder>
 get_decoder(const std::string &name, const cudaqx::tensor<uint8_t> &H,
             const cudaqx::heterogeneous_map options = {});
 
+struct detector_error_model;
+
+/// @brief DEM-derived defaults; pointers alias into the source `dem`.
+struct dem_default_values {
+  const cudaqx::tensor<uint8_t> *O = nullptr;
+  const std::vector<double> *error_rate_vec = nullptr;
+};
+
+/// @brief Return DEM defaults for any key not already supplied by the user.
+/// Shared by `get_decoder_from_stim_dem` and its Python binding.
+dem_default_values dem_defaults_for_missing_keys(
+    const std::function<bool(const std::string &)> &contains_user_key,
+    const detector_error_model &dem);
+
 /// @brief Creator function for a decoder constructed from a Stim DEM string.
 using stim_dem_decoder_creator = std::function<std::unique_ptr<decoder>(
     const std::string &, const cudaqx::heterogeneous_map &)>;
 
 /// @brief Register a Stim-DEM-string creator for the named decoder.
+/// @param name Decoder name; same name used by `get_decoder_from_stim_dem`.
+/// @param creator Builds a decoder from the raw DEM string + options. Takes
+///   precedence over the H/O fallback; must not re-enter the registry (the
+///   factory copies it out before invoking).
 /// @see get_decoder_from_stim_dem
 void register_stim_dem_decoder_creator(const std::string &name,
                                        stim_dem_decoder_creator creator);
@@ -451,12 +469,15 @@ void unregister_stim_dem_decoder_creator(const std::string &name);
 /// Otherwise the DEM is parsed and forwarded to the existing H-based path
 /// after injecting two derived entries into \p options if they are not
 /// already present:
-///   - \c "O" : \c cudaqx::tensor<uint8_t> observables_flips_matrix
-///   - \c "error_rate_vec" : \c std::vector<double> per-error probabilities
+///   - `"O"` : `cudaqx::tensor<uint8_t>` observables_flips_matrix
+///   - `"error_rate_vec"` : `std::vector<double>` per-error probabilities
 /// User-supplied values for either key win over the DEM-derived ones.
+///
+/// @note Decoders that need full DEM metadata (e.g. Chromobius) must
+/// register a Stim-DEM creator; the fallback only extracts H/O/rates.
 /// @see register_stim_dem_decoder_creator
 std::unique_ptr<decoder>
 get_decoder_from_stim_dem(const std::string &name,
                           const std::string &stim_dem_text,
-                          const cudaqx::heterogeneous_map options = {});
+                          const cudaqx::heterogeneous_map &options = {});
 } // namespace cudaq::qec

libs/qec/include/cudaq/qec/detector_error_model.h

@@ -67,10 +67,16 @@ struct detector_error_model {
 };
 
 /// @brief Parse a Stim detector error model text into a
-/// \p cudaq::qec::detector_error_model. Each \c error instruction in the DEM
+/// \p cudaq::qec::detector_error_model. Each `error` instruction in the DEM
 /// becomes a single column in \p detector_error_matrix and
 /// \p observables_flips_matrix; suggested decomposition separators are
 /// folded into the same column.
+///
+/// @note Lossy: only detector/observable flips and error probabilities
+/// are extracted. Annotations (`detector`, `logical_observable`),
+/// suggested-decomposition separators, and \p error_ids are dropped.
+/// Decoders that need the full DEM (e.g. Chromobius) must consume the
+/// raw string via `register_stim_dem_decoder_creator`.
 detector_error_model dem_from_stim_text(const std::string &dem_text);
 
 } // namespace cudaq::qec

libs/qec/lib/CMakeLists.txt

@@ -61,6 +61,7 @@ add_library(${LIBRARY_NAME} SHARED ${QEC_SOURCES})
 add_subdirectory(decoders/plugins/example)
 add_subdirectory(decoders/plugins/pymatching)
 
+# libstim comes from the parent build (CUDA-Q).
 if(NOT TARGET libstim)
   message(FATAL_ERROR
     "libstim target not available; required by cudaq-qec for Stim DEM parsing.")

libs/qec/lib/decoder_stim_dem.cpp

@@ -18,40 +18,55 @@ namespace cudaq::qec {
 
 namespace {
 
+// std::mutex is enough: the factory copies the creator out before
+// invoking, so creators cannot re-enter the registry.
 struct stim_dem_registry {
-  std::recursive_mutex &mutex;
+  std::mutex &mutex;
   std::unordered_map<std::string, stim_dem_decoder_creator> &map;
 };
 stim_dem_registry get_stim_dem_registry() {
-  static std::recursive_mutex *mutex = new std::recursive_mutex();
+  // Heap-allocated to outlive static destructors (plugin dlclose unregister
+  // path); matches the cudaqx extension_point pattern. See extension_point.h.
+  static std::mutex *mutex = new std::mutex();
   static auto *map =
       new std::unordered_map<std::string, stim_dem_decoder_creator>();
   return {*mutex, *map};
 }
 
 } // namespace
 
+dem_default_values dem_defaults_for_missing_keys(
+    const std::function<bool(const std::string &)> &contains_user_key,
+    const detector_error_model &dem) {
+  dem_default_values out;
+  if (!contains_user_key("O"))
+    out.O = &dem.observables_flips_matrix;
+  if (!contains_user_key("error_rate_vec"))
+    out.error_rate_vec = &dem.error_rates;
+  return out;
+}
+
 void register_stim_dem_decoder_creator(const std::string &name,
                                        stim_dem_decoder_creator creator) {
   auto reg = get_stim_dem_registry();
-  std::lock_guard<std::recursive_mutex> lock(reg.mutex);
+  std::lock_guard<std::mutex> lock(reg.mutex);
   reg.map[name] = std::move(creator);
 }
 
 void unregister_stim_dem_decoder_creator(const std::string &name) {
   auto reg = get_stim_dem_registry();
-  std::lock_guard<std::recursive_mutex> lock(reg.mutex);
+  std::lock_guard<std::mutex> lock(reg.mutex);
   reg.map.erase(name);
 }
 
 std::unique_ptr<decoder>
 get_decoder_from_stim_dem(const std::string &name,
                           const std::string &stim_dem_text,
-                          const cudaqx::heterogeneous_map options) {
+                          const cudaqx::heterogeneous_map &options) {
   stim_dem_decoder_creator creator;
   {
     auto reg = get_stim_dem_registry();
-    std::lock_guard<std::recursive_mutex> lock(reg.mutex);
+    std::lock_guard<std::mutex> lock(reg.mutex);
     auto iter = reg.map.find(name);
     if (iter != reg.map.end())
       creator = iter->second;
@@ -68,10 +83,13 @@ get_decoder_from_stim_dem(const std::string &name,
   auto dem = dem_from_stim_text(stim_dem_text);
 
   cudaqx::heterogeneous_map merged = options;
-  if (!merged.contains("O"))
-    merged.insert("O", dem.observables_flips_matrix);
-  if (!merged.contains("error_rate_vec"))
-    merged.insert("error_rate_vec", dem.error_rates);
+  // Keep in sync with the Python binding in py_decoder.cpp.
+  auto defaults = dem_defaults_for_missing_keys(
+      [&](const std::string &key) { return merged.contains(key); }, dem);
+  if (defaults.O)
+    merged.insert("O", *defaults.O);
+  if (defaults.error_rate_vec)
+    merged.insert("error_rate_vec", *defaults.error_rate_vec);
 
   return decoder::get(name, dem.detector_error_matrix, merged);
 }

libs/qec/lib/detector_error_model.cpp

@@ -15,7 +15,14 @@
 namespace cudaq::qec {
 
 detector_error_model dem_from_stim_text(const std::string &dem_text) {
-  stim::DetectorErrorModel dem(dem_text);
+  auto dem = [&dem_text]() {
+    try {
+      return stim::DetectorErrorModel(dem_text);
+    } catch (const std::exception &e) {
+      throw std::runtime_error(std::string("Stim DEM parse failed: ") +
+                               e.what());
+    }
+  }();
   const std::size_t num_detectors =
       static_cast<std::size_t>(dem.count_detectors());
   const std::size_t num_observables =
@@ -46,6 +53,15 @@ detector_error_model dem_from_stim_text(const std::string &dem_text) {
         dets.push_back(static_cast<std::size_t>(target.val()));
       } else if (target.is_observable_id()) {
         obs.push_back(static_cast<std::size_t>(target.val()));
+      } else {
+        // Forward-compat tripwire; unreachable today (stim's three
+        // DemTarget categories are exhaustive -- pinned by
+        // StimDemTargetCategoriesAreExhaustive).
+        throw std::runtime_error(
+            "Stim DEM error instruction (index " +
+            std::to_string(instruction_index) +
+            ") contains an unsupported target kind; only D* (detector) and "
+            "L* (observable) targets are supported by the fallback parser");
       }
     }
     detector_hits.push_back(std::move(dets));
@@ -55,6 +71,11 @@ detector_error_model dem_from_stim_text(const std::string &dem_text) {
   });
 
   const std::size_t num_errors = rates.size();
+  // Reject zero-column H at the boundary instead of letting decoders
+  // crash with block_size == 0.
+  if (num_errors == 0)
+    throw std::runtime_error(
+        "Stim DEM contains no error mechanisms after flattening");
   detector_error_model result;
   result.detector_error_matrix =
       cudaqx::tensor<uint8_t>({num_detectors, num_errors});

libs/qec/python/bindings/py_decoder.cpp

@@ -288,6 +288,22 @@ makeBatchDecoderResult(const std::vector<decoder_result> &results) {
   };
 }
 
+// Wrap a borrowed cudaqx buffer in a NumPy array and force a Python-side copy,
+// so the returned object owns its data.
+nb::object toPyArray(const cudaqx::tensor<uint8_t> &t) {
+  size_t shape[2] = {t.shape()[0], t.shape()[1]};
+  auto arr = nb::ndarray<nb::numpy, uint8_t>(const_cast<uint8_t *>(t.data()), 2,
+                                             shape, nb::none());
+  return nb::cast(arr).attr("copy")();
+}
+
+nb::object toPyArray(const std::vector<double> &v) {
+  size_t shape[1] = {v.size()};
+  auto arr = nb::ndarray<nb::numpy, double>(const_cast<double *>(v.data()), 1,
+                                            shape, nb::none());
+  return nb::cast(arr).attr("copy")();
+}
+
 } // namespace
 
 void bindDecoder(nb::module_ &mod) {
@@ -713,26 +729,16 @@ void bindDecoder(nb::module_ &mod) {
         if (PyDecoderRegistry::contains(name)) {
           auto dem = dem_from_stim_text(dem_text);
 
-          if (!options.contains("O")) {
-            const auto &O = dem.observables_flips_matrix;
-            size_t shape[2] = {O.shape()[0], O.shape()[1]};
-            auto O_arr = nb::ndarray<nb::numpy, uint8_t>(
-                const_cast<uint8_t *>(O.data()), 2, shape, nb::none());
-            options["O"] = nb::cast(O_arr).attr("copy")();
-          }
-          if (!options.contains("error_rate_vec")) {
-            const auto &rates = dem.error_rates;
-            size_t rates_shape[1] = {rates.size()};
-            auto rates_arr = nb::ndarray<nb::numpy, double>(
-                const_cast<double *>(rates.data()), 1, rates_shape, nb::none());
-            options["error_rate_vec"] = nb::cast(rates_arr).attr("copy")();
-          }
+          // Keep in sync with the C++ fallback in decoder_stim_dem.cpp.
+          auto defaults = dem_defaults_for_missing_keys(
+              [&](const std::string &key) { return options.contains(key); },
+              dem);
+          if (defaults.O)
+            options["O"] = toPyArray(*defaults.O);
+          if (defaults.error_rate_vec)
+            options["error_rate_vec"] = toPyArray(*defaults.error_rate_vec);
 
-          const auto &H = dem.detector_error_matrix;
-          size_t H_shape[2] = {H.shape()[0], H.shape()[1]};
-          auto H_arr = nb::ndarray<nb::numpy, uint8_t>(
-              const_cast<uint8_t *>(H.data()), 2, H_shape, nb::none());
-          nb::object H_obj = nb::cast(H_arr).attr("copy")();
+          nb::object H_obj = toPyArray(dem.detector_error_matrix);
           return PyDecoderRegistry::get_decoder(
               name, nb::cast<nb::ndarray<nb::numpy, uint8_t>>(H_obj), options);
         }

libs/qec/python/cudaq_qec/__init__.py

@@ -84,6 +84,7 @@ def checked_decode_batch(self, *args, **kwargs):
 get_code = qecrt.get_code
 get_available_codes = qecrt.get_available_codes
 get_decoder = qecrt.get_decoder
+get_decoder_from_stim_dem = qecrt.get_decoder_from_stim_dem
 DecoderResult = qecrt.DecoderResult
 BatchDecoderResult = qecrt.BatchDecoderResult
 DetectorErrorModel = qecrt.DetectorErrorModel

libs/qec/python/tests/test_decoder.py

@@ -528,13 +528,25 @@ def test_get_decoder_from_stim_dem():
 
 
 def test_get_decoder_from_stim_dem_rejects_malformed_text():
-    with pytest.raises(Exception):
+    with pytest.raises(RuntimeError):
         qec.get_decoder_from_stim_dem("single_error_lut", "not a valid DEM")
 
 
 def test_get_decoder_from_stim_dem_rejects_unknown_decoder():
+    with pytest.raises(RuntimeError, match="__no_such_decoder__"):
+        qec.get_decoder_from_stim_dem("__no_such_decoder__",
+                                      "error(0.1) D0 L0\n")
+
+
+def test_get_decoder_from_stim_dem_user_O_wins_over_dem_derived():
+    # Wrong-shape user O trips PyMatching's validation; silent overwrite
+    # by the DEM-derived O would suppress the throw.
+    dem_text = ("error(0.1) D0 L0\n"
+                "error(0.1) D1 L0\n"
+                "error(0.05) D0 D1\n")
+    bad_O = np.zeros((1, 4), dtype=np.uint8)
     with pytest.raises(RuntimeError):
-        qec.get_decoder_from_stim_dem("__no_such_decoder__", "error(0.1) D0\n")
+        qec.get_decoder_from_stim_dem("pymatching", dem_text, O=bad_O)
 
 
 if __name__ == "__main__":

libs/qec/unittests/CMakeLists.txt

@@ -35,7 +35,9 @@ find_package(CUDAToolkit REQUIRED)
 add_compile_options(-Wno-attributes) 
 
 add_executable(test_decoders test_decoders.cpp decoders/sample_decoder.cpp)
-target_link_libraries(test_decoders PRIVATE GTest::gtest_main cudaq-qec cudaq-qec-realtime-decoding cudaq::cudaq)
+# Direct libstim link for StimDemTargetCategoriesAreExhaustive;
+# cudaq-qec hides stim symbols via --exclude-libs.
+target_link_libraries(test_decoders PRIVATE GTest::gtest_main cudaq-qec cudaq-qec-realtime-decoding cudaq::cudaq libstim)
 add_dependencies(CUDAQXQECUnitTests test_decoders)
 gtest_discover_tests(test_decoders)