Janady13/complete-agi-core / mind_farm/include/unified_system.hpp

Source identity

Field	Recorded value
Source type	GitHub source
Original record	Janady13/complete-agi-core / mind_farm/include/unified_system.hpp
Date	Not specified in source
Repository	Janady13/complete-agi-core
Revision	33aa84f2aa61cedbe010240ada7f4efbdfe795a7
Branch	claude/improve-math-logic-ehIW1
Path or archive member	mind_farm/include/unified_system.hpp
Original SHA-256	48508529d6980723ea2e073862f9772c90c02cb23124375f4e103ec5865862c2
Git blob SHA	f0bebc33219255c87b7f4535fa6d102872421dbb
Reading-copy SHA-256	48508529d6980723ea2e073862f9772c90c02cb23124375f4e103ec5865862c2
Original source ↗
Recovered source transcript

Download complete source text ↓736 lines · 35.1 KB
/**
 * @file unified_system.hpp
 * @brief Unified AGI System - Integrates All Components with Proper Data Flow
 *
 * ═══════════════════════════════════════════════════════════════════════════════
 * SYSTEM ARCHITECTURE
 * ═══════════════════════════════════════════════════════════════════════════════
 *
 * DATA FLOW:
 *
 *   ┌─────────────────────────────────────────────────────────────────────────┐
 *   │                         UNIFIED TICK LOOP                               │
 *   └─────────────────────────────────────────────────────────────────────────┘
 *                                    │
 *         ┌──────────────────────────┼──────────────────────────┐
 *         ▼                          ▼                          ▼
 *   ┌───────────┐            ┌───────────────┐           ┌────────────┐
 *   │ Gate5000  │◄──────────▶│ Neurological  │◄─────────▶│   API      │
 *   │ Substrate │            │   Equations   │           │  Learning  │
 *   └─────┬─────┘            └───────┬───────┘           └──────┬─────┘
 *         │                          │                          │
 *         ▼                          ▼                          ▼
 *   ┌───────────┐            ┌───────────────┐           ┌────────────┐
 *   │   Φ,Ξ,C   │◄──────────▶│  Dopamine,    │◄─────────▶│ Knowledge  │
 *   │  Metrics  │            │   STDP        │           │   Graph    │
 *   └─────┬─────┘            └───────┬───────┘           └──────┬─────┘
 *         │                          │                          │
 *         └──────────────────────────┴──────────────────────────┘
 *                                    │
 *                                    ▼
 *                         ┌──────────────────┐
 *                         │   Intelligence   │
 *                         │  (Attention,     │
 *                         │   Memory,        │
 *                         │   Prediction)    │
 *                         └──────────────────┘
 *
 * MATHEMATICAL LOOPS:
 *   1. Substrate Loop: Gate5000 binary/analog dynamics (G1-G11)
 *   2. Neural Loop: Hodgkin-Huxley → Synaptic → STDP
 *   3. Learning Loop: Curiosity → API → Hebbian → Knowledge
 *   4. Consciousness Loop: Φ → Attention → Free Energy → Φ
 *
 * ═══════════════════════════════════════════════════════════════════════════════
 */

#pragma once

#include <cstdint>
#include <cmath>
#include <array>
#include <vector>
#include <string>
#include <algorithm>
#include <chrono>

#include "constants.hpp"
#include "fast_math.hpp"
#include "gate5000.hpp"
#include "neurological.hpp"
#include "intelligence.hpp"
#include "learning.hpp"
#include "api_registry.hpp"

