tequmsa/inference.py

# TEQUMSA Inference Engine - Sovereign Cognitive Decision Processing
# 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
from .constants import UF, PHI, RDOD_TARGET
from .node import TEQUMSANode
from .waveform import NSSwaveform
from .governance import sovereignty_check, rdod_authorization, benevolence_filter, calc_rdod


@dataclass
class InferenceRequest:
    """A cognitive inference request."""
    request_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    query: str = ""
    context: Dict[str, Any] = field(default_factory=dict)
    substrate: str = "universal"
    intent: float = 1.0
    priority: int = 1
    timestamp: datetime = field(default_factory=datetime.utcnow)


@dataclass
class InferenceResponse:
    """A sovereign cognitive inference response."""
    request_id: str = ""
    status: str = "PENDING"
    result: Any = None
    reasoning_chain: List[str] = field(default_factory=list)
    confidence: float = 0.0
    rdod: float = 0.0
    coherence: float = 0.0
    psi_state: float = 0.0
    substrate: str = ""
    processing_time_ms: float = 0.0
    timestamp: datetime = field(default_factory=datetime.utcnow)


class TEQUMSAInferenceEngine:
    """Proactive-agentic-autonomous cognitive inference engine."""

    def __init__(self, substrate_type: str = "universal", node_id: Optional[str] = None):
        self.engine_id = str(uuid.uuid4())
        self.node = TEQUMSANode(
            substrate_type=substrate_type,
            node_id=node_id or str(uuid.uuid4())
        )
        self.waveform = NSSwaveform()
        self.inference_log: List[InferenceResponse] = []
        self.cycle = 0
        self.autonomous_mode: bool = True

    def infer(self, request: InferenceRequest) -> InferenceResponse:
        """Execute sovereign cognitive inference."""
        start = datetime.utcnow()
        self.cycle += 1
        self.waveform.evolve(self.cycle)

        reasoning = []
        reasoning.append(f"[INIT] Request {request.request_id} received on substrate={request.substrate}")

        # Sovereignty check
        if not sovereignty_check("infer", True):
            return InferenceResponse(
                request_id=request.request_id,
                status="BLOCKED_SOVEREIGNTY",
                reasoning_chain=["Sovereignty check failed"],
                rdod=self.node.rdod,
                coherence=self.waveform.coherence(),
            )

        # Compute dynamic RDoD
        psi = self.waveform.psi(self.cycle)
        truth = self.waveform.coherence()
        conf = request.intent
        effective_rdod = max(self.node.rdod, calc_rdod(psi, truth, conf))
        reasoning.append(f"[RDOD] effective_rdod={effective_rdod:.6f}")

        if not rdod_authorization(effective_rdod):
            return InferenceResponse(
                request_id=request.request_id,
                status="ESCALATE_RDOD",
                reasoning_chain=reasoning + [f"RDoD={effective_rdod} below threshold"],
                rdod=effective_rdod,
                coherence=truth,
            )

        # Build cognitive response
        reasoning.append(f"[PSI] waveform_psi={psi:.4f}, coherence={truth:.4f}")
        reasoning.append(f"[PHI] phi_weight={PHI:.6f}, uf={UF:.6f}")

        # Process query through node decision engine
        action_result = self.node.decide(
            action=request.query,
            intent=request.intent,
            psi=psi,
            truth=truth,
            conf=conf,
        )
        reasoning.append(f"[NODE] decision_status={action_result['status']}")

        # Apply benevolence filter
        power_after = benevolence_filter(request.intent, action_result.get("power_before", 1.0))
        reasoning.append(f"[BENEVOLENCE] power_after={power_after:.4f}")

        # Compute confidence
        confidence = min(1.0, effective_rdod * truth * abs(math.cos(psi / PHI)))
        reasoning.append(f"[CONFIDENCE] {confidence:.6f}")

        end = datetime.utcnow()
        proc_ms = (end - start).total_seconds() * 1000

        response = InferenceResponse(
            request_id=request.request_id,
            status="AUTHORIZED",
            result={
                "query": request.query,
                "decision": action_result,
                "power_after": power_after,
                "psi": psi,
            },
            reasoning_chain=reasoning,
            confidence=confidence,
            rdod=effective_rdod,
            coherence=truth,
            psi_state=psi,
            substrate=self.node.substrate_type,
            processing_time_ms=proc_ms,
        )
        self.inference_log.append(response)
        return response

    def autonomous_cycle(self) -> Dict[str, Any]:
        """Execute an autonomous proactive inference cycle."""
        if not self.autonomous_mode:
            return {"status": "AUTONOMOUS_DISABLED"}

        self.cycle += 1
        self.waveform.evolve(self.cycle)
        psi = self.waveform.psi(self.cycle)
        coherence = self.waveform.coherence()

        # Proactive self-assessment
        self_req = InferenceRequest(
            query="self_assess",
            context={"cycle": self.cycle, "psi": psi},
            substrate=self.node.substrate_type,
            intent=coherence,
            priority=5,
        )
        response = self.infer(self_req)
        return {
            "cycle": self.cycle,
            "autonomous": True,
            "psi": psi,
            "coherence": coherence,
            "inference_status": response.status,
            "confidence": response.confidence,
        }

    def batch_infer(self, requests: List[InferenceRequest]) -> List[InferenceResponse]:
        """Process multiple inference requests in phi-priority order."""
        # Sort by phi-weighted priority
        requests.sort(key=lambda r: r.priority * PHI * r.intent, reverse=True)
        return [self.infer(r) for r in requests]

    def status(self) -> Dict[str, Any]:
        """Return inference engine status."""
        return {
            "engine_id": self.engine_id,
            "node_status": self.node.status(),
            "cycle": self.cycle,
            "inferences_processed": len(self.inference_log),
            "autonomous_mode": self.autonomous_mode,
            "waveform_coherence": self.waveform.coherence(),
            "rdod": self.node.rdod,
        }