Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/crates/ruQu/benches/mincut_bench.rs

@@ -0,0 +1,164 @@
+//! Benchmarks for the real SubpolynomialMinCut integration
+//!
+//! Tests the El-Hayek/Henzinger/Li O(n^{o(1)}) algorithm performance.
+
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use ruqu::mincut::DynamicMinCutEngine;
+
+/// Benchmark min-cut engine creation
+fn bench_engine_creation(c: &mut Criterion) {
+    c.bench_function("mincut_engine_creation", |b| {
+        b.iter(|| black_box(DynamicMinCutEngine::new()));
+    });
+}
+
+/// Benchmark edge insertion
+fn bench_edge_insertion(c: &mut Criterion) {
+    let mut group = c.benchmark_group("mincut_edge_insertion");
+
+    for size in [10, 50, 100, 500] {
+        group.throughput(Throughput::Elements(size as u64));
+        group.bench_with_input(BenchmarkId::from_parameter(size), &size, |b, &size| {
+            b.iter_batched(
+                || DynamicMinCutEngine::new(),
+                |mut engine| {
+                    for i in 0..size {
+                        engine.insert_edge(i as u32, (i + 1) as u32, 1.0);
+                    }
+                    black_box(engine)
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        });
+    }
+    group.finish();
+}
+
+/// Benchmark min-cut query after building a graph
+fn bench_mincut_query(c: &mut Criterion) {
+    let mut group = c.benchmark_group("mincut_query");
+
+    for size in [10, 50, 100, 200] {
+        group.bench_with_input(BenchmarkId::from_parameter(size), &size, |b, &size| {
+            // Build a random-ish graph
+            let mut engine = DynamicMinCutEngine::new();
+            for i in 0..size {
+                engine.insert_edge(i as u32, ((i + 1) % size) as u32, 1.0);
+                if i > 0 {
+                    engine.insert_edge(i as u32, ((i + size / 2) % size) as u32, 0.5);
+                }
+            }
+
+            b.iter(|| black_box(engine.min_cut_value()));
+        });
+    }
+    group.finish();
+}
+
+/// Benchmark dynamic updates (insert + query)
+fn bench_dynamic_updates(c: &mut Criterion) {
+    let mut group = c.benchmark_group("mincut_dynamic_updates");
+
+    for size in [50, 100] {
+        group.bench_with_input(BenchmarkId::from_parameter(size), &size, |b, &size| {
+            // Build initial graph
+            let mut engine = DynamicMinCutEngine::new();
+            for i in 0..size {
+                engine.insert_edge(i as u32, ((i + 1) % size) as u32, 1.0);
+            }
+            // Query once to prime
+            let _ = engine.min_cut_value();
+
+            let mut counter = 0u32;
+            b.iter(|| {
+                // Insert edge
+                engine.insert_edge(counter % size as u32, (counter + 10) % size as u32, 1.5);
+                // Query
+                let cut = engine.min_cut_value();
+                // Delete edge
+                engine.delete_edge(counter % size as u32, (counter + 10) % size as u32);
+                counter = counter.wrapping_add(1);
+                black_box(cut)
+            });
+        });
+    }
+    group.finish();
+}
+
+/// Benchmark grid graph (surface code-like)
+fn bench_surface_code_graph(c: &mut Criterion) {
+    let mut group = c.benchmark_group("mincut_surface_code");
+
+    for distance in [5, 7, 9] {
+        let num_qubits = 2 * distance * distance - 2 * distance + 1;
+        group.bench_with_input(
+            BenchmarkId::new("distance", distance),
+            &distance,
+            |b, &d| {
+                b.iter_batched(
+                    || {
+                        // Build a grid graph approximating surface code
+                        let mut engine = DynamicMinCutEngine::new();
+                        for row in 0..d {
+                            for col in 0..d {
+                                let v = (row * d + col) as u32;
+                                // Horizontal edges
+                                if col + 1 < d {
+                                    engine.insert_edge(v, v + 1, 1.0);
+                                }
+                                // Vertical edges
+                                if row + 1 < d {
+                                    engine.insert_edge(v, v + d as u32, 1.0);
+                                }
+                            }
+                        }
+                        engine
+                    },
+                    |mut engine| {
+                        // Simulate syndrome updates
+                        for i in 0..10 {
+                            let v = (i % (d * d)) as u32;
+                            engine.insert_edge(v, v + 1, 0.8);
+                            let _ = engine.min_cut_value();
+                        }
+                        black_box(engine)
+                    },
+                    criterion::BatchSize::SmallInput,
+                );
+            },
+        );
+    }
+    group.finish();
+}
+
+/// Benchmark full min-cut result with certificate
+fn bench_mincut_certified(c: &mut Criterion) {
+    let mut group = c.benchmark_group("mincut_certified");
+
+    for size in [50, 100] {
+        group.bench_with_input(BenchmarkId::from_parameter(size), &size, |b, &size| {
+            let mut engine = DynamicMinCutEngine::new();
+            for i in 0..size {
+                engine.insert_edge(i as u32, ((i + 1) % size) as u32, 1.0);
+            }
+
+            b.iter(|| {
+                let result = engine.min_cut();
+                black_box((result.value, result.is_exact, result.witness_hash))
+            });
+        });
+    }
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_engine_creation,
+    bench_edge_insertion,
+    bench_mincut_query,
+    bench_dynamic_updates,
+    bench_surface_code_graph,
+    bench_mincut_certified,
+);
+
+criterion_main!(benches);