Update cudaq and nanobind versions (#545)

- Updates pinned version of cudaq.
- Updates nanobind by reverting previous commits
(62936b1
7488c8c
a0724f6),
except for 7488c8c change to `cmake/Modules/CUDA-QX.cmake`.

Wheel build to confirm issue is fixed:
https://github.com/NVIDIA/cudaqx/actions/runs/25936612350

---------

Signed-off-by: Pradnya Khalate <pkhalate@nvidia.com>
Signed-off-by: Angela Burton <angelab@nvidia.com>
Co-authored-by: Pradnya Khalate <pkhalate@nvidia.com>
Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: Pradnya Khalate <148914294+khalatepradnya@users.noreply.github.com>

Author: 3 people

.cudaq_realtime_version

@@ -1,6 +1,6 @@
 {
   "cudaq_realtime": {
     "repository": "NVIDIA/cuda-quantum",
-    "ref": "cd88025b3d1beb02ca2703de70a583e647af10fb"
+    "ref": "053480dda0413c219c224d42313aa14d7a17a7fe"
   }
 }

.cudaq_version

@@ -1,6 +1,6 @@
 {
   "cudaq": {
     "repository": "NVIDIA/cuda-quantum",
-    "ref": "cd88025b3d1beb02ca2703de70a583e647af10fb"
+    "ref": "053480dda0413c219c224d42313aa14d7a17a7fe"
   }
 }

docs/sphinx/examples/qec/cpp/real_time_complete.cpp

@@ -122,7 +122,7 @@ __qpu__ int64_t qec_circuit() {
       cudaq::x(data[i]);
   }
 
-  return cudaq::to_integer(mz(data));
+  return cudaq::to_integer(cudaq::to_bools(mz(data)));
 }
 // [End QEC Circuit]
 

docs/sphinx/examples/qec/python/real_time_complete.py

@@ -31,7 +31,7 @@ def prep0(logical: qec.patch):
 
 # Measure ZZ stabilizers for 3-qubit repetition code
 @cudaq.kernel
-def measure_stabilizers(logical: qec.patch) -> list[bool]:
+def measure_stabilizers(logical: qec.patch) -> list[cudaq.measure_handle]:
     for i in range(logical.ancz.size()):
         reset(logical.ancz[i])
 
@@ -70,7 +70,7 @@ def qec_circuit() -> int:
         for i in range(3):
             x(data[i])
 
-    return cudaq.to_integer(mz(data))
+    return cudaq.to_integer(cudaq.to_bools(mz(data)))
 
 
 # [End QEC Circuit]

libs/qec/include/cudaq/qec/realtime/decoding.h

@@ -34,6 +34,19 @@ enqueue_syndromes(std::uint64_t decoder_id,
                   const std::vector<cudaq::measure_result> &syndromes,
                   std::uint64_t tag = 0);
 
+/// @brief Test-only entry point for enqueueing pre-discriminated syndrome
+/// bits (e.g., raw syndromes replayed from a saved file). Production code
+/// must use `enqueue_syndromes`. This entry point exists because raw bits
+/// read from disk have no measurement-event identity to preserve, so the
+/// `vector<measure_result>` API is the wrong shape for them.
+/// @param decoder_id The ID of the decoder to use.
+/// @param syndromes Pre-discriminated syndrome bits.
+/// @param tag The tag to use for the syndrome (currently useful for logging
+/// only)
+__qpu__ void enqueue_syndromes_test(std::uint64_t decoder_id,
+                                    const std::vector<bool> &syndromes,
+                                    std::uint64_t tag = 0);
+
 /// @brief Get the corrections for a given decoder.
 /// @param decoder_id The ID of the decoder to use.
 /// @param return_size The number of bits to return (in bits). This is expected

libs/qec/lib/realtime/quantinuum/quantinuum_device.cpp

