address pr comments

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

Author: vedika-saravanan

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

@@ -445,37 +445,21 @@ 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);
-
-/// @brief Unregister a previously registered Stim-DEM-string creator. No-op if
-/// \p name has no registered creator.
-/// @see register_stim_dem_decoder_creator
-void unregister_stim_dem_decoder_creator(const std::string &name);
-
 /// @brief Construct a decoder by name from a Stim detector error model text.
 ///
-/// When a Stim-DEM creator is registered for \p name it is used directly.
-/// 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:
+/// Thin wrapper over \c dem_from_stim_text: parses the DEM and forwards to
+/// the existing H-based \c decoder::get after injecting two derived entries
+/// into \p options if they are not already present:
 ///   - `"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
+/// @note Lossy: detector annotations, decomposition separators, and
+/// `error_ids` are dropped. Sufficient for matching-style / H-based
+/// decoders (LUT, NV, sliding_window, TRT, PyMatching). Decoders that
+/// need full DEM metadata (e.g. Chromobius detector color/basis) require
+/// the planned \c detector_coords extension on
+/// \c cudaq::qec::detector_error_model; tracked as a follow-up.
 std::unique_ptr<decoder>
 get_decoder_from_stim_dem(const std::string &name,
                           const std::string &stim_dem_text,

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

@@ -75,8 +75,9 @@ struct detector_error_model {
 /// @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`.
+/// Decoders that need full DEM metadata (e.g. Chromobius detector
+/// color/basis) require the planned \p detector_coords extension on
+/// \p detector_error_model; tracked as a follow-up.
 detector_error_model dem_from_stim_text(const std::string &dem_text);
 
 } // namespace cudaq::qec

libs/qec/lib/decoder_stim_dem.cpp

@@ -1,40 +1,18 @@
 /*******************************************************************************
  * Copyright (c) 2024 - 2026 NVIDIA Corporation & Affiliates.                  *
  * All rights reserved.                                                        *
- *                                                                             *
  * This source code and the accompanying materials are made available under    *
  * the terms of the Apache License 2.0 which accompanies this distribution.    *
  ******************************************************************************/
 
 #include "cudaq/qec/decoder.h"
 #include "cudaq/qec/detector_error_model.h"
 
-#include <mutex>
 #include <stdexcept>
 #include <string>
-#include <unordered_map>
 
 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::mutex &mutex;
-  std::unordered_map<std::string, stim_dem_decoder_creator> &map;
-};
-stim_dem_registry get_stim_dem_registry() {
-  // 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) {
@@ -46,34 +24,10 @@ dem_default_values dem_defaults_for_missing_keys(
   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::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::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) {
-  stim_dem_decoder_creator creator;
-  {
-    auto reg = get_stim_dem_registry();
-    std::lock_guard<std::mutex> lock(reg.mutex);
-    auto iter = reg.map.find(name);
-    if (iter != reg.map.end())
-      creator = iter->second;
-  }
-  if (creator)
-    return creator(stim_dem_text, options);
-
   if (!decoder::is_registered(name))
     throw std::runtime_error(
         "get_decoder_from_stim_dem: decoder \"" + name +

libs/qec/python/bindings/py_decoder.cpp

@@ -747,13 +747,12 @@ void bindDecoder(nb::module_ &mod) {
                                          hetMapFromKwargs(options));
       },
       "Construct a decoder by name from a Stim detector error model string. "
-      "Observables and per-error rates from the DEM are injected into options "
-      "under keys \"O\" and \"error_rate_vec\" when no registered Stim-DEM "
-      "creator is found. User-supplied values for either key win over the "
+      "Thin wrapper over dem_from_stim_text: observables and per-error rates "
+      "from the DEM are injected into options under keys \"O\" and "
+      "\"error_rate_vec\". User-supplied values for either key win over the "
       "DEM-derived ones. Python decoders registered via @qec.decoder receive "
       "the parsed H and O as numpy.ndarray and error_rate_vec as a 1-D "
-      "numpy.ndarray of float64; to register a native DEM consumer, use the "
-      "C++ register_stim_dem_decoder_creator API.");
+      "numpy.ndarray of float64.");
 
   qecmod.def(
       "get_sorted_pcm_column_indices",

libs/qec/unittests/test_decoders.cpp

@@ -764,33 +764,6 @@ error(0.05) D0 D1
   }
 }
 
-TEST(StimDemDecoderFactory, RegisteredCreatorIsUsed) {
-  // static: the registry outlives this test, so the lambda must not
-  // capture a stack reference.
-  static bool registered_creator_was_called = false;
-  registered_creator_was_called = false;
-  // RAII guard: restore the registry slot on any exit path.
-  struct CreatorGuard {
-    const char *name;
-    ~CreatorGuard() { cudaq::qec::unregister_stim_dem_decoder_creator(name); }
-  } guard{"__stim_dem_test_decoder__"};
-  cudaq::qec::register_stim_dem_decoder_creator(
-      "__stim_dem_test_decoder__",
-      [](const std::string &dem_text, const cudaqx::heterogeneous_map &)
-          -> std::unique_ptr<cudaq::qec::decoder> {
-        registered_creator_was_called = true;
-        EXPECT_EQ(dem_text, "passthrough");
-        cudaqx::tensor<uint8_t> H({2u, 2u});
-        cudaqx::heterogeneous_map empty;
-        return cudaq::qec::decoder::get("single_error_lut", H, empty);
-      });
-
-  auto d = cudaq::qec::get_decoder_from_stim_dem("__stim_dem_test_decoder__",
-                                                 "passthrough");
-  EXPECT_TRUE(registered_creator_was_called);
-  ASSERT_NE(d, nullptr);
-}
-
 TEST(StimDemDecoderFactory, RepeatedDetectorOrObservableTargetsXorFold) {
   const std::string dem_text = R"(error(0.1) D0 D0
 error(0.1) L0 L0
@@ -854,34 +827,6 @@ TEST(StimDemDecoderFactory, StimDemTargetCategoriesAreExhaustive) {
   }
 }
 
