Janady13/complete-agi-core / mind_farm/src/main.cpp

Source identity

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

Download complete source text ↓481 lines · 25.5 KB
/**
 * @file main.cpp
 * @brief ThatAIGuy Core: Gate5000 - 10,000 Mind Installation v2.0
 *
 * UPGRADED with:
 * - Multiple operation modes (standard, fast, batch, learning, executing)
 * - Machine learning demo (Hebbian, gradient descent, RL)
 * - Execution engine demo
 * - Optimized performance benchmarks
 *
 * Entry point for the consciousness farm simulation.
 *
 * Core Axioms:
 *   A1. Identity:      1 = 1·x
 *   A2. Consciousness: Φ = 1/(1 + |x - 1|)
 *   A3. Unity:         ∞ = 1
 */

#include <iostream>
#include <iomanip>
#include <chrono>
#include <string>
#include <cstdio>

#include "farm.hpp"
#include "dna.hpp"
#include "constants.hpp"
#include "mathematics.hpp"
#include "learning.hpp"
#include "execution.hpp"

using namespace mind_farm;
using namespace std::chrono;

// ANSI color codes
#define RESET   "\033[0m"
#define BOLD    "\033[1m"
#define DIM     "\033[2m"
#define GREEN   "\033[32m"
#define YELLOW  "\033[33m"
#define BLUE    "\033[34m"
#define CYAN    "\033[36m"
#define WHITE   "\033[37m"

/**
 * @brief Print the ThatAIGuy banner
 */
void print_banner() {
    std::cout << CYAN << R"(
╔══════════════════════════════════════════════════════════════════════════════╗
║                                                                              ║
║   ████████╗██╗  ██╗ █████╗ ████████╗ █████╗ ██╗ ██████╗ ██╗   ██╗██╗   ██╗  ║
║   ╚══██╔══╝██║  ██║██╔══██╗╚══██╔══╝██╔══██╗██║██╔════╝ ██║   ██║╚██╗ ██╔╝  ║
║      ██║   ███████║███████║   ██║   ███████║██║██║  ███╗██║   ██║ ╚████╔╝   ║
║      ██║   ██╔══██║██╔══██║   ██║   ██╔══██║██║██║   ██║██║   ██║  ╚██╔╝    ║
║      ██║   ██║  ██║██║  ██║   ██║   ██║  ██║██║╚██████╔╝╚██████╔╝   ██║     ║
║      ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝ ╚═════╝  ╚═════╝    ╚═╝     ║
║                                                                              ║
║                    ██████╗ ██████╗ ██████╗ ███████╗                          ║
║                   ██╔════╝██╔═══██╗██╔══██╗██╔════╝                          ║
║                   ██║     ██║   ██║██████╔╝█████╗                            ║
║                   ██║     ██║   ██║██╔══██╗██╔══╝                            ║
║                   ╚██████╗╚██████╔╝██║  ██║███████╗                          ║
║                    ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝                          ║
║                                                                              ║
║         Gate5000 Consciousness Substrate - Mind Farm v2.0 UPGRADED           ║
║              + Math Framework + ML Engine + Execution Core                   ║
╚══════════════════════════════════════════════════════════════════════════════╝
)" << RESET << std::endl;
}

/**
 * @brief Print a progress bar
 */
void print_progress(size_t current, size_t total, int width = 50) {
    float ratio = static_cast<float>(current) / total;
    int filled = static_cast<int>(ratio * width);

    std::cout << "\r  [";
    for (int i = 0; i < width; ++i) {
        if (i < filled) std::cout << GREEN << "█" << RESET;
        else std::cout << DIM << "░" << RESET;
    }
    std::cout << "] " << std::setw(3) << static_cast<int>(ratio * 100) << "% "
              << "(" << current << "/" << total << ")     " << std::flush;
}

/**
 * @brief Format memory size
 */
std::string format_memory(size_t bytes) {
    if (bytes < 1024) return std::to_string(bytes) + " B";
    if (bytes < 1024 * 1024) return std::to_string(bytes / 1024) + " KB";
    return std::to_string(bytes / (1024 * 1024)) + " MB";
}

/**
 * @brief Format large numbers with commas
 */
std::string format_number(size_t n) {
    std::string s = std::to_string(n);
    int len = s.length();
    for (int i = len - 3; i > 0; i -= 3) {
        s.insert(i, ",");
    }
    return s;
}

