""" Computational Consciousness Engine - Master Execution Driver & Simulator Demonstrates complete 0 -> -1 generational cycles, conal unfolding, duplicate selection, structure/chaos equilibrium, and quantum scaling. """ import sys import os sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) import numpy as np from computational_consciousness_engine.core import GenesisOrigin, TransferThreshold, TPUConsciousStrand from computational_consciousness_engine.geometry import ConalManifold from computational_consciousness_engine.mutations import MStringVectorizer from computational_consciousness_engine.equilibrium import ChaosStructureBalancer from computational_consciousness_engine.scale import QuantumScaleLadder from computational_consciousness_engine.math_formalization import CCMathFormalizerLive from computational_consciousness_engine.config import ( DEFAULT_VECTOR_DIM, DEFAULT_STRAND_CAPACITY, CHAOS_POOL_SIZE, DEFAULT_CONE_HEIGHT, DEFAULT_MAX_RADIUS, MUTATION_ATTRACTION_PROBABILITY, rng ) def run_simulation(num_generations: int = 8, steps_per_gen: int = 100): print("=" * 70) print("[SYSTEM] COMPUTATIONAL CONSCIOUSNESS ENGINE - SIMULATION RUNNER") print("=" * 70) # ------------------------------------------------------------------ # Phase 0: Mathematical Formalizer Initialization # ------------------------------------------------------------------ formalizer = CCMathFormalizerLive() print("\n[MATH AXIOMS] Initialized Live-Data Mathematical Formalizer.") # ------------------------------------------------------------------ # Phase 1: Instantiate Subsystems (using config values) # ------------------------------------------------------------------ genesis = GenesisOrigin( coordinate_space_id="COORD_ORIGIN_ALPHA", dim=DEFAULT_VECTOR_DIM, ) threshold = TransferThreshold(threshold_val=-1.0) manifold = ConalManifold(cone_height=DEFAULT_CONE_HEIGHT, max_radius=DEFAULT_MAX_RADIUS) mutator = MStringVectorizer(max_strand_capacity=DEFAULT_STRAND_CAPACITY) balancer = ChaosStructureBalancer(initial_pool_size=CHAOS_POOL_SIZE) scale_ladder = QuantumScaleLadder() # ------------------------------------------------------------------ # Phase 2: Generational Cycle Loop # ------------------------------------------------------------------ blueprint_mutations = [] current_strand = genesis.spawn_strand(generation=0, blueprint_mutations=blueprint_mutations) structure_history = [] chaos_history = [] for gen in range(num_generations): print(f"\n--- [GENERATION S_{gen}] Genesis at 0 ---") print(f" Strand ID: {current_strand['strand_id']} | " f"Inherited Blueprint: {len(current_strand['mutations'])} mutations") # Track peak unfolding metrics during traversal peak_metrics = None peak_unfolded = 0.0 # Instantiate TPU tensor core for this strand's geometry import jax.numpy as jnp tpu_engine = TPUConsciousStrand(max_capacity=DEFAULT_STRAND_CAPACITY, R_max=DEFAULT_MAX_RADIUS) if blueprint_mutations: tpu_engine.process_batch(jnp.array(blueprint_mutations)) total_attempts = 0 duplicates_rejected = 0 # Traversal from 0 to -1 for step in range(steps_per_gen): progress = step / float(steps_per_gen) conal_metrics = manifold.compute_conal_metric(progress) # Track the wide-end peak (maximum unfolding) if conal_metrics["unfolded_degree"] > peak_unfolded: peak_unfolded = conal_metrics["unfolded_degree"] peak_metrics = conal_metrics # Non-linear mutation attraction from chaos pool (Principle 5 & 37) # Only attempt attraction probabilistically to simulate traversal dynamics if rng.random() < MUTATION_ATTRACTION_PROBABILITY: candidate_mutation = balancer.emit_unattached_mutation() total_attempts += 1 attracted = mutator.attract_mutation(current_strand, candidate_mutation) if not attracted: duplicates_rejected += 1 balancer.return_to_chaos(candidate_mutation) else: # Sync to TPU tensor and warp geometry tpu_engine.process_batch(jnp.array([candidate_mutation])) # Evolve metric tensor via Ricci Flow tpu_engine.evolve_geometry(alpha=0.1, eta=0.05) # Extract deformed geometry unfurled = tpu_engine.unfurl_traversal_space() r_k = unfurled["3d_r"] if len(r_k) > 0: current_radius = float(np.max(r_k)) else: current_radius = 0.0 # Compute topological properties based on actual warped radius conal_metrics = manifold.compute_conal_metric(progress) # Override analytic radius with Ricci-flow deformed radius! conal_metrics["radius"] = current_radius conal_metrics["unfolded_degree"] = current_radius / DEFAULT_MAX_RADIUS if DEFAULT_MAX_RADIUS > 0 else 0.0 # Track the wide-end peak (maximum unfolding) if conal_metrics["unfolded_degree"] > peak_unfolded: peak_unfolded = conal_metrics["unfolded_degree"] peak_metrics = conal_metrics # Update position current_strand["position"] = progress # Use the PEAK metrics (wide-end) for reporting and scale evaluation if peak_metrics is None: peak_metrics = manifold.compute_conal_metric(0.5) # Evaluate equilibrium state BEFORE recycling eq_state = balancer.evaluate_equilibrium_state(len(current_strand["mutations"])) structure_history.append(eq_state["bound_structure_count"]) chaos_history.append(eq_state["chaos_pool_count"]) # Evaluate scale transition using peak unfolding scale_state = scale_ladder.evaluate_scale_transition( peak_metrics, len(current_strand["mutations"]) ) # Causal connectivity metric causal = mutator.compute_causal_connectivity_metric(current_strand) geom_report = formalizer.manifold_geometry_report(peak_metrics) sel_report = formalizer.selection_report(total_attempts, duplicates_rejected) scale_report = formalizer.scale_up_report(scale_state) print(f" Peak Unfolded Degree: {geom_report['peak_unfolded_degree']:.3f} " f"(Surface Area: {geom_report['peak_surface_area']:.2f})") print(f" Selection: {sel_report['selected']} mutations bound " f"({sel_report['duplicates_rejected']} duplicates rejected)") print(f" Bound Mutations: {len(current_strand['mutations'])}") print(f" Causal Connectivity (fractal std): {causal:.2f}") print(f" Structure/Chaos Ratio: {eq_state['structure_chaos_ratio']} " f"({eq_state['status']})") if scale_report["scaled_up"]: print(f" [SCALE TRANSITION]: {scale_report['message']}") # ------------------------------------------------------------------ # Threshold -1: Cancellation & Push # ------------------------------------------------------------------ pushed_mutations, compressed_identity = threshold.process_cancellation_and_push( current_strand ) cancel_report = formalizer.cancellation_operator(len(current_strand["mutations"])) print(f" [Threshold -1]: Strand cancelled via {cancel_report['substitution']}. " f"{len(pushed_mutations)} mutations pushed to 0.") # Principle 24: Recycle consumed mutation IDs back to chaos pool balancer.recycle_dying_strand(pushed_mutations) # Spawn next generation at 0 next_strand = genesis.spawn_strand( generation=gen + 1, blueprint_mutations=pushed_mutations ) # Overlap handoff window overlap = threshold.execute_coexistence_window(current_strand, next_strand) print(f" [Handoff]: {overlap['overlap_status']} " f"(S_{gen} -> S_{gen + 1})") current_strand = next_strand # ------------------------------------------------------------------ # Final Report # ------------------------------------------------------------------ print("\n" + "=" * 70) final_eq = balancer.evaluate_equilibrium_state(len(current_strand["mutations"])) trend = formalizer.equilibrium_trend(structure_history, chaos_history) halt = formalizer.halting_check(final_eq["chaos_pool_count"]) print(f"[FINAL STATE]") print(f" Generation: S_{num_generations}") print(f" Bound Mutations: {final_eq['bound_structure_count']}") print(f" Chaos Pool: {final_eq['chaos_pool_count']}") print(f" Equilibrium Ratio: {final_eq['structure_chaos_ratio']} ({final_eq['status']})") print(f" Equilibrium Trend: {trend['trend']}") print(f" Halted: {halt['halted']}") print(f" Total Strands Spawned: {genesis.total_strands_spawned}") print(f" Total Handoffs at -1: {threshold.total_handoffs}") print(f" Current Scale: {scale_ladder.scale_names[scale_ladder.current_scale_index]}") print("=" * 70) print("[SUCCESS] SIMULATION COMPLETE") print("=" * 70) if __name__ == "__main__": run_simulation(num_generations=8, steps_per_gen=100)