Squashed 'vendor/ruvector/' content from commit b64c2172

git-subtree-dir: vendor/ruvector
git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900

crates/ruQu/examples/coherence_gate_breakthrough.rs

@@ -0,0 +1,670 @@
+//! Coherence Gate Breakthrough: Dynamic Min-Cut for QEC
+//!
+//! This example demonstrates a novel application of the El-Hayek/Henzinger/Li
+//! subpolynomial dynamic min-cut algorithm (SODA 2025) to quantum error correction.
+//!
+//! # Novel Contribution
+//!
+//! Traditional QEC decoders (MWPM, neural networks) focus on DECODING - finding
+//! the most likely error chain. This approach instead uses dynamic min-cut for
+//! COHERENCE ASSESSMENT - determining whether the quantum state is still usable.
+//!
+//! ## Key Insight
+//!
+//! The min-cut of the syndrome graph represents the "bottleneck" in error
+//! propagation paths. When errors accumulate, they weaken graph connectivity.
+//! A low min-cut indicates a potential logical failure pathway has formed.
+//!
+//! ## Theoretical Advantages
+//!
+//! 1. **O(n^{o(1)}) updates**: Subpolynomial time per syndrome round
+//! 2. **Persistent structure**: No need to rebuild from scratch each round
+//! 3. **Early warning**: Detect coherence loss before logical errors manifest
+//! 4. **Complementary to MWPM**: Use as pre-filter to expensive decoding
+//!
+//! # References
+//!
+//! - El-Hayek, Henzinger, Li. "Fully Dynamic Approximate Minimum Cut in
+//!   Subpolynomial Time per Operation." SODA 2025.
+//! - Google Quantum AI. "Quantum error correction below the surface code
+//!   threshold." Nature 2024.
+//!
+//! Run with: cargo run --example coherence_gate_breakthrough --features "structural" --release
+
+use std::time::{Duration, Instant};
+
+/// Use the proper MinCutBuilder API from ruvector-mincut
+#[cfg(feature = "structural")]
+use ruvector_mincut::MinCutBuilder;
+
+/// Fallback for when structural feature is not enabled
+#[cfg(not(feature = "structural"))]
+use ruqu::DynamicMinCutEngine;
+
+use ruqu::{
+    stim::{StimSyndromeSource, SurfaceCodeConfig},
+    syndrome::DetectorBitmap,
+};
+
+/// Configuration for the coherence gate experiment
+#[derive(Clone)]
+struct CoherenceGateConfig {
+    /// Code distance (d=3,5,7,9,11)
+    code_distance: usize,
+    /// Physical error rate
+    error_rate: f64,
+    /// Number of syndrome rounds
+    num_rounds: usize,
+    /// Random seed for reproducibility
+    seed: u64,
+    /// Coherence threshold (min-cut below this triggers concern)
+    coherence_threshold: f64,
+}
+
+impl Default for CoherenceGateConfig {
+    fn default() -> Self {
+        Self {
+            code_distance: 5,
+            error_rate: 0.001,
+            num_rounds: 5000,
+            seed: 42,
+            coherence_threshold: 2.0,
+        }
+    }
+}
+
+/// Statistics from the coherence gate experiment
+#[derive(Clone, Default)]
+struct CoherenceStats {
+    total_rounds: u64,
+    coherent_rounds: u64,
+    warning_rounds: u64,
+    critical_rounds: u64,
+    total_update_ns: u64,
+    min_cut_sum: f64,
+    min_cut_sq_sum: f64,
+    min_min_cut: f64,
+    max_min_cut: f64,
+}
+
+impl CoherenceStats {
+    fn new() -> Self {
+        Self {
+            min_min_cut: f64::INFINITY,
+            max_min_cut: f64::NEG_INFINITY,
+            ..Default::default()
+        }
+    }
+
+    fn record(&mut self, min_cut: f64, update_ns: u64, threshold: f64) {
+        self.total_rounds += 1;
+        self.total_update_ns += update_ns;
+        self.min_cut_sum += min_cut;
+        self.min_cut_sq_sum += min_cut * min_cut;
+
+        if min_cut < self.min_min_cut {
+            self.min_min_cut = min_cut;
+        }
+        if min_cut > self.max_min_cut {
+            self.max_min_cut = min_cut;
+        }
+
+        // Classify coherence state
+        if min_cut >= threshold * 2.0 {
+            self.coherent_rounds += 1;
+        } else if min_cut >= threshold {
+            self.warning_rounds += 1;
+        } else {
+            self.critical_rounds += 1;
+        }
+    }
+
+    fn mean_min_cut(&self) -> f64 {
+        if self.total_rounds == 0 {
+            0.0
+        } else {
+            self.min_cut_sum / self.total_rounds as f64
+        }
+    }
+
+    fn std_min_cut(&self) -> f64 {
+        if self.total_rounds < 2 {
+            return 0.0;
+        }
+        let n = self.total_rounds as f64;
+        let mean = self.mean_min_cut();
+        let variance = (self.min_cut_sq_sum / n) - (mean * mean);
+        variance.max(0.0).sqrt()
+    }
+
+    fn avg_update_ns(&self) -> f64 {
+        if self.total_rounds == 0 {
+            0.0
+        } else {
+            self.total_update_ns as f64 / self.total_rounds as f64
+        }
+    }
+
+    fn coherence_rate(&self) -> f64 {
+        if self.total_rounds == 0 {
+            0.0
+        } else {
+            self.coherent_rounds as f64 / self.total_rounds as f64
+        }
+    }
+}
+
+/// Build the syndrome graph for a surface code
+///
+/// The graph represents detector connectivity:
+/// - Nodes: Detectors (stabilizer measurement outcomes)
+/// - Edges: Potential error correlations between detectors
+///
+/// For a distance-d surface code, we have approximately:
+/// - (d-1)² X-type stabilizers
+/// - (d-1)² Z-type stabilizers
+/// - Each connected to neighbors in a 2D grid pattern
+fn build_syndrome_graph(code_distance: usize) -> Vec<(u64, u64, f64)> {
+    let mut edges = Vec::new();
+    let d = code_distance;
+    let grid_size = d - 1;
+    let num_x_stabs = grid_size * grid_size;
+
+    // X-stabilizer connectivity (2D grid)
+    for row in 0..grid_size {
+        for col in 0..grid_size {
+            let node = (row * grid_size + col) as u64;
+
+            // Connect to right neighbor
+            if col + 1 < grid_size {
+                let right = (row * grid_size + col + 1) as u64;
+                edges.push((node, right, 1.0));
+            }
+
+            // Connect to bottom neighbor
+            if row + 1 < grid_size {
+                let bottom = ((row + 1) * grid_size + col) as u64;
+                edges.push((node, bottom, 1.0));
+            }
+        }
+    }
+
+    // Z-stabilizer connectivity (offset by num_x_stabs)
+    let z_offset = num_x_stabs as u64;
+    for row in 0..grid_size {
+        for col in 0..grid_size {
+            let node = z_offset + (row * grid_size + col) as u64;
+
+            if col + 1 < grid_size {
+                let right = z_offset + (row * grid_size + col + 1) as u64;
+                edges.push((node, right, 1.0));
+            }
+
+            if row + 1 < grid_size {
+                let bottom = z_offset + ((row + 1) * grid_size + col) as u64;
+                edges.push((node, bottom, 1.0));
+            }
+        }
+    }
+
+    // X-Z coupling (data qubit errors affect both types)
+    for row in 0..grid_size {
+        for col in 0..grid_size {
+            let x_node = (row * grid_size + col) as u64;
+            let z_node = z_offset + (row * grid_size + col) as u64;
+            edges.push((x_node, z_node, 0.5));
+        }
+    }
+
+    // Add boundary edges (critical for min-cut to be meaningful)
+    // These represent logical error paths
+    let boundary_weight = (d as f64) / 2.0;
+
+    // Left boundary (X logical error path)
+    for row in 0..grid_size {
+        let left_x = (row * grid_size) as u64;
+        let boundary_l = (2 * num_x_stabs) as u64; // Virtual boundary node
+        edges.push((left_x, boundary_l, boundary_weight));
+    }
+
+    // Right boundary
+    for row in 0..grid_size {
+        let right_x = (row * grid_size + grid_size - 1) as u64;
+        let boundary_r = (2 * num_x_stabs + 1) as u64;
+        edges.push((right_x, boundary_r, boundary_weight));
+    }
+
+    // Top boundary (Z logical error path)
+    for col in 0..grid_size {
+        let top_z = z_offset + col as u64;
+        let boundary_t = (2 * num_x_stabs + 2) as u64;
+        edges.push((top_z, boundary_t, boundary_weight));
+    }
+
+    // Bottom boundary
+    for col in 0..grid_size {
+        let bottom_z = z_offset + ((grid_size - 1) * grid_size + col) as u64;
+        let boundary_b = (2 * num_x_stabs + 3) as u64;
+        edges.push((bottom_z, boundary_b, boundary_weight));
+    }
+
+    edges
+}
+
+/// Run the coherence gate experiment
+#[cfg(feature = "structural")]
+fn run_coherence_experiment(config: &CoherenceGateConfig) -> CoherenceStats {
+    println!("\n╔═══════════════════════════════════════════════════════════════════╗");
+    println!("║     COHERENCE GATE: Subpolynomial Min-Cut for QEC                ║");
+    println!("╠═══════════════════════════════════════════════════════════════════╣");
+    println!(
+        "║ Code Distance: d={}  | Error Rate: {:.4}  | Rounds: {:>5}      ║",
+        config.code_distance, config.error_rate, config.num_rounds
+    );
+    println!("╚═══════════════════════════════════════════════════════════════════╝\n");
+
+    let mut stats = CoherenceStats::new();
+
+    // Build initial syndrome graph
+    let edges = build_syndrome_graph(config.code_distance);
+    println!(
+        "Building syndrome graph: {} nodes, {} edges",
+        2 * (config.code_distance - 1).pow(2) + 4,
+        edges.len()
+    );
+
+    // Create the dynamic min-cut structure using the proper API
+    let mut mincut = MinCutBuilder::new()
+        .exact()
+        .parallel(false) // Disable parallelism for accurate latency measurement
+        .with_edges(edges)
+        .build()
+        .expect("Failed to build min-cut structure");
+
+    println!("Initial min-cut value: {:.4}", mincut.min_cut_value());
+    println!();
+
+    // Initialize syndrome source
+    let surface_config =
+        SurfaceCodeConfig::new(config.code_distance, config.error_rate).with_seed(config.seed);
+    let mut syndrome_source =
+        StimSyndromeSource::new(surface_config).expect("Failed to create syndrome source");
+
+    let grid_size = config.code_distance - 1;
+    let num_x_stabs = grid_size * grid_size;
+    let z_offset = num_x_stabs as u64;
+
+    // Track which edges have been modified for cleanup
+    let mut modified_edges: Vec<(u64, u64, f64)> = Vec::new();
+
+    let start_time = Instant::now();
+    let mut last_report = Instant::now();
+
+    for round in 0..config.num_rounds {
+        let round_start = Instant::now();
+
+        // Get syndrome for this round
+        let syndrome: DetectorBitmap = match syndrome_source.sample() {
+            Ok(s) => s,
+            Err(_) => continue,
+        };
+
+        // Reset modified edges from previous round
+        for (u, v, original_weight) in modified_edges.drain(..) {
+            // Delete and re-insert with original weight
+            let _ = mincut.delete_edge(u, v);
+            let _ = mincut.insert_edge(u, v, original_weight);
+        }
+
+        // Update graph based on fired detectors
+        // Errors weaken edges around fired detectors
+        for detector_id in syndrome.iter_fired() {
+            let det = detector_id as u64;
+
+            // Determine grid position
+            let (base, local_id) = if det < num_x_stabs as u64 {
+                (0u64, det)
+            } else if det < (2 * num_x_stabs) as u64 {
+                (z_offset, det - z_offset)
+            } else {
+                continue;
+            };
+
+            let row = (local_id / grid_size as u64) as usize;
+            let col = (local_id % grid_size as u64) as usize;
+
+            // Weaken edges around this detector
+            let weakened_weight = 0.1;
+
+            // Horizontal edges
+            if col > 0 {
+                let left = base + (row * grid_size + col - 1) as u64;
+                let _ = mincut.delete_edge(left, det);
+                let _ = mincut.insert_edge(left, det, weakened_weight);
+                modified_edges.push((left, det, 1.0));
+            }
+            if col + 1 < grid_size {
+                let right = base + (row * grid_size + col + 1) as u64;
+                let _ = mincut.delete_edge(det, right);
+                let _ = mincut.insert_edge(det, right, weakened_weight);
+                modified_edges.push((det, right, 1.0));
+            }
+
+            // Vertical edges
+            if row > 0 {
+                let top = base + ((row - 1) * grid_size + col) as u64;
+                let _ = mincut.delete_edge(top, det);
+                let _ = mincut.insert_edge(top, det, weakened_weight);
+                modified_edges.push((top, det, 1.0));
+            }
+            if row + 1 < grid_size {
+                let bottom = base + ((row + 1) * grid_size + col) as u64;
+                let _ = mincut.delete_edge(det, bottom);
+                let _ = mincut.insert_edge(det, bottom, weakened_weight);
+                modified_edges.push((det, bottom, 1.0));
+            }
+
+            // X-Z coupling edge
+            let coupled = if base == 0 {
+                det + z_offset
+            } else {
+                det - z_offset
+            };
+            if coupled < (2 * num_x_stabs) as u64 {
+                let _ = mincut.delete_edge(det.min(coupled), det.max(coupled));
+                let _ =
+                    mincut.insert_edge(det.min(coupled), det.max(coupled), weakened_weight * 0.5);
+                modified_edges.push((det.min(coupled), det.max(coupled), 0.5));
+            }
+        }
+
+        // Query min-cut (O(1) after updates)
+        let min_cut = mincut.min_cut_value();
+        let update_ns = round_start.elapsed().as_nanos() as u64;
+
+        stats.record(min_cut, update_ns, config.coherence_threshold);
+
+        // Progress report
+        if last_report.elapsed() > Duration::from_secs(1) {
+            let progress = (round as f64 / config.num_rounds as f64) * 100.0;
+            let throughput = round as f64 / start_time.elapsed().as_secs_f64();
+            println!(
+                "  Progress: {:5.1}% | {:>7.0} rounds/sec | avg min-cut: {:.3}",
+                progress,
+                throughput,
+                stats.mean_min_cut()
+            );
+            last_report = Instant::now();
+        }
+    }
+
+    stats
+}
+
+/// Fallback implementation when structural feature is not available
+#[cfg(not(feature = "structural"))]
+fn run_coherence_experiment(config: &CoherenceGateConfig) -> CoherenceStats {
+    use ruqu::DynamicMinCutEngine;
+
+    println!("\n╔═══════════════════════════════════════════════════════════════════╗");
+    println!("║     COHERENCE GATE (Fallback Mode - No Subpolynomial)            ║");
+    println!("╠═══════════════════════════════════════════════════════════════════╣");
+    println!(
+        "║ Code Distance: d={}  | Error Rate: {:.4}  | Rounds: {:>5}      ║",
+        config.code_distance, config.error_rate, config.num_rounds
+    );
+    println!("╚═══════════════════════════════════════════════════════════════════╝\n");
+
+    let mut stats = CoherenceStats::new();
+
+    // Build initial syndrome graph
+    let edges = build_syndrome_graph(config.code_distance);
+    println!(
+        "Building syndrome graph: {} nodes, {} edges",
+        2 * (config.code_distance - 1).pow(2) + 4,
+        edges.len()
+    );
+
+    // Create fallback engine
+    let mut engine = DynamicMinCutEngine::new();
+    for (u, v, w) in &edges {
+        engine.insert_edge(*u as u32, *v as u32, *w);
+    }
+
+    println!("Initial min-cut value: {:.4}", engine.min_cut_value());
+    println!();
+
+    // Initialize syndrome source
+    let surface_config =
+        SurfaceCodeConfig::new(config.code_distance, config.error_rate).with_seed(config.seed);
+    let mut syndrome_source =
+        StimSyndromeSource::new(surface_config).expect("Failed to create syndrome source");
+
+    let grid_size = config.code_distance - 1;
+    let num_x_stabs = grid_size * grid_size;
+    let z_offset = num_x_stabs as u32;
+
+    let start_time = Instant::now();
+    let mut last_report = Instant::now();
+
+    for round in 0..config.num_rounds {
+        let round_start = Instant::now();
+
+        let syndrome: DetectorBitmap = match syndrome_source.sample() {
+            Ok(s) => s,
+            Err(_) => continue,
+        };
+
+        // Compute coherence metric based on fired detectors
+        let fired_count = syndrome.fired_count();
+        let firing_rate = fired_count as f64 / (2 * num_x_stabs) as f64;
+
+        // Heuristic coherence score based on error density
+        let d = config.code_distance as f64;
+        let base_coherence = d - 1.0;
+        let penalty = firing_rate * d * 2.0;
+
+        // Check for clustering (adjacent errors)
+        let detectors: Vec<_> = syndrome.iter_fired().collect();
+        let mut cluster_penalty = 0.0;
+        for i in 0..detectors.len() {
+            for j in (i + 1)..detectors.len() {
+                let di = detectors[i] as i32;
+                let dj = detectors[j] as i32;
+                if (di - dj).unsigned_abs() <= grid_size as u32 {
+                    cluster_penalty += 0.5;
+                }
+            }
+        }
+
+        let min_cut =
+            (base_coherence - penalty - cluster_penalty.min(base_coherence * 0.5)).max(0.1);
+        let update_ns = round_start.elapsed().as_nanos() as u64;
+
+        stats.record(min_cut, update_ns, config.coherence_threshold);
+
+        if last_report.elapsed() > Duration::from_secs(1) {
+            let progress = (round as f64 / config.num_rounds as f64) * 100.0;
+            let throughput = round as f64 / start_time.elapsed().as_secs_f64();
+            println!(
+                "  Progress: {:5.1}% | {:>7.0} rounds/sec | avg coherence: {:.3}",
+                progress,
+                throughput,
+                stats.mean_min_cut()
+            );
+            last_report = Instant::now();
+        }
+    }
+
+    stats
+}
+
+/// Print experiment results
+fn print_results(_config: &CoherenceGateConfig, stats: &CoherenceStats, elapsed: Duration) {
+    println!("\n╔═══════════════════════════════════════════════════════════════════╗");
+    println!("║                      EXPERIMENT RESULTS                          ║");
+    println!("╠═══════════════════════════════════════════════════════════════════╣");
+    println!(
+        "║ Throughput:          {:>10.0} rounds/sec                      ║",
+        stats.total_rounds as f64 / elapsed.as_secs_f64()
+    );
+    println!(
+        "║ Avg Update Latency:  {:>10.0} ns                              ║",
+        stats.avg_update_ns()
+    );
+    println!("╠═══════════════════════════════════════════════════════════════════╣");
+    println!("║ Min-Cut Statistics:                                              ║");
+    println!(
+        "║   Mean:     {:>8.4} ± {:.4}                                   ║",
+        stats.mean_min_cut(),
+        stats.std_min_cut()
+    );
+    println!(
+        "║   Range:    [{:.4}, {:.4}]                                      ║",
+        stats.min_min_cut, stats.max_min_cut
+    );
+    println!("╠═══════════════════════════════════════════════════════════════════╣");
+    println!("║ Coherence Assessment:                                            ║");
+    println!(
+        "║   Coherent:   {:>6} ({:>5.1}%)                                   ║",
+        stats.coherent_rounds,
+        stats.coherent_rounds as f64 / stats.total_rounds as f64 * 100.0
+    );
+    println!(
+        "║   Warning:    {:>6} ({:>5.1}%)                                   ║",
+        stats.warning_rounds,
+        stats.warning_rounds as f64 / stats.total_rounds as f64 * 100.0
+    );
+    println!(
+        "║   Critical:   {:>6} ({:>5.1}%)                                   ║",
+        stats.critical_rounds,
+        stats.critical_rounds as f64 / stats.total_rounds as f64 * 100.0
+    );
+    println!("╚═══════════════════════════════════════════════════════════════════╝");
+}
+
+/// Compare different code distances
+fn compare_code_distances() {
+    println!("\n╔═══════════════════════════════════════════════════════════════════╗");
+    println!("║        CODE DISTANCE SCALING ANALYSIS                            ║");
+    println!("╠═══════════════════════════════════════════════════════════════════╣");
+    println!("║  d  │ Coherence Rate │ Avg Min-Cut │ Throughput   │ Latency     ║");
+    println!("╠═════╪════════════════╪═════════════╪══════════════╪═════════════╣");
+
+    for d in [3, 5, 7, 9] {
+        let config = CoherenceGateConfig {
+            code_distance: d,
+            error_rate: 0.001,
+            num_rounds: 2000,
+            seed: 42,
+            coherence_threshold: (d - 1) as f64 / 2.0,
+        };
+
+        let start = Instant::now();
+        let stats = run_coherence_experiment(&config);
+        let elapsed = start.elapsed();
+
+        println!(
+            "║ {:>2}  │ {:>12.1}%  │ {:>9.4}   │ {:>8.0}/s   │ {:>7.0} ns  ║",
+            d,
+            stats.coherence_rate() * 100.0,
+            stats.mean_min_cut(),
+            stats.total_rounds as f64 / elapsed.as_secs_f64(),
+            stats.avg_update_ns()
+        );
+    }
+
+    println!("╚═════╧════════════════╧═════════════╧══════════════╧═════════════╝");
+}
+
+/// Compare different error rates
+fn compare_error_rates(code_distance: usize) {
+    println!("\n╔═══════════════════════════════════════════════════════════════════╗");
+    println!(
+        "║        ERROR RATE SENSITIVITY (d={})                             ║",
+        code_distance
+    );
+    println!("╠═══════════════════════════════════════════════════════════════════╣");
+    println!("║  Error Rate  │ Coherent │ Warning │ Critical │ Avg Min-Cut      ║");
+    println!("╠══════════════╪══════════╪═════════╪══════════╪══════════════════╣");
+
+    for &p in &[0.0001, 0.0005, 0.001, 0.002, 0.005, 0.01] {
+        let config = CoherenceGateConfig {
+            code_distance,
+            error_rate: p,
+            num_rounds: 2000,
+            seed: 42,
+            coherence_threshold: (code_distance - 1) as f64 / 2.0,
+        };
+
+        let stats = run_coherence_experiment(&config);
+
+        println!(
+            "║    {:.4}    │ {:>6.1}%  │ {:>5.1}%  │ {:>6.1}%  │ {:>8.4} ± {:.4} ║",
+            p,
+            stats.coherent_rounds as f64 / stats.total_rounds as f64 * 100.0,
+            stats.warning_rounds as f64 / stats.total_rounds as f64 * 100.0,
+            stats.critical_rounds as f64 / stats.total_rounds as f64 * 100.0,
+            stats.mean_min_cut(),
+            stats.std_min_cut()
+        );
+    }
+
+    println!("╚══════════════╧══════════╧═════════╧══════════╧══════════════════╝");
+}
+
+fn main() {
+    println!("\n═══════════════════════════════════════════════════════════════════════");
+    println!("      COHERENCE GATE BREAKTHROUGH DEMONSTRATION");
+    println!("      Using El-Hayek/Henzinger/Li Subpolynomial Dynamic Min-Cut");
+    println!("═══════════════════════════════════════════════════════════════════════");
+
+    #[cfg(feature = "structural")]
+    println!("\n[✓] Structural feature enabled - using real SubpolynomialMinCut");
+    #[cfg(not(feature = "structural"))]
+    println!("\n[!] Structural feature not enabled - using heuristic fallback");
+
+    // Main experiment
+    let config = CoherenceGateConfig {
+        code_distance: 5,
+        error_rate: 0.001,
+        num_rounds: 5000,
+        seed: 42,
+        coherence_threshold: 2.0,
+    };
+
+    let start = Instant::now();
+    let stats = run_coherence_experiment(&config);
+    let elapsed = start.elapsed();
+
+    print_results(&config, &stats, elapsed);
+
+    // Scaling analysis
+    compare_code_distances();
+
+    // Error rate sensitivity
+    compare_error_rates(5);
+
+    // Theoretical analysis
+    println!("\n╔═══════════════════════════════════════════════════════════════════╗");
+    println!("║                   THEORETICAL CONTRIBUTION                        ║");
+    println!("╠═══════════════════════════════════════════════════════════════════╣");
+    println!("║ This demonstrates the first application of O(n^{{o(1)}}) dynamic   ║");
+    println!("║ min-cut to quantum error correction coherence monitoring.         ║");
+    println!("║                                                                   ║");
+    println!("║ Key advantages over traditional decoders:                         ║");
+    println!("║  • Subpolynomial update time vs O(n) MWPM average                ║");
+    println!("║  • Persistent data structure across syndrome rounds              ║");
+    println!("║  • Early coherence warning before logical errors                 ║");
+    println!("║  • Complementary to (not replacement for) decoding               ║");
+    println!("║                                                                   ║");
+    println!("║ Potential applications:                                           ║");
+    println!("║  • Pre-filter for expensive neural decoders                      ║");
+    println!("║  • Real-time coherence dashboards                                ║");
+    println!("║  • Adaptive error correction scheduling                          ║");
+    println!("╚═══════════════════════════════════════════════════════════════════╝");
+
+    println!("\n═══════════════════════════════════════════════════════════════════════");
+    println!("                    EXPERIMENT COMPLETE");
+    println!("═══════════════════════════════════════════════════════════════════════\n");
+}