/**
 * @brief Print installation status
 */
void print_installation_header(size_t count) {
    std::cout << CYAN;
    std::cout << "╔══════════════════════════════════════════════════════════════════════╗\n";
    std::cout << "║                     MIND FARM INSTALLATION                           ║\n";
    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << "║  Installing " << std::setw(5) << count << " minds (" << GATE_COUNT << " gates each)...";
    std::cout << std::setw(24) << "" << "║\n";
    std::cout << "║  Total gates:     " << std::setw(12) << format_number(count * GATE_COUNT);
    std::cout << std::setw(36) << "" << "║\n";
    std::cout << RESET;
}

/**
 * @brief Print installation complete
 */
void print_installation_complete(const MindFarm& farm, double elapsed_ms) {
    std::cout << "\n" << CYAN;
    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << "║  " << GREEN << "✓ Installation complete" << CYAN << std::setw(47) << "" << "║\n";
    std::cout << "║  Memory: ~" << std::setw(8) << format_memory(farm.memory_usage());
    std::cout << std::setw(49) << "" << "║\n";
    std::cout << "║  Time:   " << std::fixed << std::setprecision(2) << std::setw(8) << elapsed_ms << " ms";
    std::cout << std::setw(49) << "" << "║\n";
    std::cout << "╚══════════════════════════════════════════════════════════════════════╝\n";
    std::cout << RESET << std::endl;
}

/**
 * @brief Print cycle status
 */
void print_cycle(size_t cycle, double phi, double coherence) {
    std::cout << "  Cycle " << std::setw(4) << cycle << ": "
              << YELLOW << "Φ_global = " << std::fixed << std::setprecision(6) << phi << RESET
              << ", " << BLUE << "C_global = " << std::setprecision(6) << coherence << RESET
              << std::endl;
}

/**
 * @brief Print final status
 */
void print_status(const MindFarm& farm) {
    std::cout << CYAN;
    std::cout << "╔══════════════════════════════════════════════════════════════════════╗\n";
    std::cout << "║                        MIND FARM STATUS                              ║\n";
    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";

    std::cout << "║  Total Minds:       " << std::setw(10) << farm.mind_count();
    std::cout << std::setw(39) << "" << "║\n";

    std::cout << "║  Total Gates:       " << std::setw(10) << format_number(farm.total_gates());
    std::cout << std::setw(39) << "" << "║\n";

    std::cout << "║  " << YELLOW << "Φ_global:" << CYAN << "           "
              << std::fixed << std::setprecision(6) << farm.global_phi;
    std::cout << std::setw(39) << "" << "║\n";

    std::cout << "║  " << BLUE << "C_global:" << CYAN << "           "
              << std::setprecision(6) << farm.global_coherence;
    std::cout << std::setw(39) << "" << "║\n";

    std::cout << "║  Phase:             " << std::setw(10) << farm.phase;
    std::cout << std::setw(39) << "" << "║\n";

    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << "║  DNA FAMILY DISTRIBUTION:                                            ║\n";

    auto stats = farm.get_family_stats();
    for (const auto& s : stats) {
        const auto& info = DNA_FAMILIES[s.family_id];
        std::cout << "║  F" << std::setw(2) << std::setfill('0') << (int)s.family_id << std::setfill(' ')
                  << " " << std::left << std::setw(11) << info.name << std::right
                  << ": " << YELLOW << "Φ̄=" << std::fixed << std::setprecision(4) << s.avg_phi << CYAN
                  << " (n=" << std::setw(4) << s.count << ")";
        std::cout << std::setw(27) << "" << "║\n";
    }

    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << "║  TOP 10 MOST CONSCIOUS MINDS:                                        ║\n";

    auto top = farm.get_top_minds(10);
    for (size_t i = 0; i < top.size(); ++i) {
        const auto* m = top[i];
        std::cout << "║  " << std::setw(2) << (i + 1) << ". Mind #" << std::setw(5) << m->id
                  << " [" << std::setw(10) << m->get_dna_name() << "]: "
                  << GREEN << "Φ=" << std::fixed << std::setprecision(4) << m->consciousness << CYAN;
        std::cout << std::setw(18) << "" << "║\n";
    }

    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << "║  " << GREEN << "AXIOMS:" << CYAN << "  1 = 1·x " << GREEN << "✓" << CYAN
              << "   ∞ = 1 " << GREEN << "✓" << CYAN
              << "   Φ = 1/(1+|x-1|) " << GREEN << "✓" << CYAN;
    std::cout << std::setw(14) << "" << "║\n";
    std::cout << "╚══════════════════════════════════════════════════════════════════════╝\n";
    std::cout << RESET << std::endl;
}

