d803bfe2b1
git-subtree-dir: vendor/ruvector git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900
703 lines
21 KiB
Rust
703 lines
21 KiB
Rust
//! # Tier 3: Synthetic Nervous Systems for Environments
|
|
//!
|
|
//! Buildings, factories, cities.
|
|
//!
|
|
//! ## What Changes
|
|
//! - Infrastructure becomes a sensing fabric
|
|
//! - Reflexes manage local events
|
|
//! - Policy emerges from patterns, not rules
|
|
//!
|
|
//! ## Why This Matters
|
|
//! - Environments respond like organisms
|
|
//! - Energy, safety, and flow self-regulate
|
|
//! - Central planning gives way to distributed intelligence
|
|
//!
|
|
//! This is exotic but inevitable.
|
|
|
|
use std::collections::{HashMap, VecDeque};
|
|
use std::f32::consts::PI;
|
|
|
|
/// A location in the environment
|
|
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
|
|
pub struct LocationId(pub String);
|
|
|
|
/// A zone grouping multiple locations
|
|
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
|
|
pub struct ZoneId(pub String);
|
|
|
|
/// Environmental sensor reading
|
|
#[derive(Clone, Debug)]
|
|
pub struct EnvironmentReading {
|
|
pub timestamp: u64,
|
|
pub location: LocationId,
|
|
pub sensor_type: EnvironmentSensor,
|
|
pub value: f32,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
|
pub enum EnvironmentSensor {
|
|
Temperature,
|
|
Humidity,
|
|
Light,
|
|
Occupancy,
|
|
AirQuality,
|
|
Noise,
|
|
Motion,
|
|
Energy,
|
|
Water,
|
|
}
|
|
|
|
/// Environmental actuator command
|
|
#[derive(Clone, Debug)]
|
|
pub struct EnvironmentAction {
|
|
pub location: LocationId,
|
|
pub actuator: EnvironmentActuator,
|
|
pub value: f32,
|
|
pub priority: u8,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum EnvironmentActuator {
|
|
HVAC { mode: HVACMode },
|
|
Lighting { brightness: f32 },
|
|
Ventilation { flow_rate: f32 },
|
|
Shading { position: f32 },
|
|
DoorLock { locked: bool },
|
|
Alarm { active: bool },
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum HVACMode {
|
|
Off,
|
|
Heating(f32),
|
|
Cooling(f32),
|
|
Ventilation,
|
|
}
|
|
|
|
/// Local reflex for immediate environmental response
|
|
pub struct LocalEnvironmentReflex {
|
|
pub location: LocationId,
|
|
pub sensor_type: EnvironmentSensor,
|
|
pub threshold_low: f32,
|
|
pub threshold_high: f32,
|
|
pub action_low: EnvironmentActuator,
|
|
pub action_high: EnvironmentActuator,
|
|
pub hysteresis: f32,
|
|
pub last_state: i8, // -1 = below, 0 = normal, 1 = above
|
|
}
|
|
|
|
impl LocalEnvironmentReflex {
|
|
pub fn new(
|
|
location: LocationId,
|
|
sensor_type: EnvironmentSensor,
|
|
threshold_low: f32,
|
|
threshold_high: f32,
|
|
action_low: EnvironmentActuator,
|
|
action_high: EnvironmentActuator,
|
|
) -> Self {
|
|
Self {
|
|
location,
|
|
sensor_type,
|
|
threshold_low,
|
|
threshold_high,
|
|
action_low,
|
|
action_high,
|
|
hysteresis: 0.5,
|
|
last_state: 0,
|
|
}
|
|
}
|
|
|
|
/// Check if reflex should fire
|
|
pub fn check(&mut self, reading: &EnvironmentReading) -> Option<EnvironmentAction> {
|
|
if reading.location != self.location || reading.sensor_type != self.sensor_type {
|
|
return None;
|
|
}
|
|
|
|
// Apply hysteresis
|
|
let effective_low = if self.last_state == -1 {
|
|
self.threshold_low + self.hysteresis
|
|
} else {
|
|
self.threshold_low
|
|
};
|
|
|
|
let effective_high = if self.last_state == 1 {
|
|
self.threshold_high - self.hysteresis
|
|
} else {
|
|
self.threshold_high
|
|
};
|
|
|
|
if reading.value < effective_low && self.last_state != -1 {
|
|
self.last_state = -1;
|
|
Some(EnvironmentAction {
|
|
location: self.location.clone(),
|
|
actuator: self.action_low.clone(),
|
|
value: reading.value,
|
|
priority: 1,
|
|
})
|
|
} else if reading.value > effective_high && self.last_state != 1 {
|
|
self.last_state = 1;
|
|
Some(EnvironmentAction {
|
|
location: self.location.clone(),
|
|
actuator: self.action_high.clone(),
|
|
value: reading.value,
|
|
priority: 1,
|
|
})
|
|
} else if reading.value >= effective_low && reading.value <= effective_high {
|
|
self.last_state = 0;
|
|
None
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Zone-level homeostasis controller
|
|
pub struct ZoneHomeostasis {
|
|
pub zone: ZoneId,
|
|
pub locations: Vec<LocationId>,
|
|
pub target_temperature: f32,
|
|
pub target_humidity: f32,
|
|
pub target_light: f32,
|
|
pub adaptation_rate: f32,
|
|
/// Learned occupancy pattern (24 hours)
|
|
pub occupancy_pattern: [f32; 24],
|
|
pub learning_enabled: bool,
|
|
}
|
|
|
|
impl ZoneHomeostasis {
|
|
pub fn new(zone: ZoneId, locations: Vec<LocationId>) -> Self {
|
|
Self {
|
|
zone,
|
|
locations,
|
|
target_temperature: 22.0,
|
|
target_humidity: 50.0,
|
|
target_light: 500.0,
|
|
adaptation_rate: 0.1,
|
|
occupancy_pattern: [0.0; 24],
|
|
learning_enabled: true,
|
|
}
|
|
}
|
|
|
|
/// Learn from occupancy patterns
|
|
pub fn learn_occupancy(&mut self, hour: usize, occupancy: f32) {
|
|
if self.learning_enabled && hour < 24 {
|
|
self.occupancy_pattern[hour] = self.occupancy_pattern[hour]
|
|
* (1.0 - self.adaptation_rate)
|
|
+ occupancy * self.adaptation_rate;
|
|
}
|
|
}
|
|
|
|
/// Predict occupancy for pre-conditioning
|
|
pub fn predict_occupancy(&self, hour: usize) -> f32 {
|
|
if hour < 24 {
|
|
self.occupancy_pattern[hour]
|
|
} else {
|
|
0.0
|
|
}
|
|
}
|
|
|
|
/// Compute zone-level action based on aggregate readings
|
|
pub fn compute_action(
|
|
&self,
|
|
readings: &[EnvironmentReading],
|
|
hour: usize,
|
|
) -> Vec<EnvironmentAction> {
|
|
let mut actions = Vec::new();
|
|
|
|
// Filter readings for this zone
|
|
let zone_readings: Vec<_> = readings
|
|
.iter()
|
|
.filter(|r| self.locations.contains(&r.location))
|
|
.collect();
|
|
|
|
if zone_readings.is_empty() {
|
|
return actions;
|
|
}
|
|
|
|
// Average temperature
|
|
let temp_readings: Vec<_> = zone_readings
|
|
.iter()
|
|
.filter(|r| r.sensor_type == EnvironmentSensor::Temperature)
|
|
.collect();
|
|
|
|
if !temp_readings.is_empty() {
|
|
let avg_temp: f32 =
|
|
temp_readings.iter().map(|r| r.value).sum::<f32>() / temp_readings.len() as f32;
|
|
|
|
// Adjust target based on predicted occupancy
|
|
let predicted_occ = self.predict_occupancy(hour);
|
|
let effective_target = if predicted_occ > 0.5 {
|
|
self.target_temperature
|
|
} else {
|
|
// Setback when unoccupied
|
|
self.target_temperature - 2.0
|
|
};
|
|
|
|
let temp_error = avg_temp - effective_target;
|
|
|
|
if temp_error.abs() > 1.0 {
|
|
let mode = if temp_error > 0.0 {
|
|
HVACMode::Cooling(temp_error.abs().min(5.0))
|
|
} else {
|
|
HVACMode::Heating(temp_error.abs().min(5.0))
|
|
};
|
|
|
|
for loc in &self.locations {
|
|
actions.push(EnvironmentAction {
|
|
location: loc.clone(),
|
|
actuator: EnvironmentActuator::HVAC { mode: mode.clone() },
|
|
value: temp_error,
|
|
priority: 2,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// Light based on occupancy
|
|
let occupancy_readings: Vec<_> = zone_readings
|
|
.iter()
|
|
.filter(|r| r.sensor_type == EnvironmentSensor::Occupancy)
|
|
.collect();
|
|
|
|
if !occupancy_readings.is_empty() {
|
|
let occupied = occupancy_readings.iter().any(|r| r.value > 0.5);
|
|
|
|
for loc in &self.locations {
|
|
let brightness = if occupied { 1.0 } else { 0.1 };
|
|
actions.push(EnvironmentAction {
|
|
location: loc.clone(),
|
|
actuator: EnvironmentActuator::Lighting { brightness },
|
|
value: brightness,
|
|
priority: 3,
|
|
});
|
|
}
|
|
}
|
|
|
|
actions
|
|
}
|
|
}
|
|
|
|
/// Global workspace for environment-wide coordination
|
|
pub struct EnvironmentWorkspace {
|
|
pub capacity: usize,
|
|
pub items: VecDeque<WorkspaceItem>,
|
|
pub policies: Vec<EmergentPolicy>,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct WorkspaceItem {
|
|
pub zone: ZoneId,
|
|
pub observation: String,
|
|
pub salience: f32,
|
|
pub timestamp: u64,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct EmergentPolicy {
|
|
pub name: String,
|
|
pub trigger_pattern: String,
|
|
pub action_pattern: String,
|
|
pub confidence: f32,
|
|
pub occurrences: u64,
|
|
}
|
|
|
|
impl EnvironmentWorkspace {
|
|
pub fn new(capacity: usize) -> Self {
|
|
Self {
|
|
capacity,
|
|
items: VecDeque::new(),
|
|
policies: Vec::new(),
|
|
}
|
|
}
|
|
|
|
/// Broadcast observation to workspace
|
|
pub fn broadcast(&mut self, item: WorkspaceItem) {
|
|
if self.items.len() >= self.capacity {
|
|
// Remove lowest salience
|
|
if let Some(min_idx) = self
|
|
.items
|
|
.iter()
|
|
.enumerate()
|
|
.min_by(|(_, a), (_, b)| a.salience.partial_cmp(&b.salience).unwrap())
|
|
.map(|(i, _)| i)
|
|
{
|
|
self.items.remove(min_idx);
|
|
}
|
|
}
|
|
self.items.push_back(item);
|
|
}
|
|
|
|
/// Detect emergent patterns
|
|
pub fn detect_patterns(&mut self) -> Option<EmergentPolicy> {
|
|
// Look for repeated sequences in workspace
|
|
let observations: Vec<_> = self.items.iter().map(|i| i.observation.clone()).collect();
|
|
|
|
if observations.len() < 3 {
|
|
return None;
|
|
}
|
|
|
|
// Simple pattern: if same observation repeats
|
|
let last = observations.last()?;
|
|
let count = observations.iter().filter(|o| *o == last).count();
|
|
|
|
if count >= 3 {
|
|
let policy = EmergentPolicy {
|
|
name: format!("Pattern_{}", self.policies.len()),
|
|
trigger_pattern: last.clone(),
|
|
action_pattern: "coordinate_response".to_string(),
|
|
confidence: count as f32 / observations.len() as f32,
|
|
occurrences: 1,
|
|
};
|
|
|
|
// Check if already known
|
|
if !self
|
|
.policies
|
|
.iter()
|
|
.any(|p| p.trigger_pattern == last.clone())
|
|
{
|
|
self.policies.push(policy.clone());
|
|
return Some(policy);
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
}
|
|
|
|
/// Complete synthetic nervous system for an environment
|
|
pub struct SyntheticNervousSystem {
|
|
pub name: String,
|
|
/// Local reflexes (fast, location-specific)
|
|
pub reflexes: Vec<LocalEnvironmentReflex>,
|
|
/// Zone homeostasis (medium, zone-level)
|
|
pub zones: HashMap<ZoneId, ZoneHomeostasis>,
|
|
/// Global workspace (slow, environment-wide)
|
|
pub workspace: EnvironmentWorkspace,
|
|
/// Current time
|
|
pub timestamp: u64,
|
|
/// Action history
|
|
pub action_log: Vec<(u64, EnvironmentAction)>,
|
|
}
|
|
|
|
impl SyntheticNervousSystem {
|
|
pub fn new(name: &str) -> Self {
|
|
Self {
|
|
name: name.to_string(),
|
|
reflexes: Vec::new(),
|
|
zones: HashMap::new(),
|
|
workspace: EnvironmentWorkspace::new(7),
|
|
timestamp: 0,
|
|
action_log: Vec::new(),
|
|
}
|
|
}
|
|
|
|
/// Add a zone
|
|
pub fn add_zone(&mut self, zone_id: &str, locations: Vec<&str>) {
|
|
let zone = ZoneId(zone_id.to_string());
|
|
let locs: Vec<_> = locations
|
|
.iter()
|
|
.map(|l| LocationId(l.to_string()))
|
|
.collect();
|
|
|
|
self.zones
|
|
.insert(zone.clone(), ZoneHomeostasis::new(zone, locs));
|
|
}
|
|
|
|
/// Add a local reflex
|
|
pub fn add_reflex(&mut self, reflex: LocalEnvironmentReflex) {
|
|
self.reflexes.push(reflex);
|
|
}
|
|
|
|
/// Process sensor readings through the nervous system
|
|
pub fn process(&mut self, readings: Vec<EnvironmentReading>) -> Vec<EnvironmentAction> {
|
|
self.timestamp += 1;
|
|
let hour = ((self.timestamp / 60) % 24) as usize;
|
|
|
|
let mut actions = Vec::new();
|
|
|
|
// 1. Local reflexes (fastest)
|
|
for reflex in &mut self.reflexes {
|
|
for reading in &readings {
|
|
if let Some(action) = reflex.check(reading) {
|
|
actions.push(action);
|
|
}
|
|
}
|
|
}
|
|
|
|
// If reflexes fired, skip higher levels
|
|
if !actions.is_empty() {
|
|
for action in &actions {
|
|
self.action_log.push((self.timestamp, action.clone()));
|
|
}
|
|
return actions;
|
|
}
|
|
|
|
// 2. Zone homeostasis (medium)
|
|
for (_, zone) in &mut self.zones {
|
|
// Learn occupancy
|
|
for reading in &readings {
|
|
if reading.sensor_type == EnvironmentSensor::Occupancy
|
|
&& zone.locations.contains(&reading.location)
|
|
{
|
|
zone.learn_occupancy(hour, reading.value);
|
|
}
|
|
}
|
|
|
|
// Compute zone actions
|
|
let zone_actions = zone.compute_action(&readings, hour);
|
|
actions.extend(zone_actions);
|
|
}
|
|
|
|
// 3. Global workspace (slowest, pattern detection)
|
|
for reading in &readings {
|
|
if reading.value > 0.8 || reading.value < 0.2 {
|
|
// Significant observation
|
|
self.workspace.broadcast(WorkspaceItem {
|
|
zone: ZoneId("global".to_string()),
|
|
observation: format!(
|
|
"{:?}_{}",
|
|
reading.sensor_type,
|
|
if reading.value > 0.5 { "high" } else { "low" }
|
|
),
|
|
salience: reading.value.abs(),
|
|
timestamp: self.timestamp,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Detect emergent patterns
|
|
if let Some(policy) = self.workspace.detect_patterns() {
|
|
println!(
|
|
" [EMERGENT] New policy: {} (confidence: {:.2})",
|
|
policy.name, policy.confidence
|
|
);
|
|
}
|
|
|
|
for action in &actions {
|
|
self.action_log.push((self.timestamp, action.clone()));
|
|
}
|
|
|
|
actions
|
|
}
|
|
|
|
/// Get system status
|
|
pub fn status(&self) -> EnvironmentStatus {
|
|
let learned_patterns = self.workspace.policies.len();
|
|
|
|
let zone_states: HashMap<_, _> = self
|
|
.zones
|
|
.iter()
|
|
.map(|(id, zone)| {
|
|
(
|
|
id.clone(),
|
|
ZoneState {
|
|
target_temp: zone.target_temperature,
|
|
occupancy_learned: zone.occupancy_pattern.iter().sum::<f32>() > 0.0,
|
|
},
|
|
)
|
|
})
|
|
.collect();
|
|
|
|
EnvironmentStatus {
|
|
timestamp: self.timestamp,
|
|
active_reflexes: self.reflexes.len(),
|
|
zones: self.zones.len(),
|
|
learned_patterns,
|
|
zone_states,
|
|
recent_actions: self.action_log.len(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct EnvironmentStatus {
|
|
pub timestamp: u64,
|
|
pub active_reflexes: usize,
|
|
pub zones: usize,
|
|
pub learned_patterns: usize,
|
|
pub zone_states: HashMap<ZoneId, ZoneState>,
|
|
pub recent_actions: usize,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct ZoneState {
|
|
pub target_temp: f32,
|
|
pub occupancy_learned: bool,
|
|
}
|
|
|
|
fn main() {
|
|
println!("=== Tier 3: Synthetic Nervous Systems for Environments ===\n");
|
|
|
|
let mut building = SyntheticNervousSystem::new("Smart Building");
|
|
|
|
// Add zones
|
|
building.add_zone("office_north", vec!["room_101", "room_102", "room_103"]);
|
|
building.add_zone("office_south", vec!["room_201", "room_202"]);
|
|
building.add_zone("lobby", vec!["entrance", "reception"]);
|
|
|
|
// Add local reflexes
|
|
building.add_reflex(LocalEnvironmentReflex::new(
|
|
LocationId("room_101".to_string()),
|
|
EnvironmentSensor::Temperature,
|
|
18.0,
|
|
28.0,
|
|
EnvironmentActuator::HVAC {
|
|
mode: HVACMode::Heating(3.0),
|
|
},
|
|
EnvironmentActuator::HVAC {
|
|
mode: HVACMode::Cooling(3.0),
|
|
},
|
|
));
|
|
|
|
building.add_reflex(LocalEnvironmentReflex::new(
|
|
LocationId("entrance".to_string()),
|
|
EnvironmentSensor::Motion,
|
|
0.0,
|
|
0.5,
|
|
EnvironmentActuator::Lighting { brightness: 0.2 },
|
|
EnvironmentActuator::Lighting { brightness: 1.0 },
|
|
));
|
|
|
|
println!("Building initialized:");
|
|
let status = building.status();
|
|
println!(" Zones: {}", status.zones);
|
|
println!(" Active reflexes: {}", status.active_reflexes);
|
|
|
|
// Simulate a day
|
|
println!("\nSimulating 24 hours...");
|
|
for hour in 0..24 {
|
|
for minute in 0..60 {
|
|
let timestamp = hour * 60 + minute;
|
|
|
|
// Generate readings based on time of day
|
|
let occupied = (hour >= 8 && hour <= 18) && (minute % 5 == 0);
|
|
let temp = 20.0 + 4.0 * ((hour as f32 / 24.0) * PI).sin();
|
|
|
|
let readings = vec![
|
|
EnvironmentReading {
|
|
timestamp,
|
|
location: LocationId("room_101".to_string()),
|
|
sensor_type: EnvironmentSensor::Temperature,
|
|
value: temp,
|
|
},
|
|
EnvironmentReading {
|
|
timestamp,
|
|
location: LocationId("room_101".to_string()),
|
|
sensor_type: EnvironmentSensor::Occupancy,
|
|
value: if occupied { 1.0 } else { 0.0 },
|
|
},
|
|
EnvironmentReading {
|
|
timestamp,
|
|
location: LocationId("entrance".to_string()),
|
|
sensor_type: EnvironmentSensor::Motion,
|
|
value: if occupied && minute % 15 == 0 {
|
|
1.0
|
|
} else {
|
|
0.0
|
|
},
|
|
},
|
|
];
|
|
|
|
let actions = building.process(readings);
|
|
|
|
if hour % 4 == 0 && minute == 0 {
|
|
println!(
|
|
" Hour {}: {} actions, temp={:.1}°C, occupied={}",
|
|
hour,
|
|
actions.len(),
|
|
temp,
|
|
occupied
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Summary
|
|
let status = building.status();
|
|
println!("\n=== End of Day Status ===");
|
|
println!(" Total actions taken: {}", status.recent_actions);
|
|
println!(" Emergent policies learned: {}", status.learned_patterns);
|
|
println!(" Zone states:");
|
|
for (zone, state) in &status.zone_states {
|
|
println!(
|
|
" {:?}: target={:.1}°C, occupancy_learned={}",
|
|
zone.0, state.target_temp, state.occupancy_learned
|
|
);
|
|
}
|
|
|
|
println!("\n=== Key Benefits ===");
|
|
println!("- Infrastructure becomes a sensing fabric");
|
|
println!("- Local reflexes handle immediate events");
|
|
println!("- Zone homeostasis manages comfort autonomously");
|
|
println!("- Policies emerge from patterns, not rules");
|
|
println!("- Energy, safety, and flow self-regulate");
|
|
println!("\nThis is exotic but inevitable.");
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_local_reflex() {
|
|
let mut reflex = LocalEnvironmentReflex::new(
|
|
LocationId("test".to_string()),
|
|
EnvironmentSensor::Temperature,
|
|
18.0,
|
|
28.0,
|
|
EnvironmentActuator::HVAC {
|
|
mode: HVACMode::Heating(1.0),
|
|
},
|
|
EnvironmentActuator::HVAC {
|
|
mode: HVACMode::Cooling(1.0),
|
|
},
|
|
);
|
|
|
|
// Cold triggers heating
|
|
let reading = EnvironmentReading {
|
|
timestamp: 0,
|
|
location: LocationId("test".to_string()),
|
|
sensor_type: EnvironmentSensor::Temperature,
|
|
value: 15.0,
|
|
};
|
|
|
|
let action = reflex.check(&reading);
|
|
assert!(action.is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn test_zone_homeostasis() {
|
|
let mut zone = ZoneHomeostasis::new(
|
|
ZoneId("test".to_string()),
|
|
vec![LocationId("room1".to_string())],
|
|
);
|
|
|
|
// Learn occupancy pattern
|
|
for _ in 0..10 {
|
|
zone.learn_occupancy(10, 1.0); // 10am occupied
|
|
zone.learn_occupancy(22, 0.0); // 10pm empty
|
|
}
|
|
|
|
assert!(zone.predict_occupancy(10) > 0.5);
|
|
assert!(zone.predict_occupancy(22) < 0.5);
|
|
}
|
|
|
|
#[test]
|
|
fn test_workspace_patterns() {
|
|
let mut workspace = EnvironmentWorkspace::new(7);
|
|
|
|
// Add repeated observation
|
|
for _ in 0..5 {
|
|
workspace.broadcast(WorkspaceItem {
|
|
zone: ZoneId("test".to_string()),
|
|
observation: "Temperature_high".to_string(),
|
|
salience: 1.0,
|
|
timestamp: 0,
|
|
});
|
|
}
|
|
|
|
let pattern = workspace.detect_patterns();
|
|
assert!(pattern.is_some());
|
|
}
|
|
}
|