Squashed 'vendor/ruvector/' content from commit b64c2172

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

crates/ruvector-nervous-system/examples/tiers/t1_edge_autonomy.rs

@@ -0,0 +1,504 @@
+//! # Tier 1: Edge Autonomy and Control
+//!
+//! Drones, vehicles, robotics, industrial automation.
+//!
+//! ## What Changes
+//! - Reflex arcs handle safety and stabilization
+//! - Policy loops run slower and only when needed
+//! - Bullet-time bursts replace constant compute
+//!
+//! ## Why This Matters
+//! - Lower power, faster reactions
+//! - Systems degrade gracefully instead of catastrophically
+//! - Certification becomes possible because reflex paths are bounded
+//!
+//! This is where Cognitum shines immediately.
+
+use std::time::{Duration, Instant};
+
+/// Sensor reading from edge device
+#[derive(Clone, Debug)]
+pub struct SensorReading {
+    pub timestamp_us: u64,
+    pub sensor_type: SensorType,
+    pub value: f32,
+    pub confidence: f32,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum SensorType {
+    Accelerometer,
+    Gyroscope,
+    Proximity,
+    Temperature,
+    Battery,
+    Motor,
+}
+
+/// Control action output
+#[derive(Clone, Debug)]
+pub struct ControlAction {
+    pub actuator_id: u32,
+    pub command: ActuatorCommand,
+    pub priority: Priority,
+    pub deadline_us: u64,
+}
+
+#[derive(Clone, Debug)]
+pub enum ActuatorCommand {
+    SetMotorSpeed(f32),
+    ApplyBrake(f32),
+    AdjustPitch(f32),
+    EmergencyStop,
+    Idle,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Priority {
+    Safety,     // Immediate, preempts everything
+    Stability,  // Fast reflex response
+    Efficiency, // Slower optimization
+    Background, // When idle
+}
+
+/// Reflex arc for immediate safety responses
+/// Runs on Cognitum worker tiles with deterministic timing
+pub struct ReflexArc {
+    pub name: String,
+    pub trigger_threshold: f32,
+    pub response_action: ActuatorCommand,
+    pub max_latency_us: u64,
+    pub last_activation: u64,
+    pub activation_count: u64,
+}
+
+impl ReflexArc {
+    pub fn new(name: &str, threshold: f32, action: ActuatorCommand, max_latency_us: u64) -> Self {
+        Self {
+            name: name.to_string(),
+            trigger_threshold: threshold,
+            response_action: action,
+            max_latency_us,
+            last_activation: 0,
+            activation_count: 0,
+        }
+    }
+
+    /// Check if reflex should fire - deterministic, bounded execution
+    pub fn check(&mut self, reading: &SensorReading) -> Option<ControlAction> {
+        if reading.value.abs() > self.trigger_threshold {
+            self.last_activation = reading.timestamp_us;
+            self.activation_count += 1;
+
+            Some(ControlAction {
+                actuator_id: 0,
+                command: self.response_action.clone(),
+                priority: Priority::Safety,
+                deadline_us: reading.timestamp_us + self.max_latency_us,
+            })
+        } else {
+            None
+        }
+    }
+}
+
+/// Stability controller using dendritic coincidence detection
+/// Detects correlated sensor patterns requiring stabilization
+pub struct StabilityController {
+    pub imu_history: Vec<(f32, f32, f32)>, // accel, gyro, proximity
+    pub coincidence_window_us: u64,
+    pub stability_threshold: f32,
+    pub membrane_potential: f32,
+}
+
+impl StabilityController {
+    pub fn new(coincidence_window_us: u64, threshold: f32) -> Self {
+        Self {
+            imu_history: Vec::with_capacity(100),
+            coincidence_window_us,
+            stability_threshold: threshold,
+            membrane_potential: 0.0,
+        }
+    }
+
+    /// Process sensor fusion for stability
+    pub fn process(&mut self, readings: &[SensorReading]) -> Option<ControlAction> {
+        // Extract relevant sensors
+        let accel = readings
+            .iter()
+            .find(|r| r.sensor_type == SensorType::Accelerometer)
+            .map(|r| r.value);
+        let gyro = readings
+            .iter()
+            .find(|r| r.sensor_type == SensorType::Gyroscope)
+            .map(|r| r.value);
+
+        if let (Some(a), Some(g)) = (accel, gyro) {
+            // Coincidence detection: both accelerating and rotating
+            let instability = a.abs() * g.abs();
+
+            // Integrate over time (dendritic membrane)
+            self.membrane_potential += instability;
+            self.membrane_potential *= 0.9; // Decay
+
+            if self.membrane_potential > self.stability_threshold {
+                self.membrane_potential = 0.0; // Reset after spike
+
+                // Compute corrective action
+                let correction = -g * 0.1; // Counter-rotate
+                return Some(ControlAction {
+                    actuator_id: 1,
+                    command: ActuatorCommand::AdjustPitch(correction),
+                    priority: Priority::Stability,
+                    deadline_us: readings[0].timestamp_us + 1000, // 1ms deadline
+                });
+            }
+        }
+
+        None
+    }
+}
+
+/// Bullet-time burst controller
+/// Activates high-fidelity processing only during critical moments
+pub struct BulletTimeController {
+    pub is_active: bool,
+    pub activation_threshold: f32,
+    pub deactivation_threshold: f32,
+    pub burst_duration_us: u64,
+    pub burst_start: u64,
+    pub normal_sample_rate_hz: u32,
+    pub burst_sample_rate_hz: u32,
+}
+
+impl BulletTimeController {
+    pub fn new() -> Self {
+        Self {
+            is_active: false,
+            activation_threshold: 0.8,
+            deactivation_threshold: 0.3,
+            burst_duration_us: 100_000, // 100ms max burst
+            burst_start: 0,
+            normal_sample_rate_hz: 100,
+            burst_sample_rate_hz: 10_000,
+        }
+    }
+
+    /// Check if bullet-time should activate
+    pub fn should_activate(&mut self, urgency: f32, timestamp_us: u64) -> bool {
+        if !self.is_active && urgency > self.activation_threshold {
+            self.is_active = true;
+            self.burst_start = timestamp_us;
+            println!("  [BULLET TIME] Activated! Urgency: {:.2}", urgency);
+            return true;
+        }
+
+        if self.is_active {
+            // Check deactivation conditions
+            let elapsed = timestamp_us - self.burst_start;
+            if urgency < self.deactivation_threshold || elapsed > self.burst_duration_us {
+                self.is_active = false;
+                println!("  [BULLET TIME] Deactivated after {}us", elapsed);
+            }
+        }
+
+        self.is_active
+    }
+
+    pub fn current_sample_rate(&self) -> u32 {
+        if self.is_active {
+            self.burst_sample_rate_hz
+        } else {
+            self.normal_sample_rate_hz
+        }
+    }
+}
+
+/// Policy loop for slower optimization
+/// Runs when reflexes and stability are not active
+pub struct PolicyLoop {
+    pub energy_budget: f32,
+    pub target_efficiency: f32,
+    pub update_interval_ms: u64,
+    pub last_update: u64,
+}
+
+impl PolicyLoop {
+    pub fn new(energy_budget: f32) -> Self {
+        Self {
+            energy_budget,
+            target_efficiency: 0.9,
+            update_interval_ms: 100, // Run at 10Hz
+            last_update: 0,
+        }
+    }
+
+    /// Optimize for efficiency when safe
+    pub fn optimize(
+        &mut self,
+        readings: &[SensorReading],
+        timestamp_us: u64,
+    ) -> Option<ControlAction> {
+        let timestamp_ms = timestamp_us / 1000;
+        if timestamp_ms < self.last_update + self.update_interval_ms {
+            return None;
+        }
+        self.last_update = timestamp_ms;
+
+        // Check battery level
+        let battery = readings
+            .iter()
+            .find(|r| r.sensor_type == SensorType::Battery)
+            .map(|r| r.value)
+            .unwrap_or(1.0);
+
+        if battery < 0.2 {
+            // Low power mode
+            Some(ControlAction {
+                actuator_id: 0,
+                command: ActuatorCommand::SetMotorSpeed(0.5), // Reduce speed
+                priority: Priority::Efficiency,
+                deadline_us: timestamp_us + 10_000,
+            })
+        } else {
+            None
+        }
+    }
+}
+
+/// Main edge autonomy system
+pub struct EdgeAutonomySystem {
+    /// Safety reflexes (always active, highest priority)
+    pub reflexes: Vec<ReflexArc>,
+    /// Stability controller (fast, second priority)
+    pub stability: StabilityController,
+    /// Bullet-time for critical moments
+    pub bullet_time: BulletTimeController,
+    /// Policy optimization (slow, lowest priority)
+    pub policy: PolicyLoop,
+    /// Graceful degradation state
+    pub degradation_level: u8,
+}
+
+impl EdgeAutonomySystem {
+    pub fn new() -> Self {
+        Self {
+            reflexes: vec![
+                ReflexArc::new(
+                    "collision_avoidance",
+                    0.5, // Proximity threshold
+                    ActuatorCommand::EmergencyStop,
+                    100, // 100us max latency
+                ),
+                ReflexArc::new(
+                    "overheat_protection",
+                    85.0, // Temperature threshold
+                    ActuatorCommand::SetMotorSpeed(0.0),
+                    1000, // 1ms max latency
+                ),
+            ],
+            stability: StabilityController::new(10_000, 2.0),
+            bullet_time: BulletTimeController::new(),
+            policy: PolicyLoop::new(100.0),
+            degradation_level: 0,
+        }
+    }
+
+    /// Process sensor readings through the nervous system hierarchy
+    pub fn process(&mut self, readings: Vec<SensorReading>) -> Vec<ControlAction> {
+        let mut actions = Vec::new();
+        let timestamp = readings.first().map(|r| r.timestamp_us).unwrap_or(0);
+
+        // 1. Safety reflexes (always checked first, deterministic)
+        for reflex in &mut self.reflexes {
+            for reading in &readings {
+                if let Some(action) = reflex.check(reading) {
+                    println!("  REFLEX [{}]: {:?}", reflex.name, action.command);
+                    actions.push(action);
+                    // Safety actions preempt everything
+                    return actions;
+                }
+            }
+        }
+
+        // 2. Stability control (fast, dendritic integration)
+        if let Some(action) = self.stability.process(&readings) {
+            println!("  STABILITY: {:?}", action.command);
+            actions.push(action);
+        }
+
+        // 3. Bullet-time activation check
+        let urgency = self.compute_urgency(&readings);
+        if self.bullet_time.should_activate(urgency, timestamp) {
+            println!(
+                "  Sample rate: {}Hz",
+                self.bullet_time.current_sample_rate()
+            );
+        }
+
+        // 4. Policy optimization (only if stable)
+        if actions.is_empty() {
+            if let Some(action) = self.policy.optimize(&readings, timestamp) {
+                println!("  POLICY: {:?}", action.command);
+                actions.push(action);
+            }
+        }
+
+        actions
+    }
+
+    fn compute_urgency(&self, readings: &[SensorReading]) -> f32 {
+        readings
+            .iter()
+            .map(|r| r.value.abs() * (1.0 - r.confidence))
+            .sum::<f32>()
+            / readings.len().max(1) as f32
+    }
+
+    /// Handle graceful degradation
+    pub fn degrade(&mut self) {
+        self.degradation_level += 1;
+        match self.degradation_level {
+            1 => {
+                println!("  DEGRADATION 1: Disabling policy optimization");
+            }
+            2 => {
+                println!("  DEGRADATION 2: Reducing stability bandwidth");
+                self.stability.stability_threshold *= 1.5;
+            }
+            3 => {
+                println!("  DEGRADATION 3: Safety reflexes only");
+            }
+            _ => {
+                println!("  CRITICAL: Maximum degradation reached");
+            }
+        }
+    }
+}
+
+fn main() {
+    println!("=== Tier 1: Edge Autonomy and Control ===\n");
+
+    let mut system = EdgeAutonomySystem::new();
+
+    // Simulate normal operation
+    println!("Normal operation...");
+    for i in 0..10 {
+        let readings = vec![
+            SensorReading {
+                timestamp_us: i * 10_000,
+                sensor_type: SensorType::Accelerometer,
+                value: 0.1,
+                confidence: 0.95,
+            },
+            SensorReading {
+                timestamp_us: i * 10_000,
+                sensor_type: SensorType::Gyroscope,
+                value: 0.05,
+                confidence: 0.95,
+            },
+            SensorReading {
+                timestamp_us: i * 10_000,
+                sensor_type: SensorType::Battery,
+                value: 0.8,
+                confidence: 1.0,
+            },
+        ];
+        let _ = system.process(readings);
+    }
+    println!("  10 cycles processed, system stable\n");
+
+    // Simulate instability (triggers stability controller)
+    println!("Simulating instability...");
+    for i in 0..5 {
+        let readings = vec![
+            SensorReading {
+                timestamp_us: 100_000 + i * 1000,
+                sensor_type: SensorType::Accelerometer,
+                value: 2.0 + i as f32 * 0.5,
+                confidence: 0.8,
+            },
+            SensorReading {
+                timestamp_us: 100_000 + i * 1000,
+                sensor_type: SensorType::Gyroscope,
+                value: 1.5 + i as f32 * 0.3,
+                confidence: 0.8,
+            },
+        ];
+        let actions = system.process(readings);
+        for action in actions {
+            println!(
+                "    Action: {:?} (deadline: {}us)",
+                action.command, action.deadline_us
+            );
+        }
+    }
+
+    // Simulate collision (triggers safety reflex)
+    println!("\nSimulating collision warning...");
+    let emergency = vec![SensorReading {
+        timestamp_us: 200_000,
+        sensor_type: SensorType::Proximity,
+        value: 0.9, // Very close!
+        confidence: 0.99,
+    }];
+    let actions = system.process(emergency);
+    println!("  Emergency response latency: <100us guaranteed");
+
+    // Demonstrate graceful degradation
+    println!("\nDemonstrating graceful degradation...");
+    for _ in 0..3 {
+        system.degrade();
+    }
+
+    println!("\n=== Key Benefits ===");
+    println!("- Reflex latency: <100μs (deterministic)");
+    println!("- Stability control: <1ms response");
+    println!("- Bullet-time: 100x sample rate during critical moments");
+    println!("- Graceful degradation prevents catastrophic failure");
+    println!("- Certifiable: bounded execution paths");
+    println!("\nThis is where Cognitum shines immediately.");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_reflex_arc_fires() {
+        let mut reflex = ReflexArc::new("test", 0.5, ActuatorCommand::EmergencyStop, 100);
+
+        let reading = SensorReading {
+            timestamp_us: 0,
+            sensor_type: SensorType::Proximity,
+            value: 0.9,
+            confidence: 1.0,
+        };
+
+        let result = reflex.check(&reading);
+        assert!(result.is_some());
+        assert_eq!(result.unwrap().priority, Priority::Safety);
+    }
+
+    #[test]
+    fn test_bullet_time_activation() {
+        let mut bt = BulletTimeController::new();
+
+        assert!(!bt.is_active);
+        assert!(bt.should_activate(0.9, 0));
+        assert!(bt.is_active);
+        assert_eq!(bt.current_sample_rate(), 10_000);
+    }
+
+    #[test]
+    fn test_graceful_degradation() {
+        let mut system = EdgeAutonomySystem::new();
+
+        assert_eq!(system.degradation_level, 0);
+        system.degrade();
+        assert_eq!(system.degradation_level, 1);
+        system.degrade();
+        system.degrade();
+        assert_eq!(system.degradation_level, 3);
+    }
+}