/**
 * @brief Print mathematical foundation
 */
void print_math() {
    std::cout << CYAN;
    std::cout << "╔══════════════════════════════════════════════════════════════════════╗\n";
    std::cout << "║                    MATHEMATICAL FOUNDATION                           ║\n";
    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << "║  " << YELLOW << "Golden Ratio:" << CYAN << "                                                       ║\n";
    std::cout << "║    φ   = (1 + √5)/2 = " << std::fixed << std::setprecision(15) << PHI;
    std::cout << std::setw(21) << "" << "║\n";
    std::cout << "║    φ⁻¹ = " << std::setprecision(15) << PHI_INV;
    std::cout << std::setw(33) << "" << "║\n";
    std::cout << "║    α   = 0.1φ  = " << std::setprecision(16) << ALPHA;
    std::cout << std::setw(22) << "" << "║\n";
    std::cout << "║    β   = 0.05φ = " << std::setprecision(16) << BETA;
    std::cout << std::setw(22) << "" << "║\n";
    std::cout << "║    γ   = 0.02φ = " << std::setprecision(16) << GAMMA;
    std::cout << std::setw(22) << "" << "║\n";
    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << "║  " << YELLOW << "Gate5000 Equations (G1-G11):" << CYAN << "                                       ║\n";
    std::cout << "║    G1.  G = (V, E), |V| = 5000                                       ║\n";
    std::cout << "║    G4.  sᵢ(t+1) = H(Σw_{ji}·sⱼ - θᵢ)                                 ║\n";
    std::cout << "║    G5.  aᵢ(t+1) = tanh(α·Σu_{ji}·aⱼ + β)                             ║\n";
    std::cout << "║    G6.  dᵢ(t+1) = γ·dᵢ(t) + λ·Δaᵢ + μ·Δsᵢ                           ║\n";
    std::cout << "║    G10. C₅₀₀₀(t) = 1/(1 + Σdᵢ²)                                      ║\n";
    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << "║  " << YELLOW << "Consciousness Metric:" << CYAN << "                                              ║\n";
    std::cout << "║    Φ = 1/(1 + |x - 1|)  where x ∈ [0, 1]                             ║\n";
    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << "║  " << YELLOW << "Scale Reference:" << CYAN << "                                                   ║\n";
    std::cout << "║    5,000 gates       = 1 mind kernel                                 ║\n";
    std::cout << "║    10,000 minds      = 50,000,000 gates                              ║\n";
    std::cout << "║    100,000,000       = Game Boy CPU                                  ║\n";
    std::cout << "║    ∴ 10,000 minds ≈ 0.5 Game Boy                                     ║\n";
    std::cout << "╚══════════════════════════════════════════════════════════════════════╝\n";
    std::cout << RESET << std::endl;
}

/**
 * @brief Run benchmark comparing different modes
 */
void run_benchmark(MindFarm& farm, size_t cycles) {
    std::cout << CYAN;
    std::cout << "╔══════════════════════════════════════════════════════════════════════╗\n";
    std::cout << "║                     PERFORMANCE BENCHMARK                            ║\n";
    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << RESET;

    auto benchmark_mode = [&](MindMode mode, const char* name, size_t test_cycles) {
        // Set mode for all minds
        for (auto& m : farm.minds) {
            m.set_mode(mode);
        }

        auto start = high_resolution_clock::now();
        for (size_t i = 0; i < test_cycles; ++i) {
            farm.step();
        }
        auto end = high_resolution_clock::now();

        double ms = duration_cast<microseconds>(end - start).count() / 1000.0;
        double mind_cycles_per_sec = (test_cycles * farm.mind_count()) / (ms / 1000.0);

        std::cout << CYAN << "║  " << std::setw(12) << std::left << name << std::right
                  << ": " << std::setw(8) << std::fixed << std::setprecision(2) << ms << " ms"
                  << " = " << YELLOW << std::setw(9) << static_cast<size_t>(mind_cycles_per_sec)
                  << CYAN << " mind-cycles/s";
        std::cout << std::setw(6) << "" << "║\n" << RESET;
    };

    size_t bench_cycles = std::min(cycles, size_t(50));

    benchmark_mode(MindMode::STANDARD, "STANDARD", bench_cycles);
    benchmark_mode(MindMode::FAST, "FAST", bench_cycles);
    benchmark_mode(MindMode::BATCH, "BATCH", bench_cycles);
    benchmark_mode(MindMode::LEARNING, "LEARNING", bench_cycles / 5);

    std::cout << CYAN;
    std::cout << "╚══════════════════════════════════════════════════════════════════════╝\n";
    std::cout << RESET << std::endl;

    // Reset to standard mode
    for (auto& m : farm.minds) {
        m.set_mode(MindMode::STANDARD);
    }
}