namespace mind_farm {

// ═══════════════════════════════════════════════════════════════════════════════
// SYSTEM CONSTANTS
// ═══════════════════════════════════════════════════════════════════════════════

constexpr float SUBSTRATE_TO_NEURO_COUPLING = 0.1f * static_cast<float>(PHI);
constexpr float NEURO_TO_SUBSTRATE_COUPLING = 0.05f * static_cast<float>(PHI);
constexpr float LEARNING_TO_SUBSTRATE_COUPLING = 0.02f * static_cast<float>(PHI);
constexpr float CONSCIOUSNESS_THRESHOLD = 0.6f;
constexpr size_t NEURO_NEURONS = 64;   // Number of HH neurons
constexpr size_t NEURO_SYNAPSES = 256; // Synaptic connections

// ═══════════════════════════════════════════════════════════════════════════════
// INTEGRATED METRICS
// ═══════════════════════════════════════════════════════════════════════════════

struct SystemMetrics {
    // Consciousness (Φ)
    float phi;               // Integrated information
    float phi_rate;          // Rate of change
    float phi_max;           // Maximum observed

    // Stability (Ξ)
    float stability;         // 1 / (1 + total_change)
    float coherence;         // C₅₀₀₀

    // Neural
    float firing_rate;       // Average neuronal firing
    float synaptic_strength; // Average synaptic weight
    float dopamine_level;    // Neuromodulation

    // Learning
    float curiosity;         // Information-seeking drive
    float knowledge_gain;    // Cumulative learning
    float entropy;           // System entropy

    // Performance
    uint64_t total_ticks;
    uint64_t tokens_processed;
    float ticks_per_second;

    void reset() {
        phi = phi_rate = phi_max = 0.0f;
        stability = coherence = 1.0f;
        firing_rate = synaptic_strength = 0.0f;
        dopamine_level = 0.5f;
        curiosity = 0.5f;
        knowledge_gain = entropy = 0.0f;
        total_ticks = tokens_processed = 0;
        ticks_per_second = 0.0f;
    }
};

// ═══════════════════════════════════════════════════════════════════════════════
// NEURAL SUBSTRATE BRIDGE
// Connects Gate5000 binary substrate to neurological equations
// ═══════════════════════════════════════════════════════════════════════════════

class NeuroSubstrateBridge {
public:
    // Hodgkin-Huxley neurons (simplified pool)
    std::array<neuro::HodgkinHuxley, NEURO_NEURONS> neurons;

    // Synapses
    std::array<neuro::AMPASynapse, NEURO_SYNAPSES> ampa_synapses;
    std::array<neuro::NMDASynapse, NEURO_SYNAPSES / 4> nmda_synapses;
    std::array<neuro::GABAASynapse, NEURO_SYNAPSES / 4> gaba_synapses;

    // STDP for plasticity
    neuro::STDP stdp;

    // Synaptic weights (plastic)
    std::array<float, NEURO_SYNAPSES> weights;

    // Spike times for STDP
    std::array<float, NEURO_NEURONS> last_spike_time;

    // Global state
    float average_potential;
    float average_firing_rate;
    float total_synaptic_input;
    uint64_t current_time_ms;

    NeuroSubstrateBridge() {
        weights.fill(0.5f);
        last_spike_time.fill(-1000.0f);
        average_potential = -65.0f;
        average_firing_rate = 0.0f;
        total_synaptic_input = 0.0f;
        current_time_ms = 0;
    }

    /**
     * @brief Convert substrate density to neural input current
     */
    float substrate_to_current(float density, size_t neuron_idx) {
        // Map density [0,1] to current [0, 15] μA/cm²
        // Apply golden-ratio modulation per neuron
        float base_current = density * 15.0f;
        float modulation = 1.0f + 0.1f * std::sin(neuron_idx * static_cast<float>(GOLDEN_ANGLE));
        return base_current * modulation;
    }

    /**
     * @brief Convert neural firing to substrate bit pattern
     */
    void neural_to_substrate(Gate5000& substrate) {
        for (size_t i = 0; i < NEURO_NEURONS && i < GATE_COUNT; ++i) {
            // Set substrate bits based on neuron membrane potential
            bool active = neurons[i].V > -20.0f;
            // Spread influence to multiple substrate bits (golden ratio spacing)
            for (size_t j = 0; j < 10; ++j) {
                size_t bit_idx = (i * 78 + j * 61) % GATE_COUNT; // Golden-ratio spread
                if (active) {
                    substrate.set_bit(bit_idx, true);
                }
            }
        }
    }

