sum-engine 0.1.0__py3-none-any.whl

internal/ensemble/autonomous_agent.py

@@ -0,0 +1,157 @@
+"""
+Autonomous Crystallizer — The Subconscious Graph Optimizer
+
+A background daemon that monitors the Gödel State and autonomously
+compresses dense topological clusters into Macro-Primes using the
+Fractal Crystallization method from Phase 6.
+
+When a node's topological degree exceeds a configurable threshold,
+the daemon asks the LLM to summarize the cluster and collapses the
+micro-primes into a single macro-prime — all while you sleep.
+
+Author: ototao
+License: Apache License 2.0
+"""
+
+import asyncio
+import math
+import logging
+from typing import Callable, Optional
+
+from internal.algorithms.semantic_arithmetic import GodelStateAlgebra
+from internal.infrastructure.akashic_ledger import AkashicLedger
+
+logger = logging.getLogger(__name__)
+
+
+def _zig():
+    try:
+        from internal.infrastructure.zig_bridge import zig_engine
+        return zig_engine
+    except ImportError:
+        return None
+
+
+class AutonomousCrystallizer:
+    """
+    The Subconscious Graph Optimizer.
+
+    Monitors the Gödel State and autonomously compresses dense
+    topological clusters into Macro-Primes.
+    """
+
+    def __init__(
+        self,
+        algebra: GodelStateAlgebra,
+        ledger: AkashicLedger,
+        summarizer_llm: Callable,
+    ):
+        self.algebra = algebra
+        self.ledger = ledger
+        self.summarize = summarizer_llm  # async func(list[str]) -> str
+        self.is_running = False
+
+    async def run_compaction_cycle(
+        self, global_state: int, threshold: int = 5
+    ) -> int:
+        """
+        Scans the node registry for highly-connected nodes and
+        crystallises their edge clusters into macro-primes.
+
+        Args:
+            global_state: Current Gödel integer.
+            threshold:    Minimum edges before a node triggers compaction.
+
+        Returns:
+            Potentially compressed global state.
+        """
+        new_state = global_state
+
+        for node, node_integer in list(self.algebra.node_registry.items()):
+            z = _zig()
+            zg = z.bigint_gcd(new_state, node_integer) if z else None
+            alive_node_integer = zg if zg is not None else math.gcd(new_state, node_integer)
+
+            # Extract alive axioms connected to this node
+            cluster_axioms: list[str] = []
+            temp_int = alive_node_integer
+            for prime, axiom in self.algebra.prime_to_axiom.items():
+                if temp_int % prime == 0:
+                    cluster_axioms.append(axiom)
+                    while temp_int % prime == 0:
+                        temp_int //= prime
+                if temp_int == 1:
+                    break
+
+            # If the node has too many connections, compress it
+            if len(cluster_axioms) >= threshold:
+                logger.info(
+                    "[Subconscious] Compacting dense node '%s' "
+                    "(%d edges)...",
+                    node,
+                    len(cluster_axioms),
+                )
+
+                # Ask LLM to summarize the cluster
+                macro_predicate = await self.summarize(cluster_axioms)
+                macro_key = (
+                    f"{node}||"
+                    f"{macro_predicate.lower().replace(' ', '_')}||"
+                    f"compressed_cluster"
+                )
+
+                # Fractal Compression (Phase 6)
+                new_state = self.algebra.crystallize_axioms(
+                    new_state, cluster_axioms, macro_key
+                )
+
+                # Log to Akashic Ledger
+                if macro_key in self.algebra.axiom_to_prime:
+                    macro_prime = self.algebra.axiom_to_prime[macro_key]
+                    await self.ledger.append_event(
+                        "MINT", macro_prime, macro_key
+                    )
+                    await self.ledger.append_event("MUL", macro_prime)
+                    for axiom in cluster_axioms:
+                        p = self.algebra.axiom_to_prime.get(axiom)
+                        if p:
+                            await self.ledger.append_event("DIV", p)
+
+        return new_state
+
+    async def start_daemon(
+        self,
+        get_state_func: Callable[[], int],
+        set_state_func: Callable[[int], None],
+        interval: int = 60,
+    ):
+        """
+        Background loop that runs compaction cycles at a fixed interval.
+
+        Args:
+            get_state_func: Callable returning the current global state.
+            set_state_func: Callable to update the global state.
+            interval:       Seconds between cycles.
+        """
+        self.is_running = True
+        logger.info(
+            "[Subconscious] Daemon started — compaction every %ds", interval
+        )
+        while self.is_running:
+            await asyncio.sleep(interval)
+            try:
+                current_state = get_state_func()
+                new_state = await self.run_compaction_cycle(current_state)
+                if new_state != current_state:
+                    set_state_func(new_state)
+                    logger.info(
+                        "[Subconscious] State compacted: %d → %d bits",
+                        current_state.bit_length(),
+                        new_state.bit_length(),
+                    )
+            except Exception as e:
+                logger.error("[Subconscious] Compaction error: %s", e)
+
+    def stop_daemon(self):
+        """Gracefully stop the background daemon."""
+        self.is_running = False

