code examples fixed and integrated

Signed-off-by: Kevin Mato <[email protected]>

Author: kvmto

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

@@ -19,6 +19,7 @@
 #include <common/NoiseModel.h>
 #include <fstream>
 
+// [Begin Save DEM]
 // Save decoder configuration to YAML file
 void save_dem(const cudaq::qec::detector_error_model &dem,
               const std::string &filename) {
@@ -30,35 +31,39 @@ void save_dem(const cudaq::qec::detector_error_model &dem,
   config.syndrome_size = dem.num_detectors();
   config.H_sparse = cudaq::qec::pcm_to_sparse_vec(dem.detector_error_matrix);
   config.O_sparse = cudaq::qec::pcm_to_sparse_vec(dem.observables_flips_matrix);
-  
+
   // Calculate numRounds from DEM (we send 1 additional round, so add 1)
-  uint64_t numSyndromesPerRound = 2;  // Z0Z1 and Z1Z2
+  uint64_t numSyndromesPerRound = 2; // Z0Z1 and Z1Z2
   auto numRounds = dem.num_detectors() / numSyndromesPerRound + 1;
   config.D_sparse = cudaq::qec::generate_timelike_sparse_detector_matrix(
       numSyndromesPerRound, numRounds, false);
-  
+
   cudaq::qec::decoding::config::multi_error_lut_config lut_config;
   lut_config.lut_error_depth = 2;
   config.decoder_custom_args = lut_config;
-  
+
   cudaq::qec::decoding::config::multi_decoder_config multi_config;
   multi_config.decoders.push_back(config);
-  
+
   std::ofstream file(filename);
   file << multi_config.to_yaml_str(200);
   file.close();
   printf("Saved config to %s\n", filename.c_str());
 }
+// [End Save DEM]
 
+// [Begin Load DEM]
 // Load decoder configuration from YAML file
 void load_dem(const std::string &filename) {
   std::ifstream file(filename);
   std::string yaml((std::istreambuf_iterator<char>(file)),
                    std::istreambuf_iterator<char>());
-  auto config = cudaq::qec::decoding::config::multi_decoder_config::from_yaml_str(yaml);
+  auto config =
+      cudaq::qec::decoding::config::multi_decoder_config::from_yaml_str(yaml);
   cudaq::qec::decoding::config::configure_decoders(config);
   printf("Loaded config from %s\n", filename.c_str());
 }
+// [End Load DEM]
 
 // Prepare logical |0⟩
 __qpu__ void prep0(cudaq::qec::patch logical) {
@@ -68,72 +73,86 @@ __qpu__ void prep0(cudaq::qec::patch logical) {
 }
 
 // Measure ZZ stabilizers for 3-qubit repetition code
-__qpu__ std::vector<cudaq::measure_result> measure_stabilizers(
-    cudaq::qec::patch logical) {
+__qpu__ std::vector<cudaq::measure_result>
+measure_stabilizers(cudaq::qec::patch logical) {
   for (std::size_t i = 0; i < logical.ancz.size(); ++i) {
     cudaq::reset(logical.ancz[i]);
   }
-  
+
   // Z0Z1 stabilizer
   cudaq::x<cudaq::ctrl>(logical.data[0], logical.ancz[0]);
   cudaq::x<cudaq::ctrl>(logical.data[1], logical.ancz[0]);
-  
+
   // Z1Z2 stabilizer
   cudaq::x<cudaq::ctrl>(logical.data[1], logical.ancz[1]);
   cudaq::x<cudaq::ctrl>(logical.data[2], logical.ancz[1]);
-  
+
   return {mz(logical.ancz[0]), mz(logical.ancz[1])};
 }
 
+// [Begin QEC Circuit]
 // QEC circuit with real-time decoding
 __qpu__ int64_t qec_circuit() {
   cudaq::qec::decoding::reset_decoder(0);
-  
+
   cudaq::qvector data(3);
   cudaq::qvector ancz(2);
-  cudaq::qvector ancx;  // Empty for repetition code
+  cudaq::qvector ancx; // Empty for repetition code
   cudaq::qec::patch logical(data, ancx, ancz);
-  
+
   prep0(logical);
-  
+
   // 3 rounds of syndrome measurement
   for (int round = 0; round < 3; ++round) {
     auto syndromes = measure_stabilizers(logical);
     cudaq::qec::decoding::enqueue_syndromes(0, syndromes);
   }
-  
+
   // Get corrections and apply them
   auto corrections = cudaq::qec::decoding::get_corrections(0, 3);
   for (std::size_t i = 0; i < 3; ++i) {
     if (corrections[i])
       cudaq::x(data[i]);
   }
-  
+
   return cudaq::to_integer(mz(data));
 }
+// [End QEC Circuit]
 
+// [Begin Main]
 int main() {
-  auto code = cudaq::qec::get_code("repetition", 
+  // [Begin Get Code]
+  auto code = cudaq::qec::get_code("repetition",
                                    cudaqx::heterogeneous_map{{"distance", 3}});
-  
+  // [End Get Code]
+
+  // [Begin DEM Generation]
   // Step 1: Generate detector error model
   printf("Step 1: Generating DEM...\n");
   cudaq::noise_model noise;
   noise.add_all_qubit_channel("x", cudaq::depolarization2(0.01), 1);
-  
+
   auto dem = cudaq::qec::z_dem_from_memory_circuit(
       *code, cudaq::qec::operation::prep0, 3, noise);
-  
+  // [End DEM Generation]
+
+  // [Begin Save DEM]
   save_dem(dem, "config.yaml");
-  
+  // [End Save DEM]
+
+  // [Begin Load and Run]
   // Step 2: Load config and run circuit
   printf("\nStep 2: Running circuit with decoding...\n");
   load_dem("config.yaml");
-  
+
   cudaq::run(10, qec_circuit);
   printf("Ran 10 shots\n");
-  
+
   cudaq::qec::decoding::config::finalize_decoders();
+  // [End Load and Run]
+
   printf("\nDone!\n");
   return 0;
 }
+// [End Main]
+// [End Documentation]

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

@@ -15,72 +15,86 @@
 """
 
 import os
+
 os.environ["CUDAQ_DEFAULT_SIMULATOR"] = "stim"
 
 import cudaq
 import cudaq_qec as qec
 
+
 # Prepare logical |0⟩
 @cudaq.kernel
 def prep0(logical: qec.patch):
     for i in range(logical.data.size()):
         cudaq.reset(logical.data[i])
 
+
 # Measure ZZ stabilizers for 3-qubit repetition code
 @cudaq.kernel
 def measure_stabilizers(logical: qec.patch):
     for i in range(logical.ancz.size()):
         cudaq.reset(logical.ancz[i])
-    
+
     # Z0Z1 stabilizer
     cudaq.cx(logical.data[0], logical.ancz[0])
     cudaq.cx(logical.data[1], logical.ancz[0])
-    
+
     # Z1Z2 stabilizer
     cudaq.cx(logical.data[1], logical.ancz[1])
     cudaq.cx(logical.data[2], logical.ancz[1])
-    
+
     return [cudaq.mz(logical.ancz[0]), cudaq.mz(logical.ancz[1])]
 
+
+# [Begin QEC Circuit]
 # QEC circuit with real-time decoding
 @cudaq.kernel
 def qec_circuit():
     qec.reset_decoder(0)
-    
+
     data = cudaq.qvector(3)
     ancz = cudaq.qvector(2)
     ancx = cudaq.qvector(0)
     logical = qec.patch(data, ancx, ancz)
-    
+
     prep0(logical)
-    
+
     # 3 rounds of syndrome measurement
     for _ in range(3):
         syndromes = measure_stabilizers(logical)
         qec.enqueue_syndromes(0, syndromes)
-    
+
     # Get corrections and apply them
     corrections = qec.get_corrections(0, 3, False)
     for i in range(3):
         if corrections[i]:
             cudaq.x(data[i])
-    
+
     cudaq.mz(data)
 
+
+# [End QEC Circuit]
+
+
+# [Begin Main]
 def main():
+    # [Begin Get Code]
     # Get 3-qubit repetition code
     code = qec.get_code("repetition", distance=3)
-    
+    # [End Get Code]
+
+    # [Begin DEM Generation]
     # Step 1: Generate detector error model
     print("Step 1: Generating DEM...")
     cudaq.set_target("stim")
-    
+
     noise = cudaq.NoiseModel()
     noise.add_all_qubit_channel("x", cudaq.Depolarization2(0.01), 1)
-    
-    dem = qec.z_dem_from_memory_circuit(
-        code, qec.operation.prep0, 3, noise)
-    
+
+    dem = qec.z_dem_from_memory_circuit(code, qec.operation.prep0, 3, noise)
+    # [End DEM Generation]
+
+    # [Begin Save DEM]
     # Save decoder config
     config = qec.DecoderConfig()
     config.id = 0
@@ -89,30 +103,41 @@ def main():
     config.syndrome_size = dem.detector_error_matrix.shape[0]
     config.H_sparse = qec.pcm_to_sparse_vec(dem.detector_error_matrix)
     config.O_sparse = qec.pcm_to_sparse_vec(dem.observables_flips_matrix)
-    
+
     # Calculate numRounds from DEM (we send 1 additional round, so add 1)
     num_syndromes_per_round = 2  # Z0Z1 and Z1Z2
-    num_rounds = dem.detector_error_matrix.shape[0] // num_syndromes_per_round + 1
+    num_rounds = dem.detector_error_matrix.shape[
+        0] // num_syndromes_per_round + 1
     config.D_sparse = qec.generate_timelike_sparse_detector_matrix(
         num_syndromes_per_round, num_rounds, False)
     config.decoder_custom_args = {"lut_error_depth": 2}
-    
+
     multi_config = qec.MultiDecoderConfig()
     multi_config.decoders = [config]
-    
+
     with open("config.yaml", 'w') as f:
         f.write(multi_config.to_yaml_str(200))
     print("Saved config to config.yaml")
-    
+    # [End Save DEM]
+
+    # [Begin Load and Run]
     # Step 2: Load config and run circuit
     print("\nStep 2: Running circuit with decoding...")
+    # [Begin Load DEM]
     qec.configure_decoders_from_file("config.yaml")
-    
+    # [End Load DEM]
+
     cudaq.sample(qec_circuit, shots_count=10)
     print("Ran 10 shots")
-    
+
     qec.finalize_decoders()
+    # [End Load and Run]
+
     print("\nDone!")
 
+
+# [End Main]
+
 if __name__ == "__main__":
     main()
+# [End Documentation]