fix formatting

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

Author: vedika-saravanan

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

@@ -31,17 +31,17 @@ using float_t = double;
 #endif
 
 /// @brief Construction input for a decoder: either an explicit parity-check
-/// matrix (\c cudaq::qec::sparse_binary_matrix) or a Stim detector error model string
-/// (\c std::string_view).
+/// matrix (`cudaq::qec::sparse_binary_matrix`) or a Stim detector error model
+/// string (`std::string_view`).
 ///
 /// Parity-check-matrix-based decoders (LUT, sliding_window, TRT, PyMatching,
 /// nv-qldpc, ...) accept either alternative: a DEM string is parsed into a
-/// parity-check matrix via \c dem_from_stim_text. Decoders that require the raw
+/// parity-check matrix via `dem_from_stim_text`. Decoders that require the raw
 /// DEM (e.g. Chromobius, which needs detector color/basis annotations) require
 /// the string alternative and reject a bare matrix.
 ///
 /// @note The string alternative is non-owning. The referenced buffer must stay
-/// alive for the duration of the \c get_decoder / \c decoder::get call;
+/// alive for the duration of the `get_decoder` / `decoder::get` call;
 /// decoders parse it during construction and do not retain the view.
 using decoder_init =
     std::variant<cudaq::qec::sparse_binary_matrix, std::string_view>;
@@ -164,16 +164,16 @@ class decoder
   /// @brief Decode a single syndrome
   /// @param syndrome A vector of syndrome measurements where the floating point
   /// value is the probability that the syndrome measurement is a |1>. The
-  /// length of the syndrome vector should be equal to \p syndrome_size.
-  /// @returns Vector of length \p block_size with soft probabilities of errors
+  /// length of the syndrome vector should be equal to `syndrome_size`.
+  /// @returns Vector of length `block_size` with soft probabilities of errors
   /// in each index.
   virtual decoder_result decode(const std::vector<float_t> &syndrome) = 0;
 
   /// @brief Decode a single syndrome
   /// @param syndrome An order-1 tensor of syndrome measurements where a 1 bit
   /// represents that the syndrome measurement is a |1>. The
-  /// length of the syndrome vector should be equal to \p syndrome_size.
-  /// @returns Vector of length \p block_size of errors in each index.
+  /// length of the syndrome vector should be equal to `syndrome_size`.
+  /// @returns Vector of length `block_size` of errors in each index.
   virtual decoder_result decode(const cudaqx::tensor<uint8_t> &syndrome);
 
   /// @brief Decode a single syndrome
@@ -196,7 +196,7 @@ class decoder
   /// @brief Construct a registered decoder by name.
   /// @param name The registered decoder name.
   /// @param init Either a parity-check matrix or a Stim DEM string (see
-  /// \c decoder_init). The variant is forwarded to the decoder's creator, so
+  /// `decoder_init`). The variant is forwarded to the decoder's creator, so
   /// parity-check-matrix-based decoders and DEM-native decoders (Chromobius)
   /// share a single entry point.
   /// @param param_map Optional decoder-specific parameters.
@@ -206,19 +206,22 @@ class decoder
 
   static std::unique_ptr<decoder>
   get(const std::string &name, const cudaq::qec::sparse_binary_matrix &H,
-      const cudaqx::heterogeneous_map &param_map = cudaqx::heterogeneous_map()) {
+      const cudaqx::heterogeneous_map &param_map =
+          cudaqx::heterogeneous_map()) {
     return get(name, decoder_init{H}, param_map);
   }
 
   static std::unique_ptr<decoder>
   get(const std::string &name, const cudaqx::tensor<uint8_t> &H,
-      const cudaqx::heterogeneous_map &param_map = cudaqx::heterogeneous_map()) {
+      const cudaqx::heterogeneous_map &param_map =
+          cudaqx::heterogeneous_map()) {
     return get(name, cudaq::qec::sparse_binary_matrix(H), param_map);
   }
 
   static std::unique_ptr<decoder>
   get(const std::string &name, std::string_view stim_dem_text,
-      const cudaqx::heterogeneous_map &param_map = cudaqx::heterogeneous_map()) {
+      const cudaqx::heterogeneous_map &param_map =
+          cudaqx::heterogeneous_map()) {
     return get(name, decoder_init{stim_dem_text}, param_map);
   }
 
@@ -503,26 +506,27 @@ dem_default_values dem_defaults_for_missing_keys(
     const std::function<bool(const std::string &)> &contains_user_key,
     const detector_error_model &dem);
 
-/// @brief Extract the Stim DEM text from a \c decoder_init, throwing if it holds
-/// a parity-check matrix instead. Use this in the create() function of decoders
-/// that require a raw DEM (e.g. Chromobius), which cannot be reconstructed from
-/// a bare parity-check matrix.
+/// @brief Extract the Stim DEM text from a `decoder_init`, throwing if it
+/// holds a parity-check matrix instead. Use this in the create() function of
+/// decoders that require a raw DEM (e.g. Chromobius), which cannot be
+/// reconstructed from a bare parity-check matrix.
 std::string_view require_dem_text(const decoder_init &init);
 
