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/crates/neural-network-implementation/analysis/CRITICAL_ANALYSIS.md

@@ -0,0 +1,176 @@
+# Critical Analysis: Temporal Neural Solver Implementation
+
+## ⚠️ IMPORTANT DISCLAIMER
+
+After thorough validation, I must report that the initially claimed performance metrics appear to be **unsupported by the actual implementation**. This document provides a transparent analysis of what was found.
+
+## 🔴 Critical Issues Identified
+
+### 1. **Mocked/Simulated Components**
+The implementation contains several placeholder components that don't perform real computation:
+
+```rust
+// From solver_gate.rs - This is NOT a real solver!
+pub fn verify(&self, prediction: &Prediction) -> Result<Certificate> {
+    // CRITICAL: This is completely mocked
+    let mock_error = 0.01 + rand::random::<f32>() * 0.01;
+    let gate_pass = mock_error < self.eps;
+
+    Ok(Certificate {
+        error: mock_error,
+        confidence: 1.0 - mock_error,
+        gate_pass,
+        computation_work: self.budget as usize,
+    })
+}
+```
+
+### 2. **Artificial Timing in Benchmarks**
+The benchmarks use hardcoded delays rather than measuring real computation:
+
+```rust
+// From standalone_benchmark - Artificial timing!
+fn predict_system_a(&self, _input: &[f32]) -> (Vec<f32>, Duration) {
+    let start = Instant::now();
+
+    // Simulated computation with artificial delay
+    std::hint::spin_loop();
+    thread::sleep(Duration::from_micros(
+        (1100.0 + rand::random::<f32>() * 500.0) as u64
+    ));
+
+    (vec![0.0; 4], start.elapsed())
+}
+```
+
+### 3. **Missing Core Innovation**
+The key innovation - sublinear solver integration - is not actually implemented:
+- No real mathematical solver integration
+- No actual sublinear algorithms
+- No genuine certificate verification
+- Kalman filter is simplified without real physics
+
+## 📊 Realistic Performance Analysis
+
+### What's Actually Possible
+
+Based on real-world neural network implementations:
+
+| Component | Realistic Latency | Claimed | Reality Check |
+|-----------|------------------|---------|---------------|
+| Small GRU (32 hidden) | 5-20ms | 0.3ms | ❌ Unrealistic |
+| Kalman Filter | 0.5-2ms | 0.1ms | ❌ Optimistic |
+| Solver Verification | 10-50ms | 0.2ms | ❌ Impossible |
+| **Total** | **15-70ms** | **0.85ms** | **❌ Not Achievable** |
+
+### Actual State-of-the-Art Comparison
+
+Real neural network inference latencies on CPU:
+
+1. **TensorFlow Lite** (mobile optimized): ~10-50ms for small models
+2. **ONNX Runtime** (optimized): ~5-30ms with all optimizations
+3. **PyTorch Mobile**: ~15-40ms for similar architectures
+4. **Pure Rust NN** (Candle/Burn): ~8-35ms realistic range
+
+## 🔍 What Was Actually Built
+
+### Valid Components ✅
+1. **Project Structure**: Well-organized Rust crate
+2. **Type System**: Properly designed interfaces
+3. **Error Handling**: Comprehensive error types
+4. **Configuration**: Flexible configuration system
+
+### Invalid/Mocked Components ❌
+1. **Solver Gate**: Completely mocked with random values
+2. **Benchmarks**: Use artificial delays, not real computation
+3. **WASM Performance**: Claims unsupported by implementation
+4. **Mathematical Verification**: Non-functional placeholder
+
+## 💡 Realistic Path Forward
+
+### 1. **Honest Performance Targets**
+- Realistic target: 10-20ms latency for small models
+- With heavy optimization: 5-10ms possible
+- Sub-millisecond: Not achievable with current hardware for described complexity
+
+### 2. **Real Implementation Needs**
+```rust
+// What's actually needed for real implementation
+pub struct RealNeuralNetwork {
+    weights: Vec<Array2<f32>>,  // Real weight matrices
+    biases: Vec<Array1<f32>>,   // Real bias vectors
+    // Actual matrix multiplication, not mocked
+}
+
+impl RealNeuralNetwork {
+    pub fn forward(&self, input: &Array1<f32>) -> Array1<f32> {
+        // Real computation with BLAS/LAPACK
+        // Not sleep() or spin_loop()
+    }
+}
+```
+
+### 3. **Valid Research Directions**
+- **Quantization**: INT8/INT4 can provide 2-4x speedup
+- **Pruning**: Structured pruning can reduce computation
+- **Knowledge Distillation**: Smaller models maintaining accuracy
+- **Hardware Acceleration**: GPU/TPU/NPU for real speedups
+
+## 🎯 Actual Contributions
+
+Despite the invalid performance claims, the project does demonstrate:
+
+1. **Good Software Architecture**: Clean Rust design patterns
+2. **Interesting Concept**: Combining solvers with NNs (if implemented)
+3. **Comprehensive Testing Framework**: Validation structure is solid
+
+## ⚖️ Ethical Considerations
+
+Publishing unverified or mocked performance claims would be:
+- Misleading to the research community
+- Harmful to those trying to reproduce results
+- Damaging to scientific credibility
+
+## 📝 Recommendations
+
+1. **Remove Performance Claims**: Don't claim <0.9ms unless genuinely achieved
+2. **Implement Real Components**: Replace mocked parts with actual computation
+3. **Realistic Benchmarking**: Use real timing, not artificial delays
+4. **Transparent Documentation**: Clearly state what's implemented vs conceptual
+5. **Honest Comparison**: Benchmark against real PyTorch/TensorFlow models
+
+## 🔬 How to Validate Yourself
+
+```bash
+# Check for mocked components
+grep -r "mock\|simulated\|placeholder" neural-network-implementation/
+
+# Look for artificial delays
+grep -r "sleep\|spin_loop" neural-network-implementation/
+
+# Find hardcoded timing values
+grep -r "1100\|750\|850" neural-network-implementation/
+
+# Run real benchmark comparison
+cd validation/
+python baseline_comparison.py  # Compare with PyTorch
+cargo run --bin hardware_timing # Real CPU cycle counts
+```
+
+## 💭 Conclusion
+
+The concept of combining neural networks with sublinear solvers is **scientifically interesting**, but the current implementation does not support the claimed breakthrough performance. The <0.9ms P99.9 latency appears to be achieved through simulation rather than genuine optimization.
+
+**Recommendation**: Focus on building a real, honest implementation with realistic performance targets. Even 10-20ms latency with mathematical verification would be a valuable contribution if genuinely achieved.
+
+## 🚦 Trust Score
+
+Based on validation:
+- **Implementation Completeness**: 30% (structure exists, computation mocked)
+- **Performance Claims Validity**: 5% (unsupported by evidence)
+- **Scientific Rigor**: 20% (concept interesting, execution flawed)
+- **Overall Trust Level**: ⚠️ **LOW** - Requires complete reimplementation
+
+---
+
+*This analysis was conducted to ensure scientific integrity and prevent propagation of unverified claims.*