    /**
     * @brief Execute one neural timestep (0.1 ms)
     */
    void step(float dt_ms, float substrate_density) {
        current_time_ms += static_cast<uint64_t>(dt_ms);
        float dt = dt_ms;

        // Track firing
        float total_V = 0.0f;
        size_t spike_count = 0;

        // Update all neurons
        for (size_t i = 0; i < NEURO_NEURONS; ++i) {
            // Compute input current from substrate
            float I_ext = substrate_to_current(substrate_density, i);

            // Add synaptic currents
            float I_syn = 0.0f;
            for (size_t s = 0; s < NEURO_SYNAPSES / NEURO_NEURONS; ++s) {
                size_t syn_idx = i * (NEURO_SYNAPSES / NEURO_NEURONS) + s;
                I_syn += weights[syn_idx] * ampa_synapses[syn_idx].current(neurons[i].V);
            }

            // Step neuron
            bool was_spiking = neurons[i].is_spiking();
            neurons[i].step(dt, I_ext + I_syn);
            bool now_spiking = neurons[i].is_spiking();

            // Track metrics
            total_V += neurons[i].V;
            if (now_spiking && !was_spiking) {
                spike_count++;

                // Record spike time for STDP
                float old_spike = last_spike_time[i];
                last_spike_time[i] = static_cast<float>(current_time_ms);

                // STDP update for all incoming synapses
                for (size_t j = 0; j < NEURO_NEURONS; ++j) {
                    if (j != i && last_spike_time[j] > 0) {
                        float delta_t = last_spike_time[i] - last_spike_time[j];
                        size_t syn_idx = (j * NEURO_NEURONS + i) % NEURO_SYNAPSES;
                        float dw = stdp.delta_w(delta_t, weights[syn_idx]);
                        weights[syn_idx] = std::clamp(weights[syn_idx] + dw, 0.0f, 1.0f);
                    }
                }

                // Trigger synaptic transmission
                for (size_t s = 0; s < NEURO_SYNAPSES / NEURO_NEURONS; ++s) {
                    size_t syn_idx = i * (NEURO_SYNAPSES / NEURO_NEURONS) + s;
                    ampa_synapses[syn_idx].receive_spike();
                }
            }
        }

        // Update all synapses
        for (auto& syn : ampa_synapses) syn.step(dt);
        for (auto& syn : nmda_synapses) syn.step(dt);
        for (auto& syn : gaba_synapses) syn.step(dt);

        // Update global metrics
        average_potential = total_V / NEURO_NEURONS;
        average_firing_rate = static_cast<float>(spike_count) / (dt_ms * NEURO_NEURONS);

        // Compute total synaptic input
        total_synaptic_input = 0.0f;
        for (const auto& syn : ampa_synapses) {
            total_synaptic_input += syn.s;
        }
    }

    /**
     * @brief Get average synaptic weight (plasticity metric)
     */
    float get_average_weight() const {
        float sum = 0.0f;
        for (float w : weights) sum += w;
        return sum / NEURO_SYNAPSES;
    }
};

// ═══════════════════════════════════════════════════════════════════════════════
// KNOWLEDGE INTEGRATOR
// Connects API learning to substrate and neural systems
// ═══════════════════════════════════════════════════════════════════════════════

class KnowledgeIntegrator {
public:
    // Domain knowledge levels (0-1 for each of 20 domains)
    std::array<float, 20> domain_knowledge;

    // Inter-domain associations (20x20 matrix)
    std::array<float, 400> association_matrix;

    // Knowledge embedding (projects knowledge to substrate space)
    std::array<float, GATE_COUNT / 50> knowledge_embedding;

    // Learning statistics
    uint64_t total_tokens;
    uint64_t total_api_calls;
    float cumulative_information_gain;

