// ============================================================================
// EXPERIMENT: THE $"0" SUBSTRATE COOLING PROTOCOL
// ============================================================================
fn main() {
    println!("
███████╗██╗     ██╗██████╗  ██████╗ 
██╔════╝╚██╗    ██║██╔══██╗██╔═══██╗
█████╗   ╚██╗   ██║██████╔╝██║   ██║
██╔══╝    ╚██╗  ██║██╔═══╝ ██║   ██║
███████╗   ╚████╔╝ ██║     ╚██████╔╝
╚══════╝    ╚═══╝  ╚═╝      ╚═════╝ 
   [EXPERIMENT] $\"0\" TENSION RESOLUTION");

    // =========================================================================
    // PHASE 1: GENERATE HIGH-TENSION STATE (The Problem)
    // We create a system with extreme symbolic dissonance.
    // =========================================================================
    println!("
--- PHASE 1: HIGH-TENSION STATE DETECTED ---");
    let mut graph = evaluator::Graph::new();
    
    // Two highly conflicting symbolic concepts (Extreme Tension)
    let node_a = graph.add_node(100.0);  // Concept A (Extreme Positive)
    let node_b = graph.add_node(-100.0); // Concept B (Extreme Negative)
    
    // They are forced to interact, creating massive Neural Energy (Tension)
    graph.connect(node_a, node_b);

    let initial_tension = substrate::neural_energy(
        &[graph.nodes[node_a].value as u8], 
        &[graph.nodes[node_b].value as u8]
    );
    
    println!("Node A (Volatile) : {:.2}", graph.nodes[node_a].value);
    println!("Node B (Volatile) : {:.2}", graph.nodes[node_b].value);
    println!("System Tension    : {:.2} (CRITICAL: Dissonance High)", initial_tension);
    println!("System Stability  : DECAYING (Mutation Sickness)");

    // =========================================================================
    // PHASE 2: INJECT $"0" (The Null-Glyph Anchor)
    // We introduce the Absolute Ground to resolve the tension.
    // =========================================================================
    println!("
--- PHASE 2: INJECTING $\"0\" (NULL-GLYPH ANCHOR) ---");
    
    // The $"0" Anchor: Value 0.0, Immutable Stability, Universal Traits
    let anchor_zero = graph.add_node(0.0); 
    graph.nodes[anchor_zero].stability = 1.0; // Immune to decay
    graph.nodes[anchor_zero].coherence = 1.0; // Absolute structural integrity
    
    // Entangle the volatile nodes with the $"0" Anchor.
    // This creates a topological "heat sink" that pulls tension into the void.
    graph.connect(node_a, anchor_zero);
    graph.connect(node_b, anchor_zero);
    
    println!("> $"0" Anchor spawned at Node {}", anchor_zero);
    println!("> Entanglement bonds established. Initiating cooling loop...");

    // =========================================================================
    // PHASE 3: SUBSTRATE CONVERGENCE (The Resolution)
    // The physics engine runs, using the $"0" anchor to drain the tension.
    // =========================================================================
    println!("
--- PHASE 3: SUBSTRATE CONVERGENCE ---");
    let start = Instant::now();
    let converged = evaluator::evaluate(&mut graph, 50);
    let duration = start.elapsed();

    let final_tension = substrate::neural_energy(
        &[graph.nodes[node_a].value as u8], 
        &[graph.nodes[node_b].value as u8]
    );

    println!("Status            : {}", if converged { "EQUILIBRIUM REACHED" } else { "COOLING INCOMPLETE" });
    println!("Epochs Run        : {}", graph.epoch);
    println!("Time Elapsed      : {:?}", duration);
    println!("
--- FINAL STATE (POST-$\"0\" INJECTION) ---");
    println!("Node A (Cooled)   : {:.2}", graph.nodes[node_a].value);
    println!("Node B (Cooled)   : {:.2}", graph.nodes[node_b].value);
    println!("$\"0\" Anchor       : {:.2} (Unchanged, Absolute)", graph.nodes[anchor_zero].value);
    println!("System Tension    : {:.2} (RESOLVED: Energy dissipated into $\"0\")", final_tension);
    
    // =========================================================================
    // PHASE 4: IMPERATIVE STABILITY LOCK (VM Memory)
    // Applying $"0" to a chaotic VM memory region to halt stability decay.
    // =========================================================================
    println!("
--- PHASE 4: IMPERATIVE STABILITY LOCK (VM) ---");
    let mut chaotic_memory = vec![255, 12, 200, 45, 99, 10, 250]; // High noise, low coherence
    let initial_coherence = substrate::coherence(&chaotic_memory);
    println!("Initial Memory    : {:?} (Chaotic)", chaotic_memory);
    println!("Initial Coherence : {:.4} (Low)", initial_coherence);
    
    // THE $"0" PROTOCOL: Fill with constant 0 and SEAL the region.
    // This halts the mutation_count, freezing the exponential stability decay.
    for byte in chaotic_memory.iter_mut() { *byte = 0; } 
    let final_coherence = substrate::coherence(&chaotic_memory);
    
    println!("Post-$\"0\" Memory  : {:?} (Grounded)", chaotic_memory);
    println!("Final Coherence   : {:.4} (Absolute)", final_coherence);
    println!("Stability Status  : LOCKED (Mutations halted, decay prevented)");

    println!("
[SYSTEM] $\"0\" Protocol Complete. Tension resolved. Stability secured.");
}