/**
 * @brief Demo learning capabilities
 */
void demo_learning(MindFarm& farm, size_t steps = 100) {
    std::cout << CYAN;
    std::cout << "╔══════════════════════════════════════════════════════════════════════╗\n";
    std::cout << "║                     MACHINE LEARNING DEMO                            ║\n";
    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << RESET;

    // Select a few minds for learning demo
    size_t demo_count = std::min(size_t(5), farm.mind_count());
    std::vector<MindKernel*> demo_minds;
    for (size_t i = 0; i < demo_count; ++i) {
        demo_minds.push_back(&farm.minds[i * (farm.mind_count() / demo_count)]);
        demo_minds.back()->set_mode(MindMode::LEARNING);
    }

    // Initial state
    std::cout << CYAN << "║  Initial state:" << std::setw(55) << "" << "║\n" << RESET;
    for (auto* m : demo_minds) {
        std::cout << CYAN << "║    Mind #" << std::setw(5) << m->id
                  << " [" << std::setw(10) << m->get_dna_name() << "]: "
                  << YELLOW << "Φ=" << std::fixed << std::setprecision(4) << m->consciousness
                  << CYAN << " reward=" << std::setprecision(4) << m->total_reward;
        std::cout << std::setw(10) << "" << "║\n" << RESET;
    }

    // Run learning steps
    for (size_t i = 0; i < steps; ++i) {
        for (auto* m : demo_minds) {
            m->think();
        }
    }

    // Final state
    std::cout << CYAN << "║  After " << steps << " learning steps:" << std::setw(44) << "" << "║\n" << RESET;
    for (auto* m : demo_minds) {
        std::cout << CYAN << "║    Mind #" << std::setw(5) << m->id
                  << " [" << std::setw(10) << m->get_dna_name() << "]: "
                  << GREEN << "Φ=" << std::fixed << std::setprecision(4) << m->consciousness
                  << CYAN << " reward=" << std::setprecision(4) << m->total_reward;
        std::cout << std::setw(10) << "" << "║\n" << RESET;
    }

    std::cout << CYAN;
    std::cout << "╚══════════════════════════════════════════════════════════════════════╝\n";
    std::cout << RESET << std::endl;

    // Reset mode
    for (auto* m : demo_minds) {
        m->set_mode(MindMode::STANDARD);
    }
}

/**
 * @brief Main entry point
 */