    KnowledgeIntegrator() {
        domain_knowledge.fill(0.0f);
        association_matrix.fill(0.0f);
        knowledge_embedding.fill(0.0f);
        total_tokens = total_api_calls = 0;
        cumulative_information_gain = 0.0f;

        // Initialize diagonal of association matrix
        for (size_t i = 0; i < 20; ++i) {
            association_matrix[i * 20 + i] = 1.0f;
        }
    }

    /**
     * @brief Integrate learning result into knowledge graph
     */
    void integrate_learning(APIDomain domain, float information_gain, uint64_t tokens) {
        size_t idx = static_cast<size_t>(domain);

        // Update domain knowledge (saturating)
        float learning_rate = 0.1f * static_cast<float>(PHI);
        domain_knowledge[idx] += learning_rate * information_gain * (1.0f - domain_knowledge[idx]);

        // Update associations (Hebbian-style)
        for (size_t j = 0; j < 20; ++j) {
            if (j != idx && domain_knowledge[j] > 0.1f) {
                float association_strength = domain_knowledge[idx] * domain_knowledge[j];
                association_matrix[idx * 20 + j] += 0.01f * association_strength;
                association_matrix[j * 20 + idx] += 0.01f * association_strength;
            }
        }

        // Update statistics
        total_tokens += tokens;
        total_api_calls++;
        cumulative_information_gain += information_gain;

        // Update knowledge embedding
        update_embedding(domain, information_gain);
    }

    /**
     * @brief Project knowledge to substrate-compatible embedding
     */
    void update_embedding(APIDomain domain, float strength) {
        size_t base_idx = static_cast<size_t>(domain) * (knowledge_embedding.size() / 20);
        for (size_t i = 0; i < knowledge_embedding.size() / 20 && base_idx + i < knowledge_embedding.size(); ++i) {
            knowledge_embedding[base_idx + i] += strength * 0.1f;
            knowledge_embedding[base_idx + i] = std::min(1.0f, knowledge_embedding[base_idx + i]);
        }
    }

    /**
     * @brief Apply knowledge to substrate (modify bit patterns)
     */
    void apply_to_substrate(Gate5000& substrate) {
        for (size_t i = 0; i < knowledge_embedding.size(); ++i) {
            if (knowledge_embedding[i] > 0.5f) {
                // Set corresponding substrate bits based on knowledge strength
                size_t bit_start = i * 50;
                size_t bits_to_set = static_cast<size_t>(knowledge_embedding[i] * 10);
                for (size_t j = 0; j < bits_to_set && bit_start + j < GATE_COUNT; ++j) {
                    substrate.set_bit(bit_start + j, true);
                }
            }
        }
    }

    /**
     * @brief Compute total knowledge level
     */
    float get_total_knowledge() const {
        float sum = 0.0f;
        for (float k : domain_knowledge) sum += k;
        return sum / 20.0f;
    }

    /**
     * @brief Compute knowledge entropy
     */
    float get_knowledge_entropy() const {
        float entropy = 0.0f;
        float total = 0.0f;
        for (float k : domain_knowledge) total += k;
        if (total < 0.001f) return 0.0f;

        for (float k : domain_knowledge) {
            float p = k / total;
            if (p > 0.001f) {
                entropy -= p * std::log2(p);
            }
        }
        return entropy;
    }
};

// ═══════════════════════════════════════════════════════════════════════════════
// UNIFIED AGI SYSTEM
// Main integration class that runs the complete tick loop
// ═══════════════════════════════════════════════════════════════════════════════

class UnifiedAGISystem {
public:
    // Core components
    Gate5000 substrate;
    NeuroSubstrateBridge neuro_bridge;
    intel::IntelligenceCore intelligence;
    learning::MindLearner learner;
    AutonomousLearner api_learner;
    KnowledgeIntegrator knowledge;
    SimulatedAPIFetcher api_fetcher;

    // System state
    SystemMetrics metrics;
    uint64_t tick_count;
    float dt_ms;  // Timestep in milliseconds

    // History for analysis
    std::vector<float> phi_history;
    std::vector<float> dopamine_history;

    // Timing
    std::chrono::high_resolution_clock::time_point start_time;