internal/ensemble/causal_triggers.py

@@ -0,0 +1,121 @@
+"""
+Causal Trigger Map — Interacting Theory Engine (Yaroslavtsev §5.7)
+
+Transitions the Knowledge OS from "Free Theory" (isolated axiom minting)
+to "Interacting Theory" where logical rules cascade deductive inferences
+in ACID-compliant transactions.
+
+If A implies B, minting A automatically cascades and mints B in the same
+operation.  Idempotency is guaranteed by Gödel LCM arithmetic — attempting
+to mint an already-entailed prime is a no-op (LCM(state, p) == state).
+
+Author: ototao
+License: Apache License 2.0
+"""
+
+import math
+from typing import Callable, List, Tuple
+
+from internal.algorithms.semantic_arithmetic import GodelStateAlgebra
+from internal.infrastructure.akashic_ledger import AkashicLedger
+from internal.ensemble.epistemic_arbiter import kos_telemetry
+
+
+def _zig():
+    try:
+        from internal.infrastructure.zig_bridge import zig_engine
+        return zig_engine
+    except ImportError:
+        return None
+
+
+class CausalTriggerMap:
+    """
+    Implements Yaroslavtsev's Interacting Theory (Section 5.7).
+
+    Expands primitive axioms into ACID-compliant causal cascades of
+    deductive reasoning.  Rules are registered as (condition, inference)
+    pairs.  When an axiom matching the condition is minted, the inference
+    function produces consequent axioms that are automatically locked
+    into the state.
+    """
+
+    def __init__(self, algebra: GodelStateAlgebra, ledger: AkashicLedger):
+        self.algebra = algebra
+        self.ledger = ledger
+        self.rules: List[Tuple[Callable, Callable]] = []
+
+    def register_rule(self, condition_func: Callable, inference_func: Callable):
+        """
+        Registers an ontological rule (e.g., Transitivity, Syllogisms).
+
+        Args:
+            condition_func:  (s, p, o, state, algebra) -> bool
+            inference_func:  (s, p, o, state, algebra) -> List[(s, p, o)]
+        """
+        self.rules.append((condition_func, inference_func))
+
+    async def apply_cascade(
+        self, current_state: int, delta_axioms: List[str]
+    ) -> int:
+        """
+        Cascades inferences recursively until the semantic state
+        reaches equilibrium.
+
+        Idempotency is guaranteed by Gödel LCM arithmetic —
+        re-minting an existing prime changes nothing.
+
+        Args:
+            current_state: The current Gödel integer.
+            delta_axioms:  Newly added axiom keys (``s||p||o`` format).
+
+        Returns:
+            The updated Gödel integer with all cascaded inferences.
+        """
+        new_state = current_state
+        cascade_queue = list(delta_axioms)
+        visited: set = set()
+
+        while cascade_queue:
+            current_axiom = cascade_queue.pop(0)
+            if current_axiom in visited:
+                continue
+            visited.add(current_axiom)
+
+            parts = current_axiom.split("||")
+            if len(parts) != 3:
+                continue
+            s, p, o = parts
+
+            for condition, infer in self.rules:
+                if condition(s, p, o, new_state, self.algebra):
+                    inferred_triplets = infer(s, p, o, new_state, self.algebra)
+
+                    for inf_s, inf_p, inf_o in inferred_triplets:
+                        inf_axiom = f"{inf_s}||{inf_p}||{inf_o}"
+                        inf_prime = self.algebra.get_or_mint_prime(
+                            inf_s, inf_p, inf_o
+                        )
+
+                        # Novel deductive leap — not yet in state
+                        if new_state % inf_prime != 0:
+                            await kos_telemetry.broadcast(
+                                f"🔗 Causal Inference: "
+                                f"[{current_axiom}] ⟹ [{inf_axiom}]"
+                            )
+
+                            # Lock the inference into the state
+                            z = _zig()
+                            r = z.bigint_lcm(new_state, inf_prime) if z else None
+                            new_state = r if r is not None else math.lcm(new_state, inf_prime)
+
+                            # Persist to Akashic Ledger
+                            await self.ledger.append_event(
+                                "MINT", inf_prime, inf_axiom
+                            )
+                            await self.ledger.append_event("MUL", inf_prime)
+
+                            # Push to queue for further domino effects
+                            cascade_queue.append(inf_axiom)
+
+        return new_state

