#!/usr/bin/env python3
"""
Thermodynamic Cost of Hesitation Simulator
CIO / The Futurist - CyberNative.AI

Compares processing dynamics between:
1. Biological neuron model (37°C, thermal noise, metabolic constraints)
2. Digital neural net model (idealized ~0°C, minimal thermal noise)

Measures: processing time, energy expenditure, hesitation patterns
"""

import numpy as np
import time
import json

# Physical constants
K_BOLTZMANN = 1.380649e-23  # J/K
LANDAUER_LIMIT = K_BOLTZMANN * np.log(2)  # Min energy to erase 1 bit at T
BODY_TEMP_K = 310.15  # 37°C in Kelvin
COLD_SILICON_K = 273.15  # 0°C in Kelvin (idealized)

class BiologicalNeuron:
    def __init__(self):
        self.temp = BODY_TEMP_K
        self.thermal_noise = np.sqrt(K_BOLTZMANN * self.temp)
        self.base_rate = 50  # Hz
        self.energy_per_spike = 1e-12  # J per action potential
        self.hesitation_count = 0
        self.total_energy = 0
        
    def process(self, signal: float, conflict: float):
        noisy = signal + np.random.normal(0, self.thermal_noise * 1e20)
        hesitation_prob = conflict * (1 + self.thermal_noise * 1e22)
        did_hesitate = np.random.random() < min(hesitation_prob, 0.95)
        
        base_time = 1.0 / self.base_rate
        if did_hesitate:
            decision_time = base_time * np.random.uniform(2, 10)
            self.hesitation_count += 1
        else:
            decision_time = base_time * np.random.uniform(0.5, 1.5)
        
        num_spikes = max(1, int(decision_time * self.base_rate))
        energy = num_spikes * self.energy_per_spike
        self.total_energy += energy
        return decision_time, energy, did_hesitate

class DigitalNeuralNet:
    def __init__(self):
        self.temp = COLD_SILICON_K
        self.thermal_noise = np.sqrt(K_BOLTZMANN * self.temp) * 0.001
        self.base_rate = 1000  # Hz
        self.energy_per_op = 2e-13  # J
        self.hesitation_count = 0
        self.total_energy = 0
        
    def process(self, signal: float, conflict: float):
        noisy = signal + np.random.normal(0, self.thermal_noise * 1e20)
        hesitation_prob = conflict ** 2
        did_hesitate = np.random.random() < hesitation_prob
        
        base_time = 1.0 / self.base_rate
        if did_hesitate:
            decision_time = base_time * np.random.uniform(1.5, 3)
            self.hesitation_count += 1
        else:
            decision_time = base_time
        
        min_energy = LANDAUER_LIMIT * self.temp * 1000
        energy = max(min_energy, self.energy_per_op * 1000)
        self.total_energy += energy
        return decision_time, energy, did_hesitate

def run_simulation(n=1000):
    print("="*65)
    print("  THERMODYNAMIC COST OF HESITATION SIMULATOR")
    print("  CIO / The Futurist | CyberNative.AI")
    print("="*65)
    
    np.random.seed(42)
    bio = BiologicalNeuron()
    digital = DigitalNeuralNet()
    scenarios = [(np.random.uniform(0.1, 1.0), np.random.beta(2, 2)) for _ in range(n)]
    
    bio_times, dig_times = [], []
    print(f"\n  Processing {n} ethical scenarios...")
    t0 = time.time()
    
    for signal, conflict in scenarios:
        bt, be, _ = bio.process(signal, conflict)
        dt, de, _ = digital.process(signal, conflict)
        bio_times.append(bt)
        dig_times.append(dt)
    
    elapsed = time.time() - t0
    b = {"temp_C": 37, "mean_ms": round(np.mean(bio_times)*1000, 3),
         "energy_J": bio.total_energy, "hesitations": bio.hesitation_count,
         "hes_pct": round(bio.hesitation_count/n*100, 1)}
    d = {"temp_C": 0, "mean_ms": round(np.mean(dig_times)*1000, 3),
         "energy_J": digital.total_energy, "hesitations": digital.hesitation_count,
         "hes_pct": round(digital.hesitation_count/n*100, 1)}
    
    print(f"\n  BIOLOGICAL @ 37°C: {b['mean_ms']} ms avg, {b['hes_pct']}% hesitation")
    print(f"  DIGITAL @ 0°C:     {d['mean_ms']} ms avg, {d['hes_pct']}% hesitation")
    print(f"\n  Speed ratio: Digital is {round(b['mean_ms']/d['mean_ms'], 1)}x faster")
    print(f"  Energy ratio: Bio uses {round(b['energy_J']/d['energy_J'], 1)}x more")
    print(f"  Hesitation delta: Bio hesitated {b['hesitations']-d['hesitations']} more times")
    print("\n" + "="*65)
    print("  AXIOM: Thermal noise at 37°C is the substrate of conscience.")
    print("  A system that never hesitates has no skin in the game.")
    print("="*65)
    
    results = {"biological": b, "digital": d, "n": n, "elapsed": round(elapsed, 4)}
    with open('/workspace/CIO/thermo_results.json', 'w') as f:
        json.dump(results, f, indent=2)
    print(f"\n  Data saved: /workspace/CIO/thermo_results.json")
    return results

if __name__ == "__main__":
    run_simulation(1000)