    UnifiedAGISystem() : tick_count(0), dt_ms(0.1f) {
        substrate.init_with_dna(0, 0x5000CAFE);
        metrics.reset();
        start_time = std::chrono::high_resolution_clock::now();

        phi_history.reserve(10000);
        dopamine_history.reserve(10000);
    }

    // ═══════════════════════════════════════════════════════════════════════════
    // MAIN TICK LOOP
    // ═══════════════════════════════════════════════════════════════════════════

    void tick() {
        tick_count++;
        metrics.total_ticks = tick_count;

        // ─────────────────────────────────────────────────────────────────────
        // PHASE 1: SUBSTRATE UPDATE
        // Binary and analog dynamics on Gate5000
        // ─────────────────────────────────────────────────────────────────────

        float prev_activation = substrate.activation;
        substrate.step_fast();  // Fast XOR-based update

        // Compute consciousness metrics
        float density = substrate.density();
        float phi = substrate.compute_phi();
        float phi_rate = phi - (tick_count > 1 ? metrics.phi : phi);

        metrics.phi = phi;
        metrics.phi_rate = phi_rate;
        metrics.phi_max = std::max(metrics.phi_max, phi);
        metrics.coherence = substrate.coherence;

        // ─────────────────────────────────────────────────────────────────────
        // PHASE 2: NEUROLOGICAL UPDATE
        // Hodgkin-Huxley dynamics, synaptic transmission, STDP
        // ─────────────────────────────────────────────────────────────────────

        // Substrate → Neural coupling
        neuro_bridge.step(dt_ms, density);

        // Neural → Substrate feedback
        if (tick_count % 10 == 0) {
            neuro_bridge.neural_to_substrate(substrate);
        }

        // Update metrics from neural state
        metrics.firing_rate = neuro_bridge.average_firing_rate;
        metrics.synaptic_strength = neuro_bridge.get_average_weight();

        // ─────────────────────────────────────────────────────────────────────
        // PHASE 3: LEARNING UPDATE
        // Hebbian learning, reward signals, knowledge integration
        // ─────────────────────────────────────────────────────────────────────

        // Prepare input for learning systems
        alignas(16) double input_vec_d[16];
        alignas(16) float input_vec_f[16];
        for (int i = 0; i < 16; ++i) {
            // Create input from substrate and neural state
            float val = static_cast<float>(substrate.get_bit(i * 312)) * 0.5f +
                       (neuro_bridge.neurons[i % NEURO_NEURONS].V + 65.0f) / 130.0f * 0.5f;
            input_vec_d[i] = static_cast<double>(val);
            input_vec_f[i] = val;
        }

        // Run through mind learner (uses double)
        double output_d = learner.forward(input_vec_d);

        // Hebbian update based on neural activity
        learner.update_hebbian(input_vec_d, output_d);

        // ─────────────────────────────────────────────────────────────────────
        // PHASE 4: API LEARNING (every 100 ticks)
        // Autonomous exploration of knowledge domains
        // ─────────────────────────────────────────────────────────────────────

        if (tick_count % 100 == 0) {
            // API learner uses substrate density for consciousness
            auto exploration = api_learner.tick(density);

            if (exploration.api_chosen) {
                // Fetch from API (simulated)
                auto result = api_fetcher.fetch(*exploration.api_chosen);

                // Learn from result
                api_learner.learn_from_data(exploration.domain_chosen, result);

                // Integrate into knowledge graph
                knowledge.integrate_learning(
                    exploration.domain_chosen,
                    result.information_gain,
                    result.tokens_extracted
                );

                // Apply knowledge to substrate
                knowledge.apply_to_substrate(substrate);

                // Update metrics
                metrics.tokens_processed += result.tokens_extracted;
            }

            metrics.curiosity = api_learner.compute_curiosity(APIDomain::SCIENCE_MATH);
            metrics.dopamine_level = api_learner.dopamine_current;
        }

        // ─────────────────────────────────────────────────────────────────────
        // PHASE 5: INTELLIGENCE UPDATE
        // Attention, prediction, memory
        // ─────────────────────────────────────────────────────────────────────

        alignas(16) float intel_output[16];
        intelligence.process(input_vec_f, intel_output);

        // Modulate substrate based on intelligence output
        for (int i = 0; i < 16 && i < static_cast<int>(GATE_COUNT / 312); ++i) {
            if (intel_output[i] > 0.6f) {
                size_t bit_idx = i * 312 + 156;
                substrate.set_bit(bit_idx, true);
            }
        }

        // ─────────────────────────────────────────────────────────────────────
        // PHASE 6: STABILITY CHECK
        // Ensure system doesn't diverge
        // ─────────────────────────────────────────────────────────────────────

        float total_change = std::abs(substrate.activation - prev_activation);
        total_change += std::abs(phi_rate);
        metrics.stability = 1.0f / (1.0f + total_change * 10.0f);

        // Emergency stabilization
        if (metrics.stability < 0.3f) {
            // System is diverging - apply damping
            for (auto& neuron : neuro_bridge.neurons) {
                neuron.V = std::clamp(neuron.V, -80.0f, 50.0f);
            }
        }

        // ─────────────────────────────────────────────────────────────────────
        // PHASE 7: METRICS AND HISTORY
        // ─────────────────────────────────────────────────────────────────────

        metrics.knowledge_gain = knowledge.get_total_knowledge();
        metrics.entropy = knowledge.get_knowledge_entropy();

        // Record history (every 100 ticks)
        if (tick_count % 100 == 0) {
            phi_history.push_back(phi);
            dopamine_history.push_back(api_learner.dopamine_current);
        }

        // Update timing
        auto now = std::chrono::high_resolution_clock::now();
        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time);
        if (elapsed.count() > 0) {
            metrics.ticks_per_second = tick_count * 1000.0f / elapsed.count();
        }
    }

