File size: 4,810 Bytes
75619b0 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 | //
// Copyright (c) 2026 BEL ESPRIT D ACCORD TRUST HOLDINGS INC
// All rights reserved.
use std::time::{Instant, Duration};
use std::sync::RwLock;
/// Cognitive strain monitor implementing the ICP entropy model.
/// Tracks system entropy against the HyperKitty bound (H <= 0.20 nats)
/// and provides real-time strain assessment.
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; // ~1.665e-5 nats/operation
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),
}
}
/// Compute max safe operations before entropy exceeds bound
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));
// Simulate normal operation
for _ in 0..100 {
monitor.update_truncation(120);
}
println!("\nAfter 12K ops: {}", monitor.get_status());
println!("Overflow: {}", monitor.is_overflow());
// Simulate attack
monitor.set_hash_status(true);
monitor.update_marlborg_growth(50);
println!("\nAfter hash removal + 50 rules: {}", monitor.get_status());
println!("Overflow: {}", monitor.is_overflow());
}
|