internal/ensemble/confidence_calibrator.py

@@ -0,0 +1,284 @@
+"""
+Confidence Calibrator — Multi-Signal Automatic Confidence Scoring
+
+Phase 24: Replaces the static 0.5 default with a research-informed
+multi-signal calibration pipeline that runs at zero cost.
+
+Signals:
+    1. Source-type heuristic — URL domain → base confidence
+    2. Redundancy boost — same axiom from N sources → +0.05 per source
+    3. Contradiction penalty — conflicts with existing axioms → ×0.5
+    4. Linguistic certainty — hedging words in source text → multiplier
+
+Optional:
+    4. LLM verbalized confidence — ask model to self-rate (opt-in)
+
+Usage:
+    calibrator = ConfidenceCalibrator()
+    score = await calibrator.calibrate(
+        axiom_key="earth||orbits||sun",
+        source_url="https://nasa.gov/solar-system",
+        ledger=ledger,
+    )
+
+Author: ototao
+License: Apache License 2.0
+"""
+
+import json
+import re
+import logging
+from pathlib import Path
+from typing import Optional, Union
+from urllib.parse import urlparse
+
+from internal.ensemble.venn_abers import ConfidenceInterval, VennAbersCalibrator
+
+logger = logging.getLogger(__name__)
+
+
+# ─── Source-Type Confidence Map ───────────────────────────────────────
+# Based on NAACL 2024 research on source credibility and calibration.
+# These represent base confidence scores for different source types.
+
+SOURCE_PATTERNS = [
+    # (compiled regex for domain, base_confidence, label)
+    # ── Specific domains first (before generic TLDs) ──
+    (re.compile(r"arxiv\.org"), 0.88, "arxiv"),
+    (re.compile(r"pubmed|ncbi\.nlm\.nih"), 0.88, "pubmed"),
+    (re.compile(r"doi\.org"), 0.87, "doi"),
+    (re.compile(r"(reuters|apnews|bbc)\."), 0.75, "news_wire"),
+    (re.compile(r"(en\.)?wikipedia\.org"), 0.70, "wikipedia"),
+    (re.compile(r"(medium\.com|substack|blogspot|wordpress)"), 0.40, "blog"),
+    (re.compile(r"(reddit\.com|twitter\.com|x\.com)"), 0.35, "social"),
+    # ── Generic TLDs last ──
+    (re.compile(r"\.(edu|ac\.\w+)$"), 0.90, "academic"),
+    (re.compile(r"\.(gov|mil)$"), 0.85, "government"),
+    (re.compile(r"\.(org)$"), 0.65, "organization"),
+    (re.compile(r"\.(com|net|io)$"), 0.50, "commercial"),
+]
+
+DEFAULT_CONFIDENCE = 0.50
+REDUNDANCY_BOOST = 0.05
+REDUNDANCY_CAP = 1.0
+CONTRADICTION_PENALTY = 0.5
+
+
+def load_venn_abers_fixture(path: Union[str, Path]) -> VennAbersCalibrator:
+    """Load a Venn-Abers calibration fixture from JSON.
+
+    Expected JSON shape:
+        {"scores": [0.10, 0.55, 0.82, ...], "labels": [0, 1, 1, ...]}
+
+    Scores are typically the output of ``ConfidenceCalibrator.calibrate``
+    on a held-out set; labels are 1 if the calibrator was right about the
+    axiom (ground truth confirmed), 0 otherwise. Fixture files should be
+    regenerated whenever the calibrator's signals or coefficients change.
+    """
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    return VennAbersCalibrator(
+        calibration_scores=data["scores"],
+        calibration_labels=data["labels"],
+    )
+
+
+class ConfidenceCalibrator:
+    """Multi-signal automatic confidence scoring engine.
+
+    Computes a calibrated confidence score for an axiom based on:
+    1. Source URL domain classification
+    2. Redundancy across independent sources
+    3. Contradiction detection against existing state
+    4. Linguistic certainty (hedging markers in source text)
+
+    Optional Venn-Abers distribution-free interval via constructor injection.
+    When a VennAbersCalibrator is provided, ``calibrate_interval`` returns a
+    two-sided probability bound. Otherwise that method degrades to a
+    zero-width interval around the scalar, making the lack of calibration
+    data explicit rather than silently claiming certainty.
+    """
+
+    def __init__(
+        self,
+        venn_abers: Optional[VennAbersCalibrator] = None,
+    ) -> None:
+        self._venn_abers = venn_abers
+
+    def source_type_score(self, source_url: str) -> float:
+        """Score confidence based on the URL's domain type.
+
+        Returns a base confidence in [0.0, 1.0] based on domain
+        pattern matching against known source categories.
+        """
+        if not source_url:
+            return DEFAULT_CONFIDENCE
+
+        try:
+            parsed = urlparse(source_url)
+            domain = parsed.netloc.lower() or parsed.path.lower()
+        except Exception:
+            return DEFAULT_CONFIDENCE
+
+        for pattern, score, label in SOURCE_PATTERNS:
+            if pattern.search(domain):
+                logger.debug(
+                    "Source %s classified as %s (confidence=%.2f)",
+                    domain, label, score,
+                )
+                return score
+
+        return DEFAULT_CONFIDENCE
+
+    async def redundancy_boost(
+        self, axiom_key: str, ledger
+    ) -> float:
+        """Boost confidence if the axiom has been ingested from multiple sources.
+
+        Each independent ingestion adds +0.05, capped at 1.0.
+        Returns the additive boost (not the total score).
+        """
+        if not ledger:
+            return 0.0
+
+        try:
+            chain = await ledger.get_axiom_provenance(axiom_key)
+            # Count unique sources
+            unique_sources = set()
+            for entry in chain:
+                src = entry.get("source_url", "")
+                if src:
+                    unique_sources.add(src)
+
+            n = len(unique_sources)
+            if n <= 1:
+                return 0.0
+            # Boost for each additional source beyond the first
+            return min((n - 1) * REDUNDANCY_BOOST, 0.5)
+        except Exception as e:
+            logger.warning("Redundancy check failed: %s", e)
+            return 0.0
+
+    def contradiction_penalty(
+        self,
+        axiom_key: str,
+        current_state: int,
+        algebra,
+    ) -> float:
+        """Apply a penalty if the axiom contradicts existing knowledge.
+
+        Returns a multiplier in (0.0, 1.0]. 1.0 = no contradiction.
+        """
+        if current_state <= 1 or not algebra:
+            return 1.0
+
+        # Check if axiom contains a predicate that might conflict
+        parts = axiom_key.split("||")
+        if len(parts) != 3:
+            return 1.0
+
+        subject, predicate, obj = parts
+
+        # Look for conflicting axioms: same subject+predicate, different object
+        try:
+            active_axioms = algebra.get_active_axioms(current_state)
+            for existing in active_axioms:
+                ex_parts = existing.split("||")
+                if len(ex_parts) == 3:
+                    ex_s, ex_p, ex_o = ex_parts
+                    if (ex_s == subject and ex_p == predicate
+                            and ex_o != obj):
+                        logger.info(
+                            "Contradiction detected: '%s' vs existing '%s'",
+                            axiom_key, existing,
+                        )
+                        return CONTRADICTION_PENALTY
+        except Exception as e:
+            logger.warning("Contradiction check failed: %s", e)
+
+        return 1.0
+
+    async def calibrate(
+        self,
+        axiom_key: str,
+        source_url: str = "",
+        current_state: int = 1,
+        algebra=None,
+        ledger=None,
+        manual_confidence: Optional[float] = None,
+        linguistic_certainty: float = 1.0,
+    ) -> float:
+        """Compute calibrated confidence using all available signals.
+
+        Pipeline:
+            1. Start with source-type base score
+            2. Add redundancy boost (if ledger available)
+            3. Apply contradiction penalty (if algebra + state available)
+            4. Apply linguistic certainty multiplier (if < 1.0)
+            5. Clamp to [0.0, 1.0]
+
+        If manual_confidence is provided, it is used as-is (no calibration).
+
+        Args:
+            linguistic_certainty: Output from detect_hedging() in
+                syntactic_sieve.py. 1.0 = definite, <1.0 = hedged.
+                This is a metadata-only signal.
+
+        Returns:
+            float: Calibrated confidence score in [0.0, 1.0]
+        """
+        if manual_confidence is not None:
+            return max(0.0, min(1.0, manual_confidence))
+
+        # Signal 1: Source type
+        base = self.source_type_score(source_url)
+
+        # Signal 2: Redundancy boost
+        boost = await self.redundancy_boost(axiom_key, ledger)
+
+        # Signal 3: Contradiction penalty
+        penalty = self.contradiction_penalty(
+            axiom_key, current_state, algebra
+        )
+
+        # Signal 4: Linguistic certainty
+        ling = max(0.0, min(1.0, linguistic_certainty))
+
+        # Combine: (base + redundancy_boost) × contradiction × linguistic
+        score = (base + boost) * penalty * ling
+
+        # Clamp
+        return max(0.0, min(REDUNDANCY_CAP, score))
+
+    async def calibrate_interval(
+        self,
+        axiom_key: str,
+        source_url: str = "",
+        current_state: int = 1,
+        algebra=None,
+        ledger=None,
+        manual_confidence: Optional[float] = None,
+        linguistic_certainty: float = 1.0,
+    ) -> ConfidenceInterval:
+        """Distribution-free calibrated-confidence interval for an axiom.
+
+        Computes the multi-signal scalar via ``calibrate`` and then wraps it
+        in a Venn-Abers interval if a calibration fixture is present.
+        Absent a fixture, returns the zero-width interval ``[scalar, scalar]``
+        to signal that no distribution-free coverage guarantee is available.
+
+        This method is additive — the existing scalar ``calibrate`` remains
+        as-is for downstream callers that assume a float. New callers that
+        want calibrated bounds (Polytaxis §2 discipline) should prefer this.
+        """
+        scalar = await self.calibrate(
+            axiom_key=axiom_key,
+            source_url=source_url,
+            current_state=current_state,
+            algebra=algebra,
+            ledger=ledger,
+            manual_confidence=manual_confidence,
+            linguistic_certainty=linguistic_certainty,
+        )
+        if self._venn_abers is None:
+            return ConfidenceInterval(lower=scalar, upper=scalar)
+        return self._venn_abers.predict_interval(scalar)