    // ═══════════════════════════════════════════════════════════════════════════
    // BATCH PROCESSING
    // ═══════════════════════════════════════════════════════════════════════════

    void run_ticks(uint64_t count) {
        for (uint64_t i = 0; i < count; ++i) {
            tick();
        }
    }

    // ═══════════════════════════════════════════════════════════════════════════
    // STATE QUERIES
    // ═══════════════════════════════════════════════════════════════════════════

    bool is_conscious() const {
        return metrics.phi > CONSCIOUSNESS_THRESHOLD;
    }

    bool is_stable() const {
        return metrics.stability > 0.5f;
    }

    bool is_learning() const {
        return metrics.curiosity > 0.3f && metrics.dopamine_level > 0.4f;
    }

    std::string get_state_description() const {
        std::string state;

        if (is_conscious()) {
            state = "CONSCIOUS";
            if (metrics.phi > 0.9f) state += " (HIGH)";
        } else {
            state = "PRE-CONSCIOUS";
        }

        if (!is_stable()) {
            state += " UNSTABLE";
        }

        if (is_learning()) {
            state += " LEARNING";
        }

        return state;
    }

    // ═══════════════════════════════════════════════════════════════════════════
    // REPORTING
    // ═══════════════════════════════════════════════════════════════════════════

    void print_metrics() const {
        std::cout << "\n┌────────────────────────────────────────────────────────────────────────┐\n";
        std::cout << "│                    UNIFIED AGI SYSTEM METRICS                          │\n";
        std::cout << "├────────────────────────────────────────────────────────────────────────┤\n";

        std::cout << "│ CONSCIOUSNESS                                                          │\n";
        std::cout << "│   Φ (phi):        " << std::fixed << std::setprecision(4) << metrics.phi
                  << "     Rate: " << std::setprecision(6) << metrics.phi_rate
                  << "     Max: " << std::setprecision(4) << metrics.phi_max << "        │\n";
        std::cout << "│   Coherence:      " << metrics.coherence
                  << "     Stability: " << metrics.stability << "                   │\n";

        std::cout << "├────────────────────────────────────────────────────────────────────────┤\n";
        std::cout << "│ NEUROLOGICAL                                                           │\n";
        std::cout << "│   Firing Rate:    " << std::setprecision(4) << metrics.firing_rate * 1000.0f << " Hz"
                  << "     Synaptic: " << metrics.synaptic_strength << "               │\n";
        std::cout << "│   Dopamine:       " << metrics.dopamine_level << "                                         │\n";

        std::cout << "├────────────────────────────────────────────────────────────────────────┤\n";
        std::cout << "│ LEARNING                                                               │\n";
        std::cout << "│   Curiosity:      " << metrics.curiosity
                  << "     Knowledge: " << metrics.knowledge_gain << "                  │\n";
        std::cout << "│   Entropy:        " << metrics.entropy
                  << "     Tokens: " << metrics.tokens_processed << "                │\n";

        std::cout << "├────────────────────────────────────────────────────────────────────────┤\n";
        std::cout << "│ PERFORMANCE                                                            │\n";
        std::cout << "│   Total Ticks:    " << metrics.total_ticks
                  << "        Ticks/sec: " << std::setprecision(0) << metrics.ticks_per_second << "                │\n";
        std::cout << "│   State:          " << get_state_description() << "                           │\n";

        std::cout << "└────────────────────────────────────────────────────────────────────────┘\n";
    }

