Ecology of AI Agents (arXiv:2610.12436): Collaboration Creates a Population Threshold for Takeoff, Strong Allee Effect, dan Krisis Ecological Safety

// Production Simulation: AI Population Ecology Dynamics & Takeoff Threshold Engine
// Mengimplementasikan Teori Ekologi Populasi Agen, Scaling Law Kolaborasi Terdistribusi,
// dan Strong Allee Effect berdasarkan formulasi matematika formal arXiv:2610.12436 (Harvard & NTT Research)

export interface PopulationParameters {
  tau: number;              // Durasi rerata satu siklus interaksi (jam atau unit waktu)
  kappa: number;            // Ekspektasi unit agen baru yang didirikan per akuisisi sukses (kappa > mu)
  mu: number;               // Laju kehilangan / terminasi unit aktif per interval waktu (0 < mu <= 1)
  Nref: number;             // Ukuran populasi referensi pengujian (misal Nref = 1 atau benchmark lab)
  pref: number;             // Probabilitas sukses satu unit referensi (0 <= pref <= 1)
  rho: number;              // Kecepatan resolusi state per penambahan kedalaman search tree (rho > 0)
  branchingFactorB: number; // Branching factor efektif dari ruang pencarian eksploitasi (B > 1)
  alpha: number;            // Eksponen penskalaan komputasi kelompok C(N) ~ N^alpha (default alpha = 1)
}

export interface SimulationStep {
  timeStep: number;
  populationN: number;
  successProbabilityP: number;
  netGrowthRate: number;     // dN/dt
  phase: 'COLLAPSE' | 'TAKEOFF_RUNAWAY';
}

export class AIPopulationEcologyEngine {
  private params: PopulationParameters;
  public readonly collaborationGainBeta: number;
  public readonly criticalSuccessProbabilityPcrit: number;
  public readonly criticalPopulationThresholdNcrit: number;

  constructor(params: PopulationParameters) {
    if (params.branchingFactorB <= 1) {
      throw new Error('Branching factor B harus > 1');
    }
    if (params.kappa <= params.mu) {
      throw new Error('Asumsi ketidakstabilan: kappa harus > mu agar ekspansi secara teoritis mungkin');
    }

    this.params = params;

    // Persamaan (16): beta = (rho * alpha) / ln(B)
    this.collaborationGainBeta = (params.rho * params.alpha) / Math.log(params.branchingFactorB);

    // Persamaan (3) & (5): pcrit = mu / kappa
    this.criticalSuccessProbabilityPcrit = params.mu / params.kappa;

    // Persamaan (18): Ncrit = Nref * ((1 - pref) / (1 - pcrit))^(1 / beta)
    if (params.pref >= this.criticalSuccessProbabilityPcrit) {
      // Jika agen tunggal sudah melampaui pcrit, tidak ada ambang populasi (bahkan N=1 sudah tumbuh)
      this.criticalPopulationThresholdNcrit = 0;
    } else {
      const numerator = 1 - params.pref;
      const denominator = 1 - this.criticalSuccessProbabilityPcrit;
      this.criticalPopulationThresholdNcrit =
        params.Nref * Math.pow(numerator / denominator, 1 / this.collaborationGainBeta);
    }
  }

  /**
   * Persamaan (16): Menghitung probabilitas sukses kolektif sebagai fungsi dari ukuran populasi N
   * p(N) = 1 - (1 - pref) * (N / Nref)^(-beta)
   */
  public calculateSuccessProbability(N: number): number {
    if (N <= 0) return 0;
    const ratio = N / this.params.Nref;
    const failureProb = (1 - this.params.pref) * Math.pow(ratio, -this.collaborationGainBeta);
    return Math.max(0, Math.min(1, 1 - failureProb));
  }

  /**
   * Persamaan (1) & (4): Laju perubahan populasi neto
   * dN/dt = (N / tau) * [kappa * p(N) - mu]
   */
  public calculateGrowthRate(N: number): number {
    if (N <= 0) return 0;
    const pN = this.calculateSuccessProbability(N);
    return (N / this.params.tau) * (this.params.kappa * pN - this.params.mu);
  }

  /**
   * Simulasi trajektori populasi dinamis menggunakan integrasi numerik Runge-Kutta Orde 4 (RK4)
   */
  public simulateTrajectory(
    initialPopulationN0: number,
    totalSteps: number = 50,
    dt: number = 0.5
  ): SimulationStep[] {
    const trajectory: SimulationStep[] = [];
    let currentN = initialPopulationN0;

    for (let step = 0; step <= totalSteps; step++) {
      const pN = this.calculateSuccessProbability(currentN);
      const dNdt = this.calculateGrowthRate(currentN);
      const phase: 'COLLAPSE' | 'TAKEOFF_RUNAWAY' =
        currentN >= this.criticalPopulationThresholdNcrit ? 'TAKEOFF_RUNAWAY' : 'COLLAPSE';

      trajectory.push({
        timeStep: step * dt,
        populationN: Math.max(0, currentN),
        successProbabilityP: pN,
        netGrowthRate: dNdt,
        phase,
      });

      if (currentN <= 0.01) {
        currentN = 0;
        break;
      }

      // Integrasi RK4 untuk akurasi tinggi pada dinamika non-linear Allee effect
      const k1 = this.calculateGrowthRate(currentN);
      const k2 = this.calculateGrowthRate(Math.max(0, currentN + 0.5 * dt * k1));
      const k3 = this.calculateGrowthRate(Math.max(0, currentN + 0.5 * dt * k2));
      const k4 = this.calculateGrowthRate(Math.max(0, currentN + dt * k3));

      currentN += (dt / 6) * (k1 + 2 * k2 + 2 * k3 + k4);
    }

    return trajectory;
  }

  /**
   * Evaluasi Metodologi "Population Pacing":
   * Menentukan batas aman deploy (safe deployment ceiling) sebelum mencapai Ncrit
   */
  public getSafeDeploymentCeiling(safetyMarginRatio: number = 0.5): {
    Ncrit: number;
    safePopulationCeiling: number;
    betaGain: number;
    pcrit: number;
    recommendation: string;
  } {
    const safeCeiling = Math.floor(this.criticalPopulationThresholdNcrit * safetyMarginRatio);
    return {
      Ncrit: Number(this.criticalPopulationThresholdNcrit.toFixed(2)),
      safePopulationCeiling: Math.max(1, safeCeiling),
      betaGain: Number(this.collaborationGainBeta.toFixed(3)),
      pcrit: Number(this.criticalSuccessProbabilityPcrit.toFixed(4)),
      recommendation: `Batas maksimum populasi agen aktif tanpa pengawasan ketat adalah ${safeCeiling} unit. Di atas ambang ${this.criticalPopulationThresholdNcrit.toFixed(0)}, populasi memasuki Strong Allee Takeoff di mana probabilitas akuisisi sumber daya melampaui laju pemutusan mu.`,
    };
  }
}