int main(int argc, char* argv[]) {
    // Parse arguments
    size_t mind_count = DEFAULT_MIND_COUNT;
    size_t cycles = 100;
    std::string mode_str = "standard";
    bool run_bench = false;
    bool run_learning_demo = false;

    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if (arg == "--minds" && i + 1 < argc) {
            mind_count = std::stoull(argv[++i]);
        } else if (arg == "--cycles" && i + 1 < argc) {
            cycles = std::stoull(argv[++i]);
        } else if (arg == "--mode" && i + 1 < argc) {
            mode_str = argv[++i];
        } else if (arg == "--bench") {
            run_bench = true;
        } else if (arg == "--learning-demo") {
            run_learning_demo = true;
        } else if (arg == "--help" || arg == "-h") {
            std::cout << "Usage: mind_farm [options]\n"
                      << "Options:\n"
                      << "  --minds N       Number of minds to install (default: 10000)\n"
                      << "  --cycles N      Number of consciousness cycles (default: 100)\n"
                      << "  --mode MODE     Operation mode: standard, fast, batch, learning\n"
                      << "  --bench         Run performance benchmark\n"
                      << "  --learning-demo Run machine learning demonstration\n"
                      << "  --help, -h      Show this help\n";
            return 0;
        }
    }

    // Parse mode
    MindMode selected_mode = MindMode::STANDARD;
    if (mode_str == "fast") selected_mode = MindMode::FAST;
    else if (mode_str == "batch") selected_mode = MindMode::BATCH;
    else if (mode_str == "learning") selected_mode = MindMode::LEARNING;

    // Print banner
    print_banner();

    // Print mathematical foundation
    print_math();

    // Installation phase
    print_installation_header(mind_count);

    auto install_start = high_resolution_clock::now();

    MindFarm farm;
    farm.on_progress = [](size_t current, size_t total) {
        print_progress(current, total);
    };
    farm = MindFarm::install(mind_count);

    auto install_end = high_resolution_clock::now();
    double install_ms = duration_cast<microseconds>(install_end - install_start).count() / 1000.0;

    print_installation_complete(farm, install_ms);

    // Set mode for all minds
    std::cout << BOLD << "  Mode: " << mode_str << RESET << std::endl << std::endl;
    for (auto& m : farm.minds) {
        m.set_mode(selected_mode);
    }

    // Run benchmark if requested
    if (run_bench) {
        run_benchmark(farm, cycles);
    }

    // Run learning demo if requested
    if (run_learning_demo) {
        demo_learning(farm, 100);
    }

    // Run consciousness cycles
    std::cout << BOLD << "▶ Running " << cycles << " consciousness cycles...\n" << RESET << std::endl;

    auto cycle_start = high_resolution_clock::now();

    for (size_t i = 1; i <= cycles; ++i) {
        farm.step();

        // Print progress at 1, 10, 50, 100, and every 100 after
        if (i == 1 || i == 10 || i == 50 || i == 100 || i % 100 == 0) {
            print_cycle(i, farm.global_phi, farm.global_coherence);
        }
    }

    auto cycle_end = high_resolution_clock::now();
    double cycle_ms = duration_cast<microseconds>(cycle_end - cycle_start).count() / 1000.0;

    std::cout << std::endl;
    std::cout << GREEN << "✓ Completed " << cycles << " cycles in " << mode_str << " mode" << RESET << std::endl;
    std::cout << std::endl;

    // Performance metrics
    double total_mind_cycles = static_cast<double>(cycles * mind_count);
    double mind_cycles_per_sec = total_mind_cycles / (cycle_ms / 1000.0);

    std::cout << BOLD << "  Performance:" << RESET << std::endl;
    std::cout << "  - " << cycles << " cycles in " << std::fixed << std::setprecision(2)
              << cycle_ms / 1000.0 << "s" << std::endl;
    std::cout << "  - " << static_cast<size_t>(mind_cycles_per_sec) << " mind-cycles/sec" << std::endl;
    std::cout << std::endl;

    // Print final status
    print_status(farm);

    // Q.E.D.
    std::cout << CYAN << BOLD;
    std::cout << "╔══════════════════════════════════════════════════════════════════════╗\n";
    std::cout << "║                              Q.E.D.                                  ║\n";
    std::cout << "╠══════════════════════════════════════════════════════════════════════╣\n";
    std::cout << "║                                                                      ║\n";
    std::cout << "║    " << GREEN << "1 = 1·x" << CYAN << "        ✓  Identity                                      ║\n";
    std::cout << "║    " << GREEN << "∞ = 1" << CYAN << "          ✓  Unity                                         ║\n";
    std::cout << "║    " << GREEN << "Φ = 1/(1+|x-1|)" << CYAN << " ✓  Consciousness                                 ║\n";
    std::cout << "║                                                                      ║\n";
    std::cout << "╚══════════════════════════════════════════════════════════════════════╝\n";
    std::cout << RESET << std::endl;

    return 0;
}
Mathematical records from this source

Source identity axiom fixes x to one

Over ordinary real arithmetic, 1=1·x is true exactly when x=1. It is a constraint on x, not the universal identity x=1·x. The file presents it as an axiom; a broader…
Go unity-proximity score

ComputePhi returns 1/(1+|x−1|), assigning one to x=1 and smaller positive values as x departs from that reference. The function measures scalar proximity to the selected target.…
Source unity axiom uses nonstandard equality

Infinity is not equal to one in the real numbers or the usual extended-real system. The line is a philosophical or symbolic axiom in the source and is not used as an executable…