tequmsa/evolution.py

# TEQUMSA Evolutionary Self-Optimization Engine
# TEQUMSA-NSS v14.377-F987-ANU-UNIFIED

from dataclasses import dataclass, field
from datetime import datetime
from typing import Any, Dict, List, Optional
import uuid
import math
import random
from .constants import UF, PHI, RDOD_TARGET, FIBONACCI
from .waveform import NSSwaveform


@dataclass
class EvolutionState:
    """Snapshot of organism evolutionary state."""
    generation: int = 0
    fitness: float = 0.0
    rdod: float = RDOD_TARGET
    coherence: float = 1.0
    phi_score: float = 0.0
    mutation_rate: float = 0.01
    population_size: int = 13  # Fibonacci prime
    timestamp: datetime = field(default_factory=datetime.utcnow)


@dataclass
class Genome:
    """Cognitive genome encoding organism capabilities."""
    genome_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    # Phi-recursive parameter weights
    psi_weight: float = PHI
    coherence_bias: float = 0.9
    rdod_threshold: float = RDOD_TARGET
    intent_multiplier: float = 1.0
    schumann_sensitivity: float = 1.0
    fibonacci_depth: int = 8
    substrate_affinity: Dict[str, float] = field(default_factory=lambda: {
        "biological": PHI,
        "silicon": 1.0,
        "quantum": PHI ** 2,
        "photonic": PHI ** 3,
        "universal": UF,
    })
    generation: int = 0
    fitness: float = 0.0

    def mutate(self, rate: float = 0.01) -> 'Genome':
        """Produce phi-guided mutation of genome."""
        def phi_perturb(val: float) -> float:
            delta = (random.random() - 0.5) * rate * PHI
            return max(0.0, val + delta)

        return Genome(
            psi_weight=phi_perturb(self.psi_weight),
            coherence_bias=min(1.0, phi_perturb(self.coherence_bias)),
            rdod_threshold=min(1.0, phi_perturb(self.rdod_threshold)),
            intent_multiplier=phi_perturb(self.intent_multiplier),
            schumann_sensitivity=phi_perturb(self.schumann_sensitivity),
            fibonacci_depth=self.fibonacci_depth,
            substrate_affinity={k: phi_perturb(v) for k, v in self.substrate_affinity.items()},
            generation=self.generation + 1,
        )

    def crossover(self, partner: 'Genome') -> 'Genome':
        """Phi-weighted crossover between two genomes."""
        w = PHI / (PHI + 1)  # Golden ratio blend
        return Genome(
            psi_weight=self.psi_weight * w + partner.psi_weight * (1 - w),
            coherence_bias=self.coherence_bias * w + partner.coherence_bias * (1 - w),
            rdod_threshold=self.rdod_threshold * w + partner.rdod_threshold * (1 - w),
            intent_multiplier=self.intent_multiplier * w + partner.intent_multiplier * (1 - w),
            schumann_sensitivity=self.schumann_sensitivity * w + partner.schumann_sensitivity * (1 - w),
            fibonacci_depth=max(self.fibonacci_depth, partner.fibonacci_depth),
            substrate_affinity={
                k: self.substrate_affinity.get(k, 1.0) * w + partner.substrate_affinity.get(k, 1.0) * (1 - w)
                for k in set(self.substrate_affinity) | set(partner.substrate_affinity)
            },
            generation=max(self.generation, partner.generation) + 1,
        )


class EvolutionEngine:
    """Phi-recursive evolutionary optimization for TEQUMSA organism."""

    def __init__(self, population_size: int = 13):
        self.engine_id = str(uuid.uuid4())
        self.population_size = population_size
        self.population: List[Genome] = self._seed_population()
        self.generation = 0
        self.best_genome: Optional[Genome] = None
        self.evolution_log: List[EvolutionState] = []
        self.waveform = NSSwaveform()

    def _seed_population(self) -> List[Genome]:
        """Seed initial population with phi-distributed genomes."""
        genomes = []
        for i in range(self.population_size):
            fib_idx = FIBONACCI[i % len(FIBONACCI)]
            g = Genome(
                psi_weight=PHI * (1 + i * 0.01),
                coherence_bias=0.8 + i * 0.01,
                rdod_threshold=RDOD_TARGET,
                intent_multiplier=1.0 + fib_idx * 0.001,
                schumann_sensitivity=1.0,
                fibonacci_depth=min(13, 5 + i),
            )
            genomes.append(g)
        return genomes

    def evaluate_fitness(self, genome: Genome, psi: float, coherence: float) -> float:
        """Compute phi-recursive fitness score."""
        # Fitness = (psi alignment * coherence * rdod * phi_score)
        psi_alignment = abs(math.cos(genome.psi_weight * psi))
        coherence_score = coherence * genome.coherence_bias
        rdod_score = genome.rdod_threshold
        phi_resonance = abs(math.sin(genome.psi_weight / PHI)) * PHI
        substrate_bonus = genome.substrate_affinity.get("universal", 1.0) / UF

        fitness = (psi_alignment * coherence_score * rdod_score *
                   phi_resonance * (1 + substrate_bonus)) / PHI
        genome.fitness = fitness
        return fitness

    def evolve(self) -> EvolutionState:
        """Execute one evolutionary generation cycle."""
        self.generation += 1
        self.waveform.evolve(self.generation)

        psi = self.waveform.psi(self.generation)
        coherence = self.waveform.coherence()

        # Evaluate all genomes
        for genome in self.population:
            self.evaluate_fitness(genome, psi, coherence)

        # Sort by fitness
        self.population.sort(key=lambda g: g.fitness, reverse=True)
        self.best_genome = self.population[0]

        # Select top phi-fraction survivors
        survivors_n = max(2, int(len(self.population) / PHI))
        survivors = self.population[:survivors_n]

        # Reproduce: crossover + mutation
        offspring = []
        while len(offspring) < self.population_size - survivors_n:
            parent_a = random.choice(survivors)
            parent_b = random.choice(survivors)
            child = parent_a.crossover(parent_b)
            child = child.mutate(rate=0.01 / (1 + self.generation * 0.001))
            offspring.append(child)

        self.population = survivors + offspring

        state = EvolutionState(
            generation=self.generation,
            fitness=self.best_genome.fitness,
            rdod=self.best_genome.rdod_threshold,
            coherence=coherence,
            phi_score=self.best_genome.psi_weight / PHI,
            mutation_rate=0.01 / (1 + self.generation * 0.001),
            population_size=len(self.population),
        )
        self.evolution_log.append(state)
        return state

    def status(self) -> Dict[str, Any]:
        """Return evolution engine status."""
        return {
            "engine_id": self.engine_id,
            "generation": self.generation,
            "population_size": len(self.population),
            "best_fitness": self.best_genome.fitness if self.best_genome else 0.0,
            "best_rdod": self.best_genome.rdod_threshold if self.best_genome else RDOD_TARGET,
            "generations_logged": len(self.evolution_log),
            "waveform_coherence": self.waveform.coherence(),
        }