@@ -21,6 +21,16 @@ enqueue_syndromes(std::uint64_t decoder_id,
                   const std::vector<cudaq::measure_result> &syndromes,
                   std::uint64_t tag) {
   uint64_t syndrome_size = syndromes.size();
+  // Discriminate first, then bit-pack into the `uint64` wire format.
+  uint64_t syndrome = cudaq::to_integer(cudaq::to_bools(syndromes));
+  cudaq::device_call(enqueue_syndromes_ui64, decoder_id, syndrome_size,
+                     syndrome, tag);
+}
+
+__qpu__ void enqueue_syndromes_test(std::uint64_t decoder_id,
+                                    const std::vector<bool> &syndromes,
+                                    std::uint64_t tag) {
+  uint64_t syndrome_size = syndromes.size();
   uint64_t syndrome = cudaq::to_integer(syndromes);
   cudaq::device_call(enqueue_syndromes_ui64, decoder_id, syndrome_size,
                      syndrome, tag);

libs/qec/lib/realtime/simulation/simulation_device.cpp

@@ -19,9 +19,9 @@
 // exact signature (other than converting vectors to spans), there will be no
 // errors or warnings, other than bad crashes.
 extern "C" __attribute__((visibility("default"))) void
-simulation_enqueue_syndromes(
-    std::uint64_t decoder_id,
-    const std::vector<cudaq::measure_result> &syndromes, std::uint64_t tag);
+simulation_enqueue_syndromes(std::uint64_t decoder_id,
+                             const std::vector<bool> &syndromes,
+                             std::uint64_t tag);
 
 extern "C" __attribute__((visibility("default"))) void
 simulation_get_corrections(std::uint64_t decoder_id,
@@ -33,6 +33,15 @@ __qpu__ void
 enqueue_syndromes(std::uint64_t decoder_id,
                   const std::vector<cudaq::measure_result> &syndromes,
                   std::uint64_t tag) {
+  // The host trampoline takes a bit-typed span (see WARNING above), so
+  // discriminate the handles before crossing the boundary.
+  cudaq::device_call(simulation_enqueue_syndromes, decoder_id,
+                     cudaq::to_bools(syndromes), tag);
+}
+
+__qpu__ void enqueue_syndromes_test(std::uint64_t decoder_id,
+                                    const std::vector<bool> &syndromes,
+                                    std::uint64_t tag) {
   cudaq::device_call(simulation_enqueue_syndromes, decoder_id, syndromes, tag);
 }
 

libs/qec/python/CMakeLists.txt

@@ -17,7 +17,7 @@ if(NOT COMMAND nanobind_add_module)
   FetchContent_Declare(
     nanobind
     GIT_REPOSITORY https://github.com/wjakob/nanobind
-    GIT_TAG v2.9.2
+    GIT_TAG v2.12.0
     EXCLUDE_FROM_ALL
   )
   FetchContent_MakeAvailable(nanobind)

libs/qec/python/bindings/py_decoder.cpp

@@ -105,13 +105,6 @@ void bindDecoder(nb::module_ &mod) {
                     ? nb::cast<nb::module_>(mod.attr("qecrt"))
                     : mod.def_submodule("qecrt");
 
-  // Workaround for nanobind v2.9.2: `def_rw` on a `std::optional<T>` field
-  // does not implicitly allow Python `None` for the setter (that behavior was
-  // added in v2.12.0 via PR #1262). Passing this annotation makes the setter
-  // accept None and store `std::nullopt`. Remove once nanobind is bumped to
-  // >=2.12.0.
-  const auto setter_accepts_none = nb::for_setter(nb::arg("value").none());
-
   nb::class_<decoder_result>(qecmod, "DecoderResult", R"pbdoc(
     A class representing the results of a quantum error correction decoding operation.
 
@@ -135,8 +128,7 @@ void bindDecoder(nb::module_ &mod) {
         the original quantum state. The format depends on the specific decoder
         implementation.
     )pbdoc")
-      .def_rw("opt_results", &decoder_result::opt_results, setter_accepts_none,
-              R"pbdoc(
+      .def_rw("opt_results", &decoder_result::opt_results, R"pbdoc(
         Optional additional results from the decoder stored in a heterogeneous map.
 
         This field may be empty if no additional results are available.
@@ -741,10 +733,23 @@ void bindDecoder(nb::module_ &mod) {
                       (error_msg ? std::string(error_msg) : "unknown error.")));
     }
 
-    // List of `init_func` names to call for decoder registration
+    // List of `init_func` names to call for decoder registration.
+    //
+    // The `enqueue_syndromes` mangled string encodes the public API's
+    // parameter type. Under CUDA-Q alias `using measure_result =
+    // measure_handle;`, C++ mangling resolves the typedef to its underlying
+    // type, so `INS_14measure_handleESaIS3_EE` is the inner-vector mangling for
+    // `std::vector<cudaq::measure_handle>`. If CUDA-Q ever renames the
+    // underlying handle type or changes the alias direction, this string must
+    // be re-derived from `nm` on the per-target device .o.
+    //
+    // `enqueue_syndromes_test` is the bool-typed counterpart and stays bound
+    // to `INS_t6vectorIbSaIbEE`; the Python frontend hands it pre-discriminated
+    // bits via `cudaq.to_bools(...)`.
     // clang-format off
     static const std::vector<std::string> initFuncNames = {
-        "function_enqueue_syndromes._ZN5cudaq3qec8decoding17enqueue_syndromesEmRKSt6vectorIbSaIbEEm.init_func",
+        "function_enqueue_syndromes._ZN5cudaq3qec8decoding17enqueue_syndromesEmRKSt6vectorINS_14measure_handleESaIS3_EEm.init_func",
+        "function_enqueue_syndromes_test._ZN5cudaq3qec8decoding22enqueue_syndromes_testEmRKSt6vectorIbSaIbEEm.init_func",
         "function_get_corrections._ZN5cudaq3qec8decoding15get_correctionsEmmb.init_func",
         "function_reset_decoder._ZN5cudaq3qec8decoding13reset_decoderEm.init_func"};
     // clang-format on

libs/qec/python/bindings/py_decoding.cpp

@@ -55,6 +55,22 @@ void bindDecoding(nb::module_ &mod) {
                 - syndromes: A vector of syndrome bits (0 or 1).
                 - tag: An optional tag for the enqueue operation.
                         )pbdoc");
+  // Mirrors the C++ `enqueue_syndromes_test(uint64_t, vector<bool>, uint64_t)`
+  // entry point. The Python device kernel must pre-discriminate any
+  // `list[measure_handle]` via `cudaq.to_bools(...)` before the call. Used by
+  // app examples that already own bool-typed syndrome bits (file replay or
+  // explicit kernel-side discrimination) where the production
+  // `enqueue_syndromes(vector<measure_result>)` shape is the wrong fit.
+  qecSubMod.def(
+      "enqueue_syndromes_test",
+      [](std::uint64_t, std::vector<bool>, std::uint64_t) {},
+      R"pbdoc(Test-only entry point for enqueueing pre-discriminated syndrome
+              bits. Production code should use `enqueue_syndromes` instead.
+                Parameters
+                - decoder_id: The ID of the decoder.
+                - syndromes: A vector of syndrome bits (0 or 1).
+                - tag: An optional tag for the enqueue operation.
+                        )pbdoc");
   qecSubMod.def(
       "get_corrections", [](std::uint64_t, std::uint64_t, bool) {},
       R"pbdoc(Get the corrections from the decoder.
@@ -72,6 +88,10 @@ void bindDecoding(nb::module_ &mod) {
         qecModName, "enqueue_syndromes",
         cudaq::python::getMangledArgsString<std::uint64_t, std::vector<bool>,
                                             std::uint64_t>());
+    cudaq::python::registerDeviceKernel(
+        qecModName, "enqueue_syndromes_test",
+        cudaq::python::getMangledArgsString<std::uint64_t, std::vector<bool>,
+                                            std::uint64_t>());
     cudaq::python::registerDeviceKernel(
         qecModName, "get_corrections",
         cudaq::python::getMangledArgsString<std::uint64_t, std::uint64_t,