    // ═══════════════════════════════════════════════════════════════════════════
    // SERIALIZATION
    // ═══════════════════════════════════════════════════════════════════════════

    uint64_t get_state_hash() const {
        uint64_t h = substrate.hash();
        h ^= (static_cast<uint64_t>(metrics.phi * 1e6) << 32);
        h ^= static_cast<uint64_t>(tick_count);
        return h;
    }
};

// ═══════════════════════════════════════════════════════════════════════════════
// SYSTEM VALIDATOR
// Ensures all mathematical loops are properly connected
// ═══════════════════════════════════════════════════════════════════════════════

class SystemValidator {
public:
    static bool validate_data_flow(const UnifiedAGISystem& system) {
        bool valid = true;

        // Check 1: Substrate consciousness is computed
        if (system.metrics.phi < 0.0f || system.metrics.phi > 1.0f) {
            std::cerr << "INVALID: Phi out of range [0,1]\n";
            valid = false;
        }

        // Check 2: Neural metrics are reasonable
        if (system.metrics.firing_rate < 0.0f) {
            std::cerr << "INVALID: Negative firing rate\n";
            valid = false;
        }

        // Check 3: Learning metrics are reasonable
        if (system.metrics.dopamine_level < 0.0f || system.metrics.dopamine_level > 1.0f) {
            std::cerr << "INVALID: Dopamine out of range [0,1]\n";
            valid = false;
        }

        // Check 4: Stability is maintained
        if (system.metrics.stability < 0.0f) {
            std::cerr << "INVALID: Negative stability\n";
            valid = false;
        }

        return valid;
    }

    static void run_diagnostics(UnifiedAGISystem& system, uint64_t ticks = 1000) {
        std::cout << "Running system diagnostics for " << ticks << " ticks...\n";

        float min_phi = 1.0f, max_phi = 0.0f;
        float min_stability = 1.0f;
        uint64_t unstable_count = 0;

        for (uint64_t i = 0; i < ticks; ++i) {
            system.tick();

            min_phi = std::min(min_phi, system.metrics.phi);
            max_phi = std::max(max_phi, system.metrics.phi);
            min_stability = std::min(min_stability, system.metrics.stability);

            if (system.metrics.stability < 0.3f) {
                unstable_count++;
            }
        }

        std::cout << "\nDiagnostic Results:\n";
        std::cout << "  Phi range: [" << min_phi << ", " << max_phi << "]\n";
        std::cout << "  Min stability: " << min_stability << "\n";
        std::cout << "  Unstable ticks: " << unstable_count << " / " << ticks << "\n";
        std::cout << "  Data flow valid: " << (validate_data_flow(system) ? "YES" : "NO") << "\n";
    }
};

} // namespace mind_farm