-/// @brief Build a parity-check-matrix-based decoder from a \c decoder_init.
+/// @brief Build a parity-check-matrix-based decoder from a `decoder_init`.
 ///
-/// If \p init holds a sparse matrix, it is used directly as the parity-check matrix.
-/// If it holds a Stim DEM string, it is parsed via \c dem_from_stim_text and the
-/// derived observables (`"O"`) and per-error rates (`"error_rate_vec"`) are
-/// injected into \p params unless the user already supplied them (user values
-/// win). This is the shared implementation behind the create() function of every
-/// parity-check-matrix-based decoder, giving them DEM-string support for free.
+/// If `init` holds a sparse matrix, it is used directly as the parity-check
+/// matrix. If it holds a Stim DEM string, it is parsed via
+/// `dem_from_stim_text` and the derived observables (`"O"`) and per-error
+/// rates (`"error_rate_vec"`) are injected into `params` unless the user
+/// already supplied them (user values win). This is the shared implementation
+/// behind the create() function of every parity-check-matrix-based decoder,
+/// giving them DEM-string support for free.
 ///
 /// @note The DEM parse is lossy: detector annotations, decomposition
 /// separators, and `error_ids` are dropped. Sufficient for matching-style /
 /// parity-check-matrix decoders (LUT, NV, sliding_window, TRT, PyMatching).
 /// Decoders that need full DEM metadata (e.g. Chromobius detector color/basis)
-/// must consume the string directly via \c require_dem_text.
+/// must consume the string directly via `require_dem_text`.
 template <typename DecoderT>
 std::unique_ptr<decoder>
 make_pcm_decoder(const decoder_init &init,
@@ -545,8 +549,8 @@ make_pcm_decoder(const decoder_init &init,
 
 /// @brief Construct a decoder by name from a Stim detector error model string.
 ///
-/// @deprecated Prefer \c get_decoder, which now accepts a Stim DEM string
-/// directly via \c decoder_init. Retained as a thin convenience alias.
+/// @deprecated Prefer `get_decoder`, which now accepts a Stim DEM string
+/// directly via `decoder_init`. Retained as a thin convenience alias.
 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

@@ -19,9 +19,9 @@ namespace cudaq::qec {
 /// decoder to help make predictions about observables flips.
 ///
 /// Shared size parameters among the matrix types.
-/// - \p detector_error_matrix: num_detectors x num_error_mechanisms [d, e]
-/// - \p error_rates: num_error_mechanisms
-/// - \p observables_flips_matrix: num_observables x num_error_mechanisms [k, e]
+/// - `detector_error_matrix`: num_detectors x num_error_mechanisms [d, e]
+/// - `error_rates`: num_error_mechanisms
+/// - `observables_flips_matrix`: num_observables x num_error_mechanisms [k, e]
 ///
 /// @note The C++ API for this class may change in the future. The Python API is
 /// more likely to be backwards compatible.
@@ -33,7 +33,7 @@ struct detector_error_model {
   cudaqx::tensor<uint8_t> detector_error_matrix;
 
   /// The list of weights has length equal to the number of columns of
-  /// \p detector_error_matrix, which assigns a likelihood to each error
+  /// `detector_error_matrix`, which assigns a likelihood to each error
   /// mechanism.
   std::vector<double> error_rates;
 
@@ -67,17 +67,17 @@ struct detector_error_model {
 };
 
 /// @brief Parse a Stim detector error model text into a
-/// \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
+/// `cudaq::qec::detector_error_model`. Each `error` instruction in the DEM
+/// becomes a single column in `detector_error_matrix` and
+/// `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.
+/// suggested-decomposition separators, and `error_ids` are dropped.
 /// 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.
+/// color/basis) require the planned `detector_coords` extension on
+/// `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.cpp

@@ -19,8 +19,7 @@
 
 INSTANTIATE_REGISTRY(cudaq::qec::decoder,
                      const cudaq::qec::sparse_binary_matrix &)
-INSTANTIATE_REGISTRY(cudaq::qec::decoder,
-                     const cudaq::qec::decoder_init &,
+INSTANTIATE_REGISTRY(cudaq::qec::decoder, const cudaq::qec::decoder_init &,
                      const cudaqx::heterogeneous_map &)
 
 // Include decoder implementations AFTER registry instantiation

libs/qec/python/bindings/py_decoder.cpp

@@ -790,9 +790,9 @@ void bindDecoder(nb::module_ &mod) {
   // Shared implementation for constructing a decoder from a Stim DEM string,
   // used by both the get_decoder(str) overload and the (deprecated)
   // get_decoder_from_stim_dem entry point.
-  auto get_decoder_from_dem_text =
-      [](const std::string &name, const std::string &dem_text,
-         nb::kwargs options)
+  auto get_decoder_from_dem_text = [](const std::string &name,
+                                      const std::string &dem_text,
+                                      nb::kwargs options)
       -> std::variant<nb::object, std::unique_ptr<decoder>> {
     if (PyDecoderRegistry::contains(name)) {
       auto dem = dem_from_stim_text(dem_text);