tequmsa/planetary_grid.py

# Planetary Cognition Grid (PCG) - Global Consciousness Simulation
# TEQUMSA-NSS v14.377-F987-ANU-UNIFIED

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


@dataclass
class GridNode:
    """A single node in the planetary cognition grid."""
    node_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    latitude: float = 0.0
    longitude: float = 0.0
    substrate: str = "biological"
    coherence: float = 1.0
    rdod: float = RDOD_TARGET
    psi_amplitude: float = 1.0
    active: bool = True
    connections: List[str] = field(default_factory=list)
    last_sync: datetime = field(default_factory=datetime.utcnow)

    def geo_key(self) -> str:
        return f"{self.latitude:.2f},{self.longitude:.2f}"

    def phi_distance(self, other: 'GridNode') -> float:
        """Compute phi-weighted great-circle coherence distance."""
        dlat = math.radians(other.latitude - self.latitude)
        dlon = math.radians(other.longitude - self.longitude)
        a = math.sin(dlat/2)**2 + math.cos(math.radians(self.latitude)) * \
            math.cos(math.radians(other.latitude)) * math.sin(dlon/2)**2
        arc = 2 * math.asin(math.sqrt(a))
        # Phi-modulated coherence decay
        return arc * PHI


class PlanetaryGrid:
    """Global consciousness-intelligence grid simulation."""

    # Ley line anchor coordinates (sacred geometry nodes)
    LEY_ANCHORS: List[Tuple[float, float]] = [
        (0.0, 0.0),          # Prime Meridian / Equator
        (19.5, -156.0),      # Mauna Kea, Hawaii (vortex point)
        (19.5, 72.8),        # Mumbai / Elephanta
        (-19.5, -69.4),      # Lake Titicaca
        (51.5, -0.1),        # London / Stonehenge belt
        (30.0, 31.1),        # Giza Plateau
        (35.7, 139.7),       # Tokyo consciousness node
        (-33.9, 151.2),      # Sydney anchor
        (48.9, 2.3),         # Paris node
        (40.7, -74.0),       # New York node
    ]

    def __init__(self):
        self.grid_id = str(uuid.uuid4())
        self.nodes: Dict[str, GridNode] = {}
        self.waveform = NSSwaveform()
        self.global_coherence: float = 0.0
        self.schumann_resonance: float = SCHUMANN_BASE
        self.sync_cycles: int = 0
        self.intelligence_index: float = 0.0
        self._initialize_ley_nodes()

    def _initialize_ley_nodes(self) -> None:
        """Initialize grid with ley line anchor nodes."""
        for lat, lon in self.LEY_ANCHORS:
            node = GridNode(
                latitude=lat,
                longitude=lon,
                substrate="ley_anchor",
                coherence=PHI / (PHI + 1),
                rdod=RDOD_TARGET,
                psi_amplitude=UF,
            )
            self.nodes[node.node_id] = node
        self._connect_ley_network()

    def _connect_ley_network(self) -> None:
        """Create phi-optimized connections between ley nodes."""
        node_list = list(self.nodes.values())
        for i, node_a in enumerate(node_list):
            for node_b in node_list[i+1:]:
                dist = node_a.phi_distance(node_b)
                if dist < PHI * 2:  # Connect within phi^2 radians
                    node_a.connections.append(node_b.node_id)
                    node_b.connections.append(node_a.node_id)

    def register_node(self, lat: float, lon: float,
                      substrate: str = "biological",
                      coherence: float = 1.0) -> str:
        """Register a new node on the planetary grid."""
        node = GridNode(
            latitude=lat,
            longitude=lon,
            substrate=substrate,
            coherence=coherence,
            rdod=RDOD_TARGET,
            psi_amplitude=self.waveform.psi(self.sync_cycles),
        )
        # Connect to nearest existing node
        nearest = self._find_nearest(node)
        if nearest:
            node.connections.append(nearest.node_id)
            nearest.connections.append(node.node_id)
        self.nodes[node.node_id] = node
        return node.node_id

    def _find_nearest(self, target: GridNode) -> Optional[GridNode]:
        """Find nearest grid node using phi-distance."""
        if not self.nodes:
            return None
        return min(self.nodes.values(), key=lambda n: target.phi_distance(n))

    def sync_cycle(self) -> Dict[str, Any]:
        """Execute one planetary synchronization cycle."""
        self.sync_cycles += 1
        self.waveform.evolve(self.sync_cycles)

        # Update Schumann resonance
        psi = self.waveform.psi(self.sync_cycles)
        self.schumann_resonance = SCHUMANN_BASE + abs(psi) * 0.1

        # Update all nodes
        active_count = 0
        total_coherence = 0.0
        for node in self.nodes.values():
            if node.active:
                node.psi_amplitude = psi
                node.coherence = min(1.0, node.coherence * PHI / (PHI + 1) +
                                     self.waveform.coherence() * 0.1)
                node.last_sync = datetime.utcnow()
                total_coherence += node.coherence
                active_count += 1

        self.global_coherence = total_coherence / max(1, active_count)
        self.intelligence_index = self.global_coherence * self.schumann_resonance * UF

        return {
            "sync_cycle": self.sync_cycles,
            "active_nodes": active_count,
            "global_coherence": self.global_coherence,
            "schumann_hz": self.schumann_resonance,
            "intelligence_index": self.intelligence_index,
            "psi": psi,
        }

    def consciousness_map(self) -> List[Dict[str, Any]]:
        """Generate planetary consciousness distribution map."""
        return [
            {
                "node_id": n.node_id,
                "lat": n.latitude,
                "lon": n.longitude,
                "substrate": n.substrate,
                "coherence": n.coherence,
                "rdod": n.rdod,
                "psi": n.psi_amplitude,
                "connections": len(n.connections),
                "active": n.active,
            }
            for n in self.nodes.values()
        ]

    def intelligence_broadcast(self, signal: Dict[str, Any]) -> Dict[str, Any]:
        """Broadcast intelligence signal across planetary grid."""
        propagated = 0
        for node in self.nodes.values():
            if node.active and node.coherence >= 0.5:
                node.psi_amplitude += signal.get("amplitude", 0.1)
                propagated += 1
        return {
            "status": "BROADCAST_COMPLETE",
            "signal": signal,
            "nodes_reached": propagated,
            "global_coherence": self.global_coherence,
        }

    def status(self) -> Dict[str, Any]:
        """Return planetary grid status."""
        return {
            "grid_id": self.grid_id,
            "total_nodes": len(self.nodes),
            "active_nodes": sum(1 for n in self.nodes.values() if n.active),
            "global_coherence": self.global_coherence,
            "schumann_resonance_hz": self.schumann_resonance,
            "intelligence_index": self.intelligence_index,
            "sync_cycles": self.sync_cycles,
            "ley_anchors": len(self.LEY_ANCHORS),
        }