feat: vendor midstream and sublinear-time-solver libraries

Add ruvnet/midstream (AIMDS real-time inference) and
ruvnet/sublinear-time-solver (sublinear optimization algorithms)
as vendored dependencies under vendor/.

Co-Authored-By: claude-flow <ruv@ruv.net>

vendor/sublinear-time-solver/tests/rust/hybrid_tests.rs

@@ -0,0 +1,421 @@
+use sublinear_time_solver::core::{SparseMatrix, Vector};
+use sublinear_time_solver::solver::hybrid::{HybridSolver, HybridConfig};
+use sublinear_time_solver::solver::random_walk::{RandomWalkConfig, VarianceReduction};
+use sublinear_time_solver::solver::sampling::{SamplingConfig, SamplingStrategy};
+use sublinear_time_solver::algorithms::{Algorithm, Precision};
+
+fn create_test_matrix(n: usize) -> SparseMatrix {
+    let mut matrix = SparseMatrix::new(n, n);
+
+    // Create a symmetric positive definite matrix
+    for i in 0..n {
+        matrix.insert(i, i, 2.0 + i as f64 * 0.1); // Diagonal dominance
+
+        if i > 0 {
+            matrix.insert(i, i-1, -0.5);
+            matrix.insert(i-1, i, -0.5);
+        }
+
+        if i < n - 1 {
+            matrix.insert(i, i+1, -0.3);
+            matrix.insert(i+1, i, -0.3);
+        }
+    }
+
+    matrix
+}
+
+fn create_test_vector(n: usize) -> Vector {
+    (0..n).map(|i| 1.0 + (i as f64) * 0.2).collect()
+}
+
+#[test]
+fn test_hybrid_solver_basic_functionality() {
+    let mut config = HybridConfig::default();
+    config.max_iterations = 500;
+    config.convergence_tolerance = 1e-6;
+    config.parallel_execution = false; // Avoid threading issues in tests
+
+    let mut solver = HybridSolver::new(config);
+
+    let matrix = create_test_matrix(5);
+    let b = create_test_vector(5);
+
+    let solution = solver.solve_linear_system(&matrix, &b).unwrap();
+
+    assert_eq!(solution.len(), 5);
+
+    // Verify solution quality by computing residual
+    let mut residual = vec![0.0; 5];
+    for i in 0..5 {
+        let row = matrix.get_row(i);
+        for (&j, &value) in row {
+            residual[i] += value * solution[j];
+        }
+        residual[i] -= b[i];
+    }
+
+    let residual_norm: f64 = residual.iter().map(|r| r.powi(2)).sum::<f64>().sqrt();
+    assert!(residual_norm < 0.1, "Residual norm {} too large", residual_norm);
+}
+
+#[test]
+fn test_hybrid_solver_with_different_configurations() {
+    let test_cases = vec![
+        // Pure deterministic
+        HybridConfig {
+            use_deterministic: true,
+            use_random_walk: false,
+            use_bidirectional: false,
+            use_multilevel: false,
+            max_iterations: 200,
+            convergence_tolerance: 1e-5,
+            parallel_execution: false,
+            ..Default::default()
+        },
+        // Pure random walk
+        HybridConfig {
+            use_deterministic: false,
+            use_random_walk: true,
+            use_bidirectional: false,
+            use_multilevel: false,
+            max_iterations: 200,
+            convergence_tolerance: 1e-4,
+            parallel_execution: false,
+            random_walk_config: RandomWalkConfig {
+                max_steps: 1000,
+                variance_reduction: VarianceReduction::Antithetic,
+                seed: Some(42),
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+        // Hybrid approach
+        HybridConfig {
+            use_deterministic: true,
+            use_random_walk: true,
+            use_bidirectional: true,
+            use_multilevel: false,
+            deterministic_weight: 0.6,
+            max_iterations: 300,
+            convergence_tolerance: 1e-5,
+            parallel_execution: false,
+            ..Default::default()
+        },
+    ];
+
+    let matrix = create_test_matrix(4);
+    let b = create_test_vector(4);
+
+    for (idx, config) in test_cases.into_iter().enumerate() {
+        let mut solver = HybridSolver::new(config);
+        let solution = solver.solve_linear_system(&matrix, &b);
+
+        match solution {
+            Ok(sol) => {
+                assert_eq!(sol.len(), 4, "Test case {}: Wrong solution size", idx);
+
+                // Basic sanity checks
+                assert!(sol.iter().all(|&x| x.is_finite()), "Test case {}: Non-finite solution", idx);
+
+                let metrics = solver.get_metrics();
+                assert!(metrics.total_iterations > 0, "Test case {}: No iterations performed", idx);
+
+                println!("Test case {}: Iterations: {}, Residual: {:.2e}",
+                        idx, metrics.total_iterations, metrics.final_residual);
+            },
+            Err(e) => {
+                panic!("Test case {} failed: {:?}", idx, e);
+            }
+        }
+    }
+}
+
+#[test]
+fn test_adaptive_weight_adjustment() {
+    let mut config = HybridConfig::default();
+    config.adaptation_interval = 10;
+    config.max_iterations = 100;
+    config.parallel_execution = false;
+
+    let mut solver = HybridSolver::new(config);
+
+    let matrix = create_test_matrix(3);
+    let b = create_test_vector(3);
+
+    let initial_metrics = solver.get_metrics();
+    let _solution = solver.solve_linear_system(&matrix, &b).unwrap();
+    let final_metrics = solver.get_metrics();
+
+    // Weights should be normalized
+    let weights = &final_metrics.method_weights;
+    let total_weight = weights.deterministic + weights.random_walk
+                     + weights.bidirectional + weights.multilevel;
+    assert!((total_weight - 1.0).abs() < 1e-10, "Weights not normalized: {}", total_weight);
+
+    // Should have made progress
+    assert!(final_metrics.total_iterations > initial_metrics.total_iterations);
+}
+
+#[test]
+fn test_convergence_detection() {
+    let mut config = HybridConfig::default();
+    config.convergence_tolerance = 1e-8;
+    config.max_iterations = 1000;
+    config.parallel_execution = false;
+
+    let mut solver = HybridSolver::new(config);
+
+    // Simple well-conditioned system
+    let mut matrix = SparseMatrix::new(2, 2);
+    matrix.insert(0, 0, 4.0);
+    matrix.insert(0, 1, -1.0);
+    matrix.insert(1, 0, -1.0);
+    matrix.insert(1, 1, 4.0);
+
+    let b = vec![3.0, 3.0];
+    let solution = solver.solve_linear_system(&matrix, &b).unwrap();
+
+    let metrics = solver.get_metrics();
+
+    // Should converge to high precision
+    assert!(metrics.final_residual < 1e-6, "Did not achieve convergence: {:.2e}", metrics.final_residual);
+    assert!(matches!(metrics.precision, Precision::High | Precision::Medium));
+
+    // Expected solution is [1, 1]
+    assert!((solution[0] - 1.0).abs() < 0.01, "Solution[0] = {}, expected ~1.0", solution[0]);
+    assert!((solution[1] - 1.0).abs() < 0.01, "Solution[1] = {}, expected ~1.0", solution[1]);
+}
+
+#[test]
+fn test_memory_management() {
+    let mut config = HybridConfig::default();
+    config.memory_limit = 1; // Very small limit to trigger cleanup
+    config.max_iterations = 500;
+    config.parallel_execution = false;
+
+    let mut solver = HybridSolver::new(config);
+
+    let matrix = create_test_matrix(3);
+    let b = create_test_vector(3);
+
+    let _solution = solver.solve_linear_system(&matrix, &b).unwrap();
+
+    // Memory should be managed (convergence history should be limited)
+    let metrics = solver.get_metrics();
+    assert!(metrics.memory_usage > 0, "Memory usage should be tracked");
+}
+
+#[test]
+fn test_different_sampling_strategies() {
+    let strategies = vec![
+        SamplingStrategy::Uniform,
+        SamplingStrategy::ImportanceSampling,
+        SamplingStrategy::AdaptiveSampling,
+        SamplingStrategy::QuasiMonteCarlo,
+    ];
+
+    let matrix = create_test_matrix(3);
+    let b = create_test_vector(3);
+
+    for strategy in strategies {
+        let config = HybridConfig {
+            use_random_walk: true,
+            use_deterministic: false,
+            max_iterations: 200,
+            convergence_tolerance: 1e-4,
+            parallel_execution: false,
+            sampling_config: SamplingConfig {
+                strategy,
+                sample_size: 500,
+                seed: Some(42),
+                ..Default::default()
+            },
+            random_walk_config: RandomWalkConfig {
+                max_steps: 1000,
+                seed: Some(42),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+
+        let mut solver = HybridSolver::new(config);
+        let solution = solver.solve_linear_system(&matrix, &b);
+
+        match solution {
+            Ok(sol) => {
+                assert_eq!(sol.len(), 3);
+                assert!(sol.iter().all(|&x| x.is_finite()));
+                println!("Strategy {:?}: Solution quality OK", strategy);
+            },
+            Err(e) => {
+                println!("Strategy {:?} failed: {:?}", strategy, e);
+                // Some strategies might fail for small test cases, that's OK
+            }
+        }
+    }
+}
+
+#[test]
+fn test_variance_reduction_techniques() {
+    let variance_methods = vec![
+        VarianceReduction::None,
+        VarianceReduction::Antithetic,
+    ];
+
+    let matrix = create_test_matrix(4);
+    let b = create_test_vector(4);
+
+    for method in variance_methods {
+        let config = HybridConfig {
+            use_random_walk: true,
+            use_deterministic: false,
+            max_iterations: 100,
+            parallel_execution: false,
+            random_walk_config: RandomWalkConfig {
+                variance_reduction: method.clone(),
+                max_steps: 1000,
+                seed: Some(42),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+
+        let mut solver = HybridSolver::new(config);
+        let solution = solver.solve_linear_system(&matrix, &b);
+
+        match solution {
+            Ok(sol) => {
+                assert_eq!(sol.len(), 4);
+                println!("Variance reduction {:?}: Success", method);
+            },
+            Err(e) => {
+                println!("Variance reduction {:?} failed: {:?}", method, e);
+            }
+        }
+    }
+}
+
+#[test]
+fn test_algorithm_trait_implementation() {
+    let config = HybridConfig {
+        max_iterations: 100,
+        convergence_tolerance: 1e-6,
+        parallel_execution: false,
+        ..Default::default()
+    };
+
+    let mut solver = HybridSolver::new(config);
+
+    let matrix = create_test_matrix(3);
+    let b = create_test_vector(3);
+
+    // Test Algorithm trait methods
+    let solution = solver.solve(&matrix, &b).unwrap();
+    assert_eq!(solution.len(), 3);
+
+    let metrics = solver.get_metrics();
+    assert!(metrics.iterations > 0);
+    assert!(metrics.residual >= 0.0);
+    assert!(metrics.convergence_rate >= 0.0);
+
+    // Test config update (should not panic)
+    let mut params = std::collections::HashMap::new();
+    params.insert("learning_rate".to_string(), 0.1);
+    solver.update_config(params);
+}
+
+#[test]
+fn test_ill_conditioned_system() {
+    let mut config = HybridConfig::default();
+    config.max_iterations = 1000;
+    config.convergence_tolerance = 1e-4; // Relaxed tolerance for ill-conditioned system
+    config.parallel_execution = false;
+
+    let mut solver = HybridSolver::new(config);
+
+    // Create an ill-conditioned matrix
+    let mut matrix = SparseMatrix::new(3, 3);
+    matrix.insert(0, 0, 1.0);
+    matrix.insert(0, 1, 1.0);
+    matrix.insert(0, 2, 1.0);
+    matrix.insert(1, 0, 1.0);
+    matrix.insert(1, 1, 1.0001);
+    matrix.insert(1, 2, 1.0);
+    matrix.insert(2, 0, 1.0);
+    matrix.insert(2, 1, 1.0);
+    matrix.insert(2, 2, 1.0002);
+
+    let b = vec![3.0, 3.0001, 3.0002];
+
+    let solution = solver.solve_linear_system(&matrix, &b);
+
+    match solution {
+        Ok(sol) => {
+            assert_eq!(sol.len(), 3);
+            assert!(sol.iter().all(|&x| x.is_finite()));
+
+            let metrics = solver.get_metrics();
+            println!("Ill-conditioned system: Iterations: {}, Residual: {:.2e}",
+                    metrics.total_iterations, metrics.final_residual);
+        },
+        Err(_) => {
+            // It's acceptable for very ill-conditioned systems to fail
+            println!("Ill-conditioned system failed as expected");
+        }
+    }
+}
+
+#[test]
+fn test_large_sparse_system() {
+    let mut config = HybridConfig::default();
+    config.max_iterations = 200;
+    config.convergence_tolerance = 1e-5;
+    config.parallel_execution = false;
+
+    let mut solver = HybridSolver::new(config);
+
+    // Create a larger sparse system (10x10)
+    let matrix = create_test_matrix(10);
+    let b = create_test_vector(10);
+
+    let start = std::time::Instant::now();
+    let solution = solver.solve_linear_system(&matrix, &b).unwrap();
+    let duration = start.elapsed();
+
+    assert_eq!(solution.len(), 10);
+    assert!(solution.iter().all(|&x| x.is_finite()));
+
+    let metrics = solver.get_metrics();
+    println!("Large system (10x10): Time: {:?}, Iterations: {}, Residual: {:.2e}",
+            duration, metrics.total_iterations, metrics.final_residual);
+
+    // Should solve in reasonable time
+    assert!(duration.as_secs() < 10, "Took too long: {:?}", duration);
+}
+
+#[test]
+#[ignore] // Potentially slow test
+fn test_parallel_execution() {
+    let mut config = HybridConfig::default();
+    config.parallel_execution = true;
+    config.max_iterations = 100;
+    config.convergence_tolerance = 1e-6;
+
+    let mut solver = HybridSolver::new(config);
+
+    let matrix = create_test_matrix(5);
+    let b = create_test_vector(5);
+
+    let start = std::time::Instant::now();
+    let solution = solver.solve_linear_system(&matrix, &b).unwrap();
+    let duration = start.elapsed();
+
+    assert_eq!(solution.len(), 5);
+    assert!(solution.iter().all(|&x| x.is_finite()));
+
+    println!("Parallel execution: Time: {:?}", duration);
+
+    // Parallel execution should complete
+    assert!(duration.as_secs() < 30, "Parallel execution took too long");
+}

vendor/sublinear-time-solver/tests/rust/push_tests.rs

@@ -0,0 +1,555 @@
+//! Comprehensive tests for push algorithms
+//!
+//! Tests forward push, backward push, and bidirectional algorithms
+//! with various graph structures and configurations.
+
+use sublinear_time_solver::graph::{CompressedSparseRow, PushGraph, AdjacencyList};
+use sublinear_time_solver::solver::forward_push::{
+    ForwardPushSolver, ForwardPushConfig, ForwardPushResult,
+};
+use sublinear_time_solver::solver::backward_push::{
+    BackwardPushSolver, BackwardPushConfig, BidirectionalPushSolver,
+};
+
+/// Create a simple test graph for basic testing
+fn create_simple_graph() -> PushGraph {
+    let mut csr = CompressedSparseRow::new(4, 4);
+    csr.row_ptr = vec![0, 2, 4, 6, 7];
+    csr.col_indices = vec![1, 2, 0, 3, 0, 3, 1];
+    csr.values = vec![0.5, 0.5, 0.8, 0.2, 0.6, 0.4, 1.0];
+    
+    PushGraph::from_matrix(&csr)
+}
+
+/// Create a larger random-like graph for performance testing
+fn create_random_graph(n: usize, edges_per_node: usize) -> PushGraph {
+    let mut adjacency = AdjacencyList::new(n);
+    
+    // Create a random-like graph with deterministic seed for reproducibility
+    let mut seed = 12345u64;
+    for i in 0..n {
+        for j in 0..edges_per_node {
+            // Simple LCG for reproducible "randomness"
+            seed = seed.wrapping_mul(1103515245).wrapping_add(12345);
+            let target = (seed as usize) % n;
+            let weight = 1.0 / edges_per_node as f64;
+            
+            if target != i {
+                adjacency.add_edge(i, target, weight);
+            }
+        }
+    }
+    
+    adjacency.normalize();
+    let csr = adjacency.to_csr();
+    PushGraph::from_matrix(&csr)
+}
+
+/// Create a path graph (0 -> 1 -> 2 -> ... -> n-1)
+fn create_path_graph(n: usize) -> PushGraph {
+    let mut adjacency = AdjacencyList::new(n);
+    
+    for i in 0..n-1 {
+        adjacency.add_edge(i, i + 1, 1.0);
+    }
+    
+    let csr = adjacency.to_csr();
+    PushGraph::from_matrix(&csr)
+}
+
+/// Create a complete graph where every node connects to every other node
+fn create_complete_graph(n: usize) -> PushGraph {
+    let mut adjacency = AdjacencyList::new(n);
+    let weight = 1.0 / (n - 1) as f64;
+    
+    for i in 0..n {
+        for j in 0..n {
+            if i != j {
+                adjacency.add_edge(i, j, weight);
+            }
+        }
+    }
+    
+    let csr = adjacency.to_csr();
+    PushGraph::from_matrix(&csr)
+}
+
+#[cfg(test)]
+mod forward_push_tests {
+    use super::*;
+    
+    #[test]
+    fn test_forward_push_basic_functionality() {
+        let graph = create_simple_graph();
+        let config = ForwardPushConfig::default();
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let result = solver.solve_single_source(0);
+        
+        // Basic sanity checks
+        assert!(result.push_count > 0, "Should perform at least one push operation");
+        assert!(result.nodes_visited > 0, "Should visit at least one node");
+        assert!(result.estimate[0] > 0.0, "Source should have positive estimate");
+        assert!(result.residual_norm >= 0.0, "Residual norm should be non-negative");
+        
+        // Check that estimates are non-negative
+        for &est in &result.estimate {
+            assert!(est >= 0.0, "All estimates should be non-negative");
+        }
+        
+        // Check that residuals are non-negative
+        for &res in &result.residual {
+            assert!(res >= 0.0, "All residuals should be non-negative");
+        }
+    }
+    
+    #[test]
+    fn test_forward_push_mass_conservation() {
+        let graph = create_simple_graph();
+        let config = ForwardPushConfig {
+            epsilon: 1e-8,
+            ..ForwardPushConfig::default()
+        };
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let result = solver.solve_single_source(0);
+        let final_solution = solver.extrapolated_solution(&result);
+        
+        let total_mass: f64 = final_solution.iter().sum();
+        let residual_mass: f64 = result.residual.iter().sum();
+        
+        // Total mass should be approximately conserved
+        assert!(
+            (total_mass - 1.0).abs() < 0.01,
+            "Total mass should be approximately 1.0, got {}",
+            total_mass
+        );
+        
+        println!("Total mass: {}, Residual mass: {}", total_mass, residual_mass);
+    }
+    
+    #[test]
+    fn test_forward_push_convergence() {
+        let graph = create_simple_graph();
+        let tight_config = ForwardPushConfig {
+            epsilon: 1e-10,
+            max_pushes: 100_000,
+            ..ForwardPushConfig::default()
+        };
+        let loose_config = ForwardPushConfig {
+            epsilon: 1e-4,
+            max_pushes: 100_000,
+            ..ForwardPushConfig::default()
+        };
+        
+        let tight_solver = ForwardPushSolver::new(graph.clone(), tight_config);
+        let loose_solver = ForwardPushSolver::new(graph, loose_config);
+        
+        let tight_result = tight_solver.solve_single_source(0);
+        let loose_result = loose_solver.solve_single_source(0);
+        
+        // Tighter tolerance should require more pushes
+        assert!(
+            tight_result.push_count >= loose_result.push_count,
+            "Tighter tolerance should require at least as many pushes"
+        );
+        
+        // Tighter tolerance should have smaller residual norm
+        assert!(
+            tight_result.residual_norm <= loose_result.residual_norm * 10.0,
+            "Tighter tolerance should have smaller residual norm"
+        );
+    }
+    
+    #[test]
+    fn test_forward_push_multi_source() {
+        let graph = create_simple_graph();
+        let config = ForwardPushConfig::default();
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let sources = vec![0, 2];
+        let result = solver.solve_multi_source(&sources);
+        
+        assert!(result.push_count > 0);
+        assert!(result.nodes_visited > 0);
+        
+        // Both sources should have positive estimates
+        assert!(result.estimate[0] > 0.0);
+        assert!(result.estimate[2] > 0.0);
+        
+        let total_mass: f64 = result.estimate.iter().sum();
+        assert!(total_mass > 0.0, "Total estimate mass should be positive");
+    }
+    
+    #[test]
+    fn test_forward_push_single_entry_query() {
+        let graph = create_simple_graph();
+        let config = ForwardPushConfig::default();
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let value = solver.query_single_entry(0, 1);
+        assert!(value >= 0.0, "Query result should be non-negative");
+        
+        // Query from node to itself should be positive
+        let self_value = solver.query_single_entry(0, 0);
+        assert!(self_value > 0.0, "Self-query should be positive");
+    }
+    
+    #[test]
+    fn test_forward_push_path_graph() {
+        let graph = create_path_graph(5);
+        let config = ForwardPushConfig::default();
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let result = solver.solve_single_source(0);
+        
+        // In a path graph, probability should decrease along the path
+        assert!(result.estimate[0] > result.estimate[1]);
+        assert!(result.estimate[1] > result.estimate[2] || result.estimate[2] < 1e-6);
+    }
+    
+    #[test]
+    fn test_forward_push_complete_graph() {
+        let graph = create_complete_graph(4);
+        let config = ForwardPushConfig::default();
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let result = solver.solve_single_source(0);
+        let final_solution = solver.extrapolated_solution(&result);
+        
+        // In a complete graph, steady-state should be approximately uniform
+        let expected = config.alpha; // Restart probability
+        for i in 0..4 {
+            let diff = (final_solution[i] - expected).abs();
+            assert!(
+                diff < 0.1,
+                "Complete graph should have approximately uniform distribution, got {} for node {}",
+                final_solution[i], i
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod backward_push_tests {
+    use super::*;
+    
+    #[test]
+    fn test_backward_push_basic_functionality() {
+        let graph = create_simple_graph();
+        let config = BackwardPushConfig::default();
+        let solver = BackwardPushSolver::new(graph, config);
+        
+        let result = solver.solve_single_target(3);
+        
+        assert!(result.push_count > 0, "Should perform at least one push operation");
+        assert!(result.nodes_visited > 0, "Should visit at least one node");
+        assert!(result.estimate[3] > 0.0, "Target should have positive estimate");
+        assert!(result.residual_norm >= 0.0, "Residual norm should be non-negative");
+        
+        // Check non-negativity
+        for &est in &result.estimate {
+            assert!(est >= 0.0, "All estimates should be non-negative");
+        }
+    }
+    
+    #[test]
+    fn test_backward_push_transition_probability() {
+        let graph = create_simple_graph();
+        let config = BackwardPushConfig::default();
+        let solver = BackwardPushSolver::new(graph, config);
+        
+        let prob = solver.query_transition_probability(0, 3);
+        assert!(prob >= 0.0 && prob <= 1.0, "Transition probability should be in [0,1]");
+        
+        // Self-transition should be positive due to restart probability
+        let self_prob = solver.query_transition_probability(0, 0);
+        assert!(self_prob > 0.0, "Self-transition should be positive");
+    }
+    
+    #[test]
+    fn test_backward_push_multi_target() {
+        let graph = create_simple_graph();
+        let config = BackwardPushConfig::default();
+        let solver = BackwardPushSolver::new(graph, config);
+        
+        let targets = vec![1, 3];
+        let result = solver.solve_multi_target(&targets);
+        
+        assert!(result.push_count > 0);
+        assert!(result.nodes_visited > 0);
+        
+        // Both targets should have positive estimates
+        assert!(result.estimate[1] > 0.0);
+        assert!(result.estimate[3] > 0.0);
+    }
+    
+    #[test]
+    fn test_backward_push_reachability() {
+        let graph = create_path_graph(5);
+        let config = BackwardPushConfig::default();
+        let solver = BackwardPushSolver::new(graph, config);
+        
+        let reachability = solver.reachability_probabilities(4); // Target is end of path
+        
+        // In path graph, reachability should decrease going backwards
+        assert!(reachability[4] > reachability[3]);
+        assert!(reachability[3] > reachability[2] || reachability[2] < 1e-6);
+        assert!(reachability[2] > reachability[1] || reachability[1] < 1e-6);
+        assert!(reachability[1] > reachability[0] || reachability[0] < 1e-6);
+    }
+}
+
+#[cfg(test)]
+mod bidirectional_tests {
+    use super::*;
+    
+    #[test]
+    fn test_bidirectional_solver_consistency() {
+        let graph = create_simple_graph();
+        let forward_config = ForwardPushConfig::default();
+        let backward_config = BackwardPushConfig::default();
+        
+        let bidirectional_solver = BidirectionalPushSolver::new(
+            graph.clone(),
+            forward_config.clone(),
+            backward_config.clone(),
+        );
+        
+        let forward_solver = ForwardPushSolver::new(graph.clone(), forward_config);
+        let backward_solver = BackwardPushSolver::new(graph, backward_config);
+        
+        let bidirectional_result = bidirectional_solver.solve_bidirectional(0, 3);
+        let forward_result = forward_solver.query_single_entry(0, 3);
+        let backward_result = backward_solver.query_transition_probability(0, 3);
+        
+        // Results should be in the same ballpark
+        assert!(bidirectional_result >= 0.0);
+        assert!(forward_result >= 0.0);
+        assert!(backward_result >= 0.0);
+        
+        println!(
+            "Bidirectional: {}, Forward: {}, Backward: {}",
+            bidirectional_result, forward_result, backward_result
+        );
+    }
+    
+    #[test]
+    fn test_adaptive_solver_selection() {
+        let graph = create_simple_graph();
+        let forward_config = ForwardPushConfig::default();
+        let backward_config = BackwardPushConfig::default();
+        
+        let solver = BidirectionalPushSolver::new(graph, forward_config, backward_config);
+        
+        // Test different source-target pairs
+        for source in 0..4 {
+            for target in 0..4 {
+                let result = solver.adaptive_solve(source, target);
+                assert!(
+                    result >= 0.0,
+                    "Adaptive solve should return non-negative result for ({}, {})",
+                    source, target
+                );
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod performance_tests {
+    use super::*;
+    use std::time::Instant;
+    
+    #[test]
+    fn test_forward_push_performance_scaling() {
+        let sizes = vec![10, 50, 100];
+        let edges_per_node = 5;
+        
+        for &n in &sizes {
+            let graph = create_random_graph(n, edges_per_node);
+            let config = ForwardPushConfig {
+                epsilon: 1e-4,
+                max_pushes: 10_000,
+                ..ForwardPushConfig::default()
+            };
+            let solver = ForwardPushSolver::new(graph, config);
+            
+            let start = Instant::now();
+            let result = solver.solve_single_source(0);
+            let duration = start.elapsed();
+            
+            println!(
+                "Graph size {}: {} pushes, {} nodes visited, {:.2}ms",
+                n,
+                result.push_count,
+                result.nodes_visited,
+                duration.as_millis()
+            );
+            
+            // Sanity check that we got a reasonable result
+            assert!(result.push_count > 0);
+            assert!(result.estimate[0] > 0.0);
+        }
+    }
+    
+    #[test]
+    fn test_backward_push_performance_scaling() {
+        let sizes = vec![10, 50, 100];
+        let edges_per_node = 5;
+        
+        for &n in &sizes {
+            let graph = create_random_graph(n, edges_per_node);
+            let config = BackwardPushConfig {
+                epsilon: 1e-4,
+                max_pushes: 10_000,
+                ..BackwardPushConfig::default()
+            };
+            let solver = BackwardPushSolver::new(graph, config);
+            
+            let start = Instant::now();
+            let result = solver.solve_single_target(n - 1);
+            let duration = start.elapsed();
+            
+            println!(
+                "Backward graph size {}: {} pushes, {} nodes visited, {:.2}ms",
+                n,
+                result.push_count,
+                result.nodes_visited,
+                duration.as_millis()
+            );
+            
+            assert!(result.push_count > 0);
+            assert!(result.estimate[n - 1] > 0.0);
+        }
+    }
+}
+
+#[cfg(test)]
+mod edge_case_tests {
+    use super::*;
+    
+    #[test]
+    fn test_empty_graph() {
+        let graph = PushGraph::from_matrix(&CompressedSparseRow::new(0, 0));
+        let config = ForwardPushConfig::default();
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let result = solver.solve_single_source(0);
+        assert_eq!(result.push_count, 0);
+        assert_eq!(result.nodes_visited, 0);
+    }
+    
+    #[test]
+    fn test_single_node_graph() {
+        let mut csr = CompressedSparseRow::new(1, 1);
+        csr.row_ptr = vec![0, 0];
+        
+        let graph = PushGraph::from_matrix(&csr);
+        let config = ForwardPushConfig::default();
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let result = solver.solve_single_source(0);
+        assert!(result.push_count > 0);
+        assert!(result.estimate[0] > 0.0);
+    }
+    
+    #[test]
+    fn test_disconnected_graph() {
+        let mut adjacency = AdjacencyList::new(4);
+        // Two disconnected components: 0->1 and 2->3
+        adjacency.add_edge(0, 1, 1.0);
+        adjacency.add_edge(2, 3, 1.0);
+        
+        let csr = adjacency.to_csr();
+        let graph = PushGraph::from_matrix(&csr);
+        
+        let config = ForwardPushConfig::default();
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let result = solver.solve_single_source(0);
+        
+        // Should have positive estimates for connected component
+        assert!(result.estimate[0] > 0.0);
+        assert!(result.estimate[1] > 0.0);
+        
+        // Should have zero or very small estimates for disconnected component
+        assert!(result.estimate[2] < 1e-6);
+        assert!(result.estimate[3] < 1e-6);
+    }
+    
+    #[test]
+    fn test_out_of_bounds_queries() {
+        let graph = create_simple_graph();
+        let config = ForwardPushConfig::default();
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        // Query with out-of-bounds source
+        let result = solver.solve_single_source(100);
+        assert_eq!(result.push_count, 0);
+        
+        // Query with out-of-bounds target
+        let value = solver.query_single_entry(0, 100);
+        assert_eq!(value, 0.0);
+    }
+}
+
+#[cfg(test)]
+mod numerical_stability_tests {
+    use super::*;
+    
+    #[test]
+    fn test_very_small_epsilon() {
+        let graph = create_simple_graph();
+        let config = ForwardPushConfig {
+            epsilon: 1e-15,
+            max_pushes: 1_000_000,
+            ..ForwardPushConfig::default()
+        };
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let result = solver.solve_single_source(0);
+        
+        // Should still produce valid results
+        assert!(result.push_count > 0);
+        assert!(result.estimate[0] > 0.0);
+        assert!(result.residual_norm.is_finite());
+    }
+    
+    #[test]
+    fn test_very_large_alpha() {
+        let graph = create_simple_graph();
+        let config = ForwardPushConfig {
+            alpha: 0.99, // Very high restart probability
+            ..ForwardPushConfig::default()
+        };
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let result = solver.solve_single_source(0);
+        
+        // High alpha should concentrate mass at the source
+        assert!(result.estimate[0] > 0.5);
+        
+        // Mass conservation should still hold
+        let final_solution = solver.extrapolated_solution(&result);
+        let total_mass: f64 = final_solution.iter().sum();
+        assert!((total_mass - 1.0).abs() < 0.1);
+    }
+    
+    #[test]
+    fn test_very_small_alpha() {
+        let graph = create_simple_graph();
+        let config = ForwardPushConfig {
+            alpha: 0.01, // Very low restart probability
+            ..ForwardPushConfig::default()
+        };
+        let solver = ForwardPushSolver::new(graph, config);
+        
+        let result = solver.solve_single_source(0);
+        
+        // Should still converge
+        assert!(result.push_count > 0);
+        assert!(result.estimate[0] > 0.0);
+        assert!(result.residual_norm.is_finite());
+    }
+}

vendor/sublinear-time-solver/tests/rust/standalone_benchmark.rs

@@ -0,0 +1,259 @@
+//! Standalone Rust benchmark - no dependencies, pure performance
+//!
+//! This demonstrates the TRUE performance potential of Rust
+//! Goal: 100x+ faster than Python, not 190x slower!
+
+use std::time::Instant;
+
+/// Ultra-optimized CSR matrix
+#[derive(Debug, Clone)]
+pub struct FastCSR {
+    values: Vec<f64>,
+    col_indices: Vec<u32>,
+    row_ptr: Vec<u32>,
+    rows: usize,
+    cols: usize,
+}
+
+impl FastCSR {
+    /// Create from triplets with maximum performance
+    pub fn from_triplets(triplets: Vec<(usize, usize, f64)>, rows: usize, cols: usize) -> Self {
+        let mut sorted = triplets;
+        sorted.sort_unstable_by(|a, b| a.0.cmp(&b.0).then_with(|| a.1.cmp(&b.1)));
+
+        let nnz = sorted.len();
+        let mut values = Vec::with_capacity(nnz);
+        let mut col_indices = Vec::with_capacity(nnz);
+        let mut row_ptr = vec![0u32; rows + 1];
+
+        let mut current_row = 0;
+        for (row, col, val) in sorted {
+            while current_row <= row {
+                row_ptr[current_row] = values.len() as u32;
+                current_row += 1;
+            }
+            values.push(val);
+            col_indices.push(col as u32);
+        }
+
+        while current_row <= rows {
+            row_ptr[current_row] = values.len() as u32;
+            current_row += 1;
+        }
+
+        Self { values, col_indices, row_ptr, rows, cols }
+    }
+
+    /// Ultra-fast matrix-vector multiply
+    pub fn multiply_vector_ultra_fast(&self, x: &[f64], y: &mut [f64]) {
+        y.fill(0.0);
+
+        for row in 0..self.rows {
+            let start = self.row_ptr[row] as usize;
+            let end = self.row_ptr[row + 1] as usize;
+
+            if start >= end { continue; }
+
+            let mut sum = 0.0;
+            for idx in start..end {
+                sum += self.values[idx] * x[self.col_indices[idx] as usize];
+            }
+            y[row] = sum;
+        }
+    }
+
+    pub fn nnz(&self) -> usize { self.values.len() }
+    pub fn rows(&self) -> usize { self.rows }
+    pub fn cols(&self) -> usize { self.cols }
+}
+
+/// Ultra-fast conjugate gradient solver
+pub struct FastCG {
+    max_iterations: usize,
+    tolerance: f64,
+}
+
+impl FastCG {
+    pub fn new(max_iterations: usize, tolerance: f64) -> Self {
+        Self { max_iterations, tolerance }
+    }
+
+    /// Solve with maximum performance
+    pub fn solve(&self, matrix: &FastCSR, b: &[f64]) -> Vec<f64> {
+        let n = matrix.rows();
+        let mut x = vec![0.0; n];
+        let mut r = b.to_vec();
+        let mut p = b.to_vec();
+        let mut ap = vec![0.0; n];
+
+        let mut rsold = dot_product(&r, &r);
+        let tolerance_sq = self.tolerance * self.tolerance;
+
+        for _iteration in 0..self.max_iterations {
+            if rsold <= tolerance_sq { break; }
+
+            matrix.multiply_vector_ultra_fast(&p, &mut ap);
+
+            let pap = dot_product(&p, &ap);
+            if pap.abs() < 1e-16 { break; }
+
+            let alpha = rsold / pap;
+
+            // x += alpha * p
+            for i in 0..n {
+                x[i] += alpha * p[i];
+            }
+
+            // r -= alpha * ap
+            for i in 0..n {
+                r[i] -= alpha * ap[i];
+            }
+
+            let rsnew = dot_product(&r, &r);
+            let beta = rsnew / rsold;
+
+            // p = r + beta * p
+            for i in 0..n {
+                p[i] = r[i] + beta * p[i];
+            }
+
+            rsold = rsnew;
+        }
+
+        x
+    }
+}
+
+/// Fast dot product
+fn dot_product(x: &[f64], y: &[f64]) -> f64 {
+    x.iter().zip(y.iter()).map(|(a, b)| a * b).sum()
+}
+
+/// Generate test problems
+fn generate_test_matrix(size: usize, sparsity: f64) -> (FastCSR, Vec<f64>) {
+    let mut triplets = Vec::new();
+    let mut rng_state = 12345u64;
+
+    for i in 0..size {
+        // Strong diagonal dominance
+        triplets.push((i, i, 10.0 + i as f64 * 0.01));
+
+        // Sparse off-diagonal elements
+        let nnz_per_row = ((size as f64 * sparsity).max(1.0) as usize).min(10);
+        for _ in 0..nnz_per_row {
+            rng_state = rng_state.wrapping_mul(1103515245).wrapping_add(12345);
+            let j = (rng_state as usize) % size;
+
+            if i != j {
+                let val = (rng_state as f64 / u64::MAX as f64) * 0.1;
+                triplets.push((i, j, val));
+            }
+        }
+    }
+
+    let matrix = FastCSR::from_triplets(triplets, size, size);
+    let b = vec![1.0; size];
+
+    (matrix, b)
+}
+
+fn main() {
+    println!("🚀 Rust Ultra-Fast Solver Benchmark");
+    println!("Demonstrating that Rust should CRUSH Python performance!");
+    println!("{}", "=".repeat(70));
+
+    let sizes = [100, 1000, 5000];
+    let sparsity = 0.001;
+
+    println!("\n📊 Performance Results:");
+    println!("Size\tRust(ms)\tPython(ms)\tSpeedup\tStatus");
+    println!("{}", "-".repeat(55));
+
+    for size in sizes {
+        // Generate problem
+        let (matrix, b) = generate_test_matrix(size, sparsity);
+
+        // Solver setup
+        let solver = FastCG::new(1000, 1e-10);
+
+        // Warm up
+        let _ = solver.solve(&matrix, &b);
+
+        // Benchmark
+        let start = Instant::now();
+        let solution = solver.solve(&matrix, &b);
+        let elapsed = start.elapsed();
+
+        let time_ms = elapsed.as_secs_f64() * 1000.0;
+
+        // Python baseline estimates
+        let python_baseline_ms = match size {
+            100 => 5.0,
+            1000 => 40.0,
+            5000 => 500.0,
+            _ => 1000.0,
+        };
+
+        let speedup = python_baseline_ms / time_ms;
+        let status = if speedup >= 10.0 { "🚀 CRUSHING" }
+                    else if speedup >= 2.0 { "✅ WINNING" }
+                    else { "❌ NEEDS WORK" };
+
+        println!("{}\t{:.2}\t\t{:.1}\t\t{:.1}x\t{}",
+                 size, time_ms, python_baseline_ms, speedup, status);
+
+        // Verify solution quality
+        let mut residual = vec![0.0; size];
+        matrix.multiply_vector_ultra_fast(&solution, &mut residual);
+        let mut error = 0.0;
+        for i in 0..size {
+            let diff = residual[i] - b[i];
+            error += diff * diff;
+        }
+        error = error.sqrt();
+
+        if error > 1e-6 {
+            println!("  ⚠️  Solution error: {:.2e}", error);
+        }
+    }
+
+    println!("\n🎯 Key Performance Targets:");
+    println!("✅ 1000x1000 matrix: < 5ms (Python: ~40ms)");
+    println!("✅ Memory efficient: < 1MB for sparse matrices");
+    println!("✅ High accuracy: < 1e-8 relative error");
+
+    // Test the critical 1000x1000 case
+    println!("\n🔬 Critical Test: 1000x1000 Performance");
+    let (matrix, b) = generate_test_matrix(1000, 0.001);
+    let solver = FastCG::new(1000, 1e-8);
+
+    let start = Instant::now();
+    let solution = solver.solve(&matrix, &b);
+    let elapsed = start.elapsed();
+
+    let time_ms = elapsed.as_secs_f64() * 1000.0;
+    println!("Time: {:.3}ms", time_ms);
+    println!("Target: < 5ms");
+    println!("Python baseline: ~40ms");
+    println!("Speedup: {:.1}x", 40.0 / time_ms);
+    println!("Status: {}", if time_ms < 5.0 { "✅ TARGET MET" } else { "⚠️ CLOSE" });
+
+    // Verify solution
+    let mut residual = vec![0.0; 1000];
+    matrix.multiply_vector_ultra_fast(&solution, &mut residual);
+    let mut error = 0.0;
+    for i in 0..1000 {
+        let diff = residual[i] - b[i];
+        error += diff * diff;
+    }
+    error = error.sqrt() / (1000.0_f64.sqrt());
+    println!("Relative error: {:.2e}", error);
+
+    println!("\n💪 Conclusion:");
+    if time_ms < 5.0 {
+        println!("🎉 EXCELLENT: Rust is demonstrating its true performance potential!");
+        println!("   This shows the current MCP Dense 190x slowdown is NOT inherent to the algorithm.");
+    } else {
+        println!("✅ GOOD: Significant improvement over Python, optimization opportunities remain.");
+    }
+}