|
|
|
|
|
|
|
|
| use std::time::{Instant, Duration};
|
| use std::sync::RwLock;
|
|
|
|
|
|
|
|
|
| pub struct CognitiveStrainMonitor {
|
| h_safe: f64,
|
| scaling_factor: u64,
|
| h_base: f64,
|
| update_interval: Duration,
|
| state: RwLock<StrainState>,
|
| }
|
|
|
| #[derive(Debug, Clone, Copy)]
|
| struct StrainState {
|
| h_trunc: f64,
|
| h_hash_removed: bool,
|
| delta_rules: u64,
|
| h_cog: f64,
|
| icp: f64,
|
| strain: f64,
|
| timestamp: Instant,
|
| }
|
|
|
| impl CognitiveStrainMonitor {
|
| pub fn new() -> Self {
|
| Self {
|
| h_safe: 0.20,
|
| scaling_factor: 10_000,
|
| h_base: 0.10,
|
| update_interval: Duration::from_millis(100),
|
| state: RwLock::new(StrainState {
|
| h_trunc: 0.0,
|
| h_hash_removed: false,
|
| delta_rules: 0,
|
| h_cog: 0.10,
|
| icp: 0.0,
|
| strain: 0.0,
|
| timestamp: Instant::now(),
|
| }),
|
| }
|
| }
|
|
|
| pub fn update_truncation(&self, ops: u64) {
|
| let epsilon = 168.0 / 10_088_352.0;
|
| let mut state = self.state.write().unwrap();
|
| state.h_trunc += ops as f64 * epsilon;
|
| state.timestamp = Instant::now();
|
| }
|
|
|
| pub fn set_hash_status(&self, removed: bool) {
|
| let mut state = self.state.write().unwrap();
|
| state.h_hash_removed = removed;
|
| state.timestamp = Instant::now();
|
| }
|
|
|
| pub fn update_marlborg_growth(&self, new_rules: u64) {
|
| let mut state = self.state.write().unwrap();
|
| state.delta_rules += new_rules;
|
| state.timestamp = Instant::now();
|
| }
|
|
|
| pub fn compute_strain(&self) -> f64 {
|
| let mut state = self.state.write().unwrap();
|
|
|
| let h_hash = if state.h_hash_removed { 0.04 } else { 0.0 };
|
| let h_marlborg = state.delta_rules as f64 * 0.0005;
|
|
|
| state.h_cog = self.h_base + state.h_trunc + h_hash + h_marlborg;
|
| state.icp = if state.h_cog > self.h_safe { state.h_cog - self.h_safe } else { 0.0 };
|
| state.strain = if self.h_safe > 0.0 { state.icp / self.h_safe } else { 0.0 };
|
| state.timestamp = Instant::now();
|
|
|
| state.strain
|
| }
|
|
|
| pub fn get_entropy_fixed(&self) -> u64 {
|
| let state = self.state.read().unwrap();
|
| (state.h_cog * self.scaling_factor as f64) as u64
|
| }
|
|
|
| pub fn get_s_bh_fixed(&self) -> u64 {
|
| (self.h_safe * self.scaling_factor as f64) as u64
|
| }
|
|
|
| pub fn is_overflow(&self) -> bool {
|
| self.get_entropy_fixed() > self.get_s_bh_fixed()
|
| }
|
|
|
| pub fn is_critical(&self, threshold: f64) -> bool {
|
| self.compute_strain() > threshold
|
| }
|
|
|
| pub fn get_status(&self) -> String {
|
| let strain = self.compute_strain() * 100.0;
|
| match strain {
|
| s if s < 50.0 => format!("HEALTHY: {:.1}% strain", s),
|
| s if s < 70.0 => format!("WARNING: {:.1}% strain", s),
|
| s if s < 85.0 => format!("HIGH: {:.1}% strain", s),
|
| _ => format!("CRITICAL: {:.1}% strain", strain),
|
| }
|
| }
|
|
|
|
|
| pub fn max_safe_ops(&self, delta_rules: u64) -> u64 {
|
| let epsilon = 168.0 / 10_088_352.0;
|
| let h_hash = if self.state.read().unwrap().h_hash_removed { 0.04 } else { 0.0 };
|
| let h_marlborg = delta_rules as f64 * 0.0005;
|
| let remaining = self.h_safe - self.h_base - h_hash - h_marlborg;
|
|
|
| if remaining <= 0.0 {
|
| return 0;
|
| }
|
| (remaining / epsilon) as u64
|
| }
|
| }
|
|
|
| fn main() {
|
| let monitor = CognitiveStrainMonitor::new();
|
|
|
| println!("=== Marlborg-Wormhole Strain Monitor ===");
|
| println!("S_BH (fixed): {}", monitor.get_s_bh_fixed());
|
| println!("Initial: {}", monitor.get_status());
|
| println!("Max safe ops (0 rules): {}", monitor.max_safe_ops(0));
|
| println!("Max safe ops (100 rules): {}", monitor.max_safe_ops(100));
|
| println!("Max safe ops (440 rules): {}", monitor.max_safe_ops(440));
|
|
|
|
|
| for _ in 0..100 {
|
| monitor.update_truncation(120);
|
| }
|
| println!("\nAfter 12K ops: {}", monitor.get_status());
|
| println!("Overflow: {}", monitor.is_overflow());
|
|
|
|
|
| monitor.set_hash_status(true);
|
| monitor.update_marlborg_growth(50);
|
| println!("\nAfter hash removal + 50 rules: {}", monitor.get_status());
|
| println!("Overflow: {}", monitor.is_overflow());
|
| }
|
|
|
