Follow-up to #333 - fix tests for public repo (#335)

This PR will restore the per-PR CI back to a state where all the tests
should pass.

(The cause for the failures is that the public repo doesn't have all the
same test resources available as the private repo.)

Author: bmhowe23

libs/qec/python/tests/test_decoders_yaml.py

@@ -11,6 +11,21 @@
 import cudaq_qec as qec
 
 
+def is_nv_qldpc_decoder_available():
+    """
+    Helper function to check if the NV-QLDPC decoder is available.
+    """
+    try:
+        H_list = [[1, 0, 0, 1, 0, 1, 1], [0, 1, 0, 1, 1, 0, 1],
+                  [0, 0, 1, 0, 1, 1, 1]]
+
+        H_np = np.array(H_list, dtype=np.uint8)
+        nv_dec_gpu_and_cpu = qec.get_decoder("nv-qldpc-decoder", H_np)
+        return True
+    except Exception as e:
+        return False
+
+
 def check_decoder_yaml_roundtrip(multi_config):
     """
     Helper function to test that a decoder configuration can be serialized to
@@ -119,6 +134,8 @@ def test_single_decoder():
     """
     Test YAML serialization/deserialization and creation of a single NV-QLDPC decoder.
     """
+    if not is_nv_qldpc_decoder_available():
+        pytest.skip("NV-QLDPC decoder is not available, skipping test")
     multi_config = qec.multi_decoder_config()
     config = create_test_decoder_config_nv_qldpc(0)
     multi_config.decoders = [config]
@@ -131,6 +148,8 @@ def test_multi_decoder():
     """
     Test YAML serialization/deserialization and creation of multiple NV-QLDPC decoders.
     """
+    if not is_nv_qldpc_decoder_available():
+        pytest.skip("NV-QLDPC decoder is not available, skipping test")
     multi_config = qec.multi_decoder_config()
     config1 = create_test_decoder_config_nv_qldpc(0)
     config2 = create_test_decoder_config_nv_qldpc(1)

libs/qec/python/tests/test_decoding_config.py

@@ -307,12 +307,14 @@ def test_configure_valid_decoders():
 
     dc = qec.decoder_config()
     dc.id = 0
-    dc.type = "nv-qldpc-decoder"
+    dc.type = "multi_error_lut"
     dc.block_size = 10
     dc.syndrome_size = 3
     dc.num_syndromes_per_round = 3
     dc.H_sparse = [1, 2, 3, -1, 6, 7, 8, -1, -1]
-    dc.set_decoder_custom_args(nv)
+    lut_config = qec.multi_error_lut_config()
+    lut_config.lut_error_depth = 2
+    dc.set_decoder_custom_args(lut_config)
 
     mdc = qec.multi_decoder_config()
     mdc.decoders = [dc]

libs/qec/python/tests/test_sliding_window.py

@@ -10,8 +10,6 @@
 import cudaq
 import cudaq_qec as qec
 import pytest
-import os
-import tempfile
 
 
 @pytest.fixture(scope="function", autouse=True)
@@ -22,16 +20,6 @@ def setTarget():
     cudaq.set_target(old_target)
 
 
-@pytest.mark.parametrize("decoder_name",
-                         ["multi_error_lut", "nv-qldpc-decoder"])
-@pytest.mark.parametrize("batched", [True, False])
-@pytest.mark.parametrize("num_rounds", [5, 10])
-@pytest.mark.parametrize("num_windows", [1, 2, 3])
-def test_sliding_window_multi_error_lut_and_nv_qldpc_decoder(
-        decoder_name, batched, num_rounds, num_windows):
-    test_sliding_window_1(decoder_name, batched, num_rounds, num_windows)
-
-
 @pytest.mark.parametrize("decoder_name", ["single_error_lut"])
 @pytest.mark.parametrize("batched", [True, False])
 @pytest.mark.parametrize("num_rounds", [5, 10])
@@ -61,27 +49,9 @@ def test_sliding_window_1(decoder_name, batched, num_rounds, num_windows):
     # First compare the results of the full decoder to the sliding window
     # decoder using an inner decoder of the full window size. The results should
     # be the same.
-    if decoder_name == "nv-qldpc-decoder":
-        # nv-qldpc-decoder requires use_sparsity=True for batched decoding
-        full_decoder = qec.get_decoder(decoder_name,
-                                       dem.detector_error_matrix,
-                                       use_sparsity=True,
-                                       error_rate_vec=np.array(dem.error_rates))
-    else:
-        full_decoder = qec.get_decoder(decoder_name, dem.detector_error_matrix)
+    full_decoder = qec.get_decoder(decoder_name, dem.detector_error_matrix)
     num_syndromes_per_round = dem.detector_error_matrix.shape[0] // num_rounds
 
-    # Set up inner decoder parameters based on decoder type
-    if decoder_name == "nv-qldpc-decoder":
-        inner_decoder_params = {
-            "use_sparsity": True,
-            "error_rate_vec": np.array(dem.error_rates)
-        }
-    elif decoder_name == "multi_error_lut":
-        inner_decoder_params = {"lut_error_depth": 2}
-    else:
-        inner_decoder_params = {}
-
     sw_as_full_decoder = qec.get_decoder(
         "sliding_window",
         dem.detector_error_matrix,
@@ -92,28 +62,7 @@ def test_sliding_window_1(decoder_name, batched, num_rounds, num_windows):
         straddle_end_round=True,
         error_rate_vec=np.array(dem.error_rates),
         inner_decoder_name=decoder_name,
-        inner_decoder_params=inner_decoder_params)
-
-    # Save sliding window configuration to YAML file for verification
-    config_filename = save_sliding_window_config_to_yaml(
-        n_rounds=num_rounds,
-        n_errs_per_round=dem.detector_error_matrix.shape[1] // num_rounds,
-        n_syndromes_per_round=num_syndromes_per_round,
-        window_size=num_rounds - num_windows + 1,
-        step_size=1,
-        simplified_pcm=np.array(dem.detector_error_matrix),
-        simplified_weights=np.array(dem.error_rates),
-        inner_decoder_name=decoder_name)
-
-    # ============================================================================
-    # PROVE END-TO-END SERIALIZATION: Load and configure decoders from the saved YAML
-    # ============================================================================
-    config_result = qec.configure_decoders_from_file(config_filename)
-    assert config_result == 0, f"Failed to configure decoders from saved YAML file: {config_filename}"
-    print(
-        f"✅ Successfully configured decoders from saved YAML file: {config_filename}"
-    )
-    print("End-to-end YAML serialization and decoder configuration verified!")
+        inner_decoder_params={'dummy_param': 1})
 
     if batched:
         full_results = full_decoder.decode_batch(syndromes)
@@ -134,127 +83,3 @@ def test_sliding_window_1(decoder_name, batched, num_rounds, num_windows):
             if r1.result != r2.result:
                 num_mismatches += 1
         assert num_mismatches == 0
-
-    # Cleanup: Finalize decoders after testing configuration
-    qec.qecrt.config.finalize_decoders()
-
-    # Clean up the generated YAML file
-    #if os.path.exists(config_filename):
-    #    os.unlink(config_filename)
-
-
-def save_sliding_window_config_to_yaml(n_rounds, n_errs_per_round,
-                                       n_syndromes_per_round, window_size,
-                                       step_size, simplified_pcm,
-                                       simplified_weights, inner_decoder_name):
-    """
-    Save sliding window decoder configuration to YAML (Python version of C++ function)
-    """
-    # Create a sliding_window_config struct with concrete inner decoder configs
-    sw_config = qec.qecrt.config.sliding_window_config()
-    sw_config.window_size = window_size
-    sw_config.step_size = step_size
-    sw_config.num_syndromes_per_round = n_syndromes_per_round
-    sw_config.straddle_start_round = False  # Default value from sliding_window.cpp
-    sw_config.straddle_end_round = True  # Default value from sliding_window.cpp
-    sw_config.error_rate_vec = simplified_weights.tolist()
-    sw_config.inner_decoder_name = inner_decoder_name
-
-    # Set the appropriate concrete inner decoder config based on decoder name
-    if inner_decoder_name == "single_error_lut":
-        single_config = qec.qecrt.config.single_error_lut_config()
-        # single_error_lut_config is intentionally empty (no configuration parameters)
-        sw_config.single_error_lut_params = single_config
-    elif inner_decoder_name == "multi_error_lut":
-        multi_config = qec.qecrt.config.multi_error_lut_config()
-        multi_config.lut_error_depth = 2
-        # Note: error_rate_vec not supported in multi_error_lut_config for real-time decoding
-        sw_config.multi_error_lut_params = multi_config
-    elif inner_decoder_name == "nv-qldpc-decoder":
-        nv_config = qec.qecrt.config.nv_qldpc_decoder_config()
-        nv_config.use_sparsity = True
-        nv_config.error_rate_vec = simplified_weights.tolist()
-        nv_config.use_osd = True
-        nv_config.max_iterations = 50
-        nv_config.osd_order = 60
-        nv_config.osd_method = 3
-        sw_config.nv_qldpc_decoder_params = nv_config
-
-    # Create a decoder_config for the sliding window decoder
-    config = qec.qecrt.config.decoder_config()
-    config.id = 0
-    config.type = "sliding_window"
-    config.block_size = simplified_pcm.shape[1]  # Number of columns
-    config.syndrome_size = simplified_pcm.shape[0]  # Number of rows
-    config.num_syndromes_per_round = n_syndromes_per_round
-
-    # Convert PCM to sparse format for H_sparse and create empty O_sparse
-    H_sparse = []
-    for row in range(simplified_pcm.shape[0]):
-        for col in range(simplified_pcm.shape[1]):
-            if simplified_pcm[row, col] == 1:
-                H_sparse.append(int(col))
-        H_sparse.append(-1)  # End of row marker
-
-    config.H_sparse = H_sparse
-    config.O_sparse = []  # Empty for this test
-    # D_sparse is optional, leave unset
-
-    # Set the sliding_window_config directly
-    config.decoder_custom_args = sw_config
-
-    # Create multi_decoder_config and add our sliding window decoder
-    multi_config = qec.qecrt.config.multi_decoder_config()
-    multi_config.decoders = [config]
-
-    # Generate YAML string using native serialization (no concatenation needed!)
-    config_str = multi_config.to_yaml_str(200)  # 200 char line wrap
-
-    # Create a unique filename based on test parameters
-    filename = f"sliding_window_config_r{n_rounds}_e{n_errs_per_round}_s{n_syndromes_per_round}_w{window_size}_st{step_size}_{inner_decoder_name}.yml"
-
-    with open(filename, 'w') as config_file:
-        config_file.write(config_str)
-
-    print(
-        f"Saved sliding window config (with native YAML inner decoder params) to file: {filename}"
-    )
-
-    # Verify the config can be loaded back (inner decoder params should be natively serialized)
-    loaded_multi_config = qec.qecrt.config.multi_decoder_config.from_yaml_str(
-        config_str)
-    assert len(loaded_multi_config.decoders) == 1
-    assert loaded_multi_config.decoders[0].type == "sliding_window"
-    assert loaded_multi_config.decoders[0].id == 0
-
-    # Verify the YAML contains the expected structure and parameters
-    assert "decoder_custom_args:" in config_str
-    assert f"window_size:     {window_size}" in config_str
-    assert f"step_size:       {step_size}" in config_str
-    assert f"num_syndromes_per_round: {n_syndromes_per_round}" in config_str
-    assert f"inner_decoder_name: {inner_decoder_name}" in config_str
-
-    # Verify that inner decoder parameters are preserved in the loaded config
-    print("Successfully verified sliding window YAML config round-trip!")
-    print(
-        "Sliding window parameters and inner decoder configs natively serialized!"
-    )
-
-    if inner_decoder_name == "single_error_lut":
-        # single_error_lut_config is intentionally empty (no configuration parameters)
-        print("Single error LUT config parameters successfully verified!")
-    elif inner_decoder_name == "multi_error_lut":
-        assert "inner_decoder_params:" in config_str
-        assert "lut_error_depth: 2" in config_str
-        print("Multi error LUT config parameters successfully verified!")
-    elif inner_decoder_name == "nv-qldpc-decoder":
-        assert "inner_decoder_params:" in config_str
-        assert "use_sparsity:    true" in config_str
-        assert "use_osd:         true" in config_str
-        assert "max_iterations:  50" in config_str
-        assert "osd_order:       60" in config_str
-        assert "osd_method:      3" in config_str
-        print("NV QLDPC decoder config parameters successfully verified!")
-
-    # Return the filename for end-to-end verification
-    return filename

libs/qec/unittests/realtime/app_examples/CMakeLists.txt

@@ -38,16 +38,19 @@ add_test(
       ${CMAKE_BINARY_DIR}/lib
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
 )
-add_test(
-  NAME app_examples.surface_code-1-local-test-distance-5
-  COMMAND
-    bash "${CMAKE_CURRENT_SOURCE_DIR}/surface_code-1-test.sh"
-      ${CMAKE_CURRENT_BINARY_DIR}/surface_code-1-local
-      ${CMAKE_CURRENT_BINARY_DIR}/surface_code-1-local
-      5 40 40 NULL 20 10
-      ${CMAKE_BINARY_DIR}/lib
-  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-)
+# This must be disabled for now because the multi_error_lut decoder is not
+# powerful enough to pass this test. The nv-qldpc-decoder can pass this test,
+# but that is not available on the GitHub repo.
+# add_test(
+#   NAME app_examples.surface_code-1-local-test-distance-5
+#   COMMAND
+#     bash "${CMAKE_CURRENT_SOURCE_DIR}/surface_code-1-test.sh"
+#       ${CMAKE_CURRENT_BINARY_DIR}/surface_code-1-local
+#       ${CMAKE_CURRENT_BINARY_DIR}/surface_code-1-local
+#       5 40 40 NULL 20 10
+#       ${CMAKE_BINARY_DIR}/lib
+#   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+# )
 
 # Surface code 1 Python test
 add_test(
@@ -151,16 +154,19 @@ add_test(
       ${CMAKE_BINARY_DIR}/lib
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
 )
-add_test(
-  NAME app_examples.surface_code-2-local-test-distance-5
-  COMMAND
-    bash "${CMAKE_CURRENT_SOURCE_DIR}/surface_code-2-test.sh"
-      ${CMAKE_CURRENT_BINARY_DIR}/surface_code-2-local
-      ${CMAKE_CURRENT_BINARY_DIR}/surface_code-2-local
-      5 10 10 NULL
-      ${CMAKE_BINARY_DIR}/lib
-  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-)
+# This must be disabled for now because the multi_error_lut decoder is not
+# powerful enough to pass this test. The nv-qldpc-decoder can pass this test,
+# but that is not available on the GitHub repo.
+# add_test(
+#   NAME app_examples.surface_code-2-local-test-distance-5
+#   COMMAND
+#     bash "${CMAKE_CURRENT_SOURCE_DIR}/surface_code-2-test.sh"
+#       ${CMAKE_CURRENT_BINARY_DIR}/surface_code-2-local
+#       ${CMAKE_CURRENT_BINARY_DIR}/surface_code-2-local
+#       5 10 10 NULL
+#       ${CMAKE_BINARY_DIR}/lib
+#   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+# )
 
 # End of surface code 2, fully local, regular Stim simulator
 #------------------------------------------------------------------------------#
@@ -226,7 +232,10 @@ add_test(
 
 
 macro(add_surface_code_test base_name exe_local exe_remote dist server)
-  foreach(err_rate IN ITEMS 0.010 0.015)
+  # For now, disable 0.015 error rate because the multi_error_lut decoder is not
+  # powerful enough to pass this test. The nv-qldpc-decoder can pass this test,
+  # but that is not available on the GitHub repo.
+  foreach(err_rate IN ITEMS 0.010)
     foreach(prep IN ITEMS prep0 prepp)
       add_test(
         NAME ${base_name}-dist-${dist}-${prep}-err-${err_rate}

libs/qec/unittests/realtime/app_examples/surface_code-1-test.py

@@ -33,19 +33,22 @@
             "number_of_corrections_decoder_threshold": 40
         },
         id="d3-local"),
-    pytest.param(
-        {
-            "distance": 5,
-            "p_spam": 0.01,
-            "num_rounds": 20,
-            "decoder_window": 10,
-            "num_shots": 1000,
-            "target": "stim",
-            "number_of_non_zero_values_threshold": 40,
-            "number_of_corrections_decoder_threshold": 40
-        },
-        id="d5-local",
-    ),
+    # This must be disabled for now because the multi_error_lut decoder is not
+    # powerful enough to pass this test. The nv-qldpc-decoder can pass this test,
+    # but that is not available on the GitHub repo.
+    # pytest.param(
+    #     {
+    #         "distance": 5,
+    #         "p_spam": 0.01,
+    #         "num_rounds": 20,
+    #         "decoder_window": 10,
+    #         "num_shots": 1000,
+    #         "target": "stim",
+    #         "number_of_non_zero_values_threshold": 40,
+    #         "number_of_corrections_decoder_threshold": 40
+    #     },
+    #     id="d5-local",
+    # ),
     pytest.param(
         {
             "distance": 3,