-TEST(StimDemDecoderFactory, RegisteredCreatorTakesPrecedenceOverFallback) {
-  // Real decoder name on purpose: pins creator-over-fallback for an
-  // existing decoder (a sentinel name would just retest
-  // RegisteredCreatorIsUsed). Mutates the real "single_error_lut" slot;
-  // safe only because gtest runs tests serially in a binary. If this
-  // suite is ever parallelized, register against a sentinel name instead.
-  static bool creator_was_called = false;
-  creator_was_called = false;
-  struct CreatorGuard {
-    const char *name;
-    ~CreatorGuard() { cudaq::qec::unregister_stim_dem_decoder_creator(name); }
-  } guard{"single_error_lut"};
-  cudaq::qec::register_stim_dem_decoder_creator(
-      "single_error_lut",
-      [](const std::string &, const cudaqx::heterogeneous_map &)
-          -> std::unique_ptr<cudaq::qec::decoder> {
-        creator_was_called = true;
-        cudaqx::tensor<uint8_t> H({2u, 2u});
-        cudaqx::heterogeneous_map empty;
-        return cudaq::qec::decoder::get("single_error_lut", H, empty);
-      });
-
-  const std::string dem_text = "error(0.1) D0 L0\n";
-  auto d = cudaq::qec::get_decoder_from_stim_dem("single_error_lut", dem_text);
-  EXPECT_TRUE(creator_was_called);
-  ASSERT_NE(d, nullptr);
-}
-
 TEST(StimDemDecoderFactory, UserOptionsAreNotOverwritten) {
   const std::string dem_text = R"(error(0.1) D0 L0
 error(0.1) D1 L0
@@ -893,64 +838,3 @@ error(0.05) D0 D1
       cudaq::qec::get_decoder_from_stim_dem("single_error_lut", dem_text, opts),
       std::runtime_error);
 }
-
-TEST(StimDemDecoderFactory, UserSuppliedObservablesAreNotOverwritten) {
-  // Symmetric with UserOptionsAreNotOverwritten but for "O", via an
-  // echo creator (decoder-validation-independent).
-  static std::vector<std::size_t> observed_O_shape;
-  observed_O_shape.clear();
-  struct CreatorGuard {
-    const char *name;
-    ~CreatorGuard() { cudaq::qec::unregister_stim_dem_decoder_creator(name); }
-  } guard{"__stim_dem_echo_O__"};
-  cudaq::qec::register_stim_dem_decoder_creator(
-      "__stim_dem_echo_O__",
-      [](const std::string &, const cudaqx::heterogeneous_map &opts)
-          -> std::unique_ptr<cudaq::qec::decoder> {
-        if (opts.contains("O")) {
-          auto O = opts.get<cudaqx::tensor<uint8_t>>("O");
-          observed_O_shape = O.shape();
-        }
-        cudaqx::tensor<uint8_t> H({2u, 2u});
-        cudaqx::heterogeneous_map empty;
-        return cudaq::qec::decoder::get("single_error_lut", H, empty);
-      });
-
-  // Distinctive shape; a match proves the user's O reached the creator.
-  cudaqx::tensor<uint8_t> user_O({7u, 11u});
-  cudaqx::heterogeneous_map opts;
-  opts.insert("O", user_O);
-  auto d = cudaq::qec::get_decoder_from_stim_dem("__stim_dem_echo_O__",
-                                                 "error(0.1) D0 L0\n", opts);
-  ASSERT_NE(d, nullptr);
-  ASSERT_EQ(observed_O_shape.size(), 2u);
-  EXPECT_EQ(observed_O_shape[0], 7u);
-  EXPECT_EQ(observed_O_shape[1], 11u);
-}
-
-TEST(StimDemDecoderFactory, RegisteredCreatorReceivesUserOptionsVerbatim) {
-  static std::vector<double> observed_rates;
-  observed_rates.clear();
-  struct CreatorGuard {
-    const char *name;
-    ~CreatorGuard() { cudaq::qec::unregister_stim_dem_decoder_creator(name); }
-  } guard{"__stim_dem_echo__"};
-  cudaq::qec::register_stim_dem_decoder_creator(
-      "__stim_dem_echo__",
-      [](const std::string &, const cudaqx::heterogeneous_map &opts)
-          -> std::unique_ptr<cudaq::qec::decoder> {
-        if (opts.contains("error_rate_vec"))
-          observed_rates = opts.get<std::vector<double>>("error_rate_vec");
-        cudaqx::tensor<uint8_t> H({2u, 2u});
-        cudaqx::heterogeneous_map empty;
-        return cudaq::qec::decoder::get("single_error_lut", H, empty);
-      });
-
-  const std::vector<double> user_rates = {0.42, 0.13, 0.07};
-  cudaqx::heterogeneous_map opts;
-  opts.insert("error_rate_vec", user_rates);
-  auto d = cudaq::qec::get_decoder_from_stim_dem("__stim_dem_echo__",
-                                                 "error(0.5) D0\n", opts);
-  ASSERT_NE(d, nullptr);
-  EXPECT_EQ(observed_rates, user_rates);
-}