sum-engine 0.1.0__py3-none-any.whl

internal/__init__.py

@@ -0,0 +1,8 @@
+"""Internal SUM engine modules — not a stable public API.
+
+The CLI (``sum_cli.main``) imports from here; downstream integrations
+should depend on the CLI contract (``sum attest`` / ``sum verify``
+exit codes and the CanonicalBundle JSON schema) rather than import
+these modules directly. Internal refactors may move or rename
+submodules between minor versions.
+"""

internal/algorithms/__init__.py

@@ -0,0 +1 @@
+"""Prime-encoded semantic algebra + deterministic-sieve extractors."""

internal/algorithms/causal_discovery.py

@@ -0,0 +1,96 @@
+"""
+Causal Discovery Engine — Topological Inference
+
+Sweeps active axioms for transitive topological links (causality,
+implication, inhibition) and computes transitive closures to
+synthesize novel knowledge that the system was never explicitly taught.
+
+If the algebra contains:
+    chemical_x → inhibits → enzyme_y
+    enzyme_y   → causes   → disease_z
+
+The engine will deduce:
+    chemical_x → treats → disease_z
+
+Author: ototao
+License: Apache License 2.0
+"""
+
+from typing import List, Tuple
+import networkx as nx
+
+
+class CausalDiscoveryEngine:
+    """
+    Horizon V: The Automated Scientist.
+
+    Sweeps active axioms for transitive topological links
+    and synthesizes novel knowledge via strict predicate rules.
+    """
+
+    TRANSITIVE_PREDICATES = {"causes", "implies", "leads_to", "requires", "is_a"}
+    INVERSE_PREDICATES = {"inhibits": "treats", "prevents": "solves"}
+
+    def __init__(self, algebra):
+        self.algebra = algebra
+
+    def sweep_for_discoveries(
+        self, current_state: int
+    ) -> List[Tuple[str, str, str]]:
+        """
+        Extract directed graph from active axioms, compute transitive
+        closures, and return novel triplets not already in the state.
+
+        Args:
+            current_state: The Gödel integer to analyze.
+
+        Returns:
+            List of (subject, predicate, object) triplets that are
+            logically entailed but not yet in the state.
+        """
+        active_axioms = self.algebra.get_active_axioms(current_state)
+
+        # Build directed graph from causal/transitive predicates
+        G = nx.DiGraph()
+        for ax in active_axioms:
+            parts = ax.split("||")
+            if len(parts) == 3:
+                s, p, o = parts
+                if p in self.TRANSITIVE_PREDICATES or p in self.INVERSE_PREDICATES:
+                    G.add_edge(s, o, predicate=p)
+
+        # Compute 2-hop transitive closures
+        discoveries = set()
+
+        for node in list(G.nodes()):
+            for neighbor in list(G.successors(node)):
+                p1 = G.edges[node, neighbor]["predicate"]
+                for target in list(G.successors(neighbor)):
+                    if node == target:
+                        continue  # Skip self-loops
+
+                    p2 = G.edges[neighbor, target]["predicate"]
+
+                    # Same transitive predicate: A→B→C  ⟹  A→C
+                    if (
+                        p1 in self.TRANSITIVE_PREDICATES
+                        and p2 in self.TRANSITIVE_PREDICATES
+                    ):
+                        discoveries.add((node, p1, target))
+
+                    # Inverse + transitive: A inhibits B, B causes C  ⟹  A treats C
+                    elif (
+                        p1 in self.INVERSE_PREDICATES
+                        and p2 in self.TRANSITIVE_PREDICATES
+                    ):
+                        inferred_pred = self.INVERSE_PREDICATES[p1]
+                        discoveries.add((node, inferred_pred, target))
+
+        # Filter to only truly novel discoveries
+        novel_discoveries = []
+        for s, p, o in discoveries:
+            prime = self.algebra.get_or_mint_prime(s, p, o)
+            if current_state % prime != 0:
+                novel_discoveries.append((s, p, o))
+
+        return novel_discoveries

internal/algorithms/predicate_canon.py

@@ -0,0 +1,137 @@
+"""
+Predicate Canonicalizer — Controlled Vocabulary for Semantic Primes
+
+Maps free-form LLM predicates to a normalized vocabulary so that
+semantically identical relationships produce the same Gödel prime.
+
+Without this:
+    "sun||causes||warmth"    → prime₁
+    "sun||leads_to||warmth"  → prime₂    (different prime, same meaning!)
+
+With this:
+    "sun||causes||warmth"    → prime₁
+    "sun||leads_to||warmth"  → prime₁    (same prime via canonicalization)
+
+The canonical vocabulary is intentionally small — it maps the long tail
+of LLM-generated predicates into the set that CausalDiscovery's
+TRANSITIVE_PREDICATES and INVERSE_PREDICATES can reason over.
+
+Author: ototao
+License: Apache License 2.0
+"""
+
+
+# ─── Canonical Vocabulary ─────────────────────────────────────────────
+
+CANONICAL_MAP: dict[str, str] = {
+    # → causes family
+    "leads_to":     "causes",
+    "triggers":     "causes",
+    "results_in":   "causes",
+    "produces":     "causes",
+    "generates":    "causes",
+    "creates":      "causes",
+    "induces":      "causes",
+    "drives":       "causes",
+    "provokes":     "causes",
+    "elicits":      "causes",
+    "yields":       "causes",
+    "brings_about": "causes",
+
+    # → inhibits family
+    "prevents":     "inhibits",
+    "blocks":       "inhibits",
+    "stops":        "inhibits",
+    "suppresses":   "inhibits",
+    "reduces":      "inhibits",
+    "hinders":      "inhibits",
+    "impedes":      "inhibits",
+    "decreases":    "inhibits",
+    "diminishes":   "inhibits",
+    "constrains":   "inhibits",
+
+    # → implies family
+    "suggests":     "implies",
+    "indicates":    "implies",
+    "means":        "implies",
+    "entails":      "implies",
+    "demonstrates": "implies",
+    "shows":        "implies",
+    "proves":       "implies",
+    "evidences":    "implies",
+
+    # → requires family
+    "needs":        "requires",
+    "depends_on":   "requires",
+    "relies_on":    "requires",
+    "necessitates": "requires",
+
+    # → is_a family (taxonomy)
+    "is_type_of":   "is_a",
+    "is_kind_of":   "is_a",
+    "belongs_to":   "is_a",
+    "is_part_of":   "has_part",
+    "contains":     "has_part",
+    "includes":     "has_part",
+    "comprises":    "has_part",
+
+    # → has_property family
+    "has":          "has_property",
+    "possesses":    "has_property",
+    "exhibits":     "has_property",
+    "displays":     "has_property",
+    "features":     "has_property",
+    "characterized_by": "has_property",
+
+    # → treats family (inverse of inhibits in CausalDiscovery)
+    "cures":        "treats",
+    "heals":        "treats",
+    "remedies":     "treats",
+    "alleviates":   "treats",
+    "mitigates":    "treats",
+
+    # → enables family
+    "allows":       "enables",
+    "permits":      "enables",
+    "facilitates":  "enables",
+    "supports":     "enables",
+    "empowers":     "enables",
+
+    # → uses family
+    "utilizes":     "uses",
+    "employs":      "uses",
+    "applies":      "uses",
+    "leverages":    "uses",
+
+    # → located_in family
+    "found_in":     "located_in",
+    "exists_in":    "located_in",
+    "resides_in":   "located_in",
+    "occurs_in":    "located_in",
+}
+
+# The set of canonical predicates (roots) — these are never remapped
+CANONICAL_PREDICATES: frozenset[str] = frozenset({
+    "causes", "inhibits", "implies", "requires", "is_a",
+    "has_part", "has_property", "treats", "enables", "uses",
+    "located_in", "leads_to",
+    # Keep CausalDiscovery's originals
+    "solves",
+})
+
+
+def canonicalize(predicate: str) -> str:
+    """
+    Maps a free-form predicate string to its canonical form.
+
+    If the predicate is already canonical or has no mapping,
+    it is returned unchanged (the system remains open-world).
+
+    Args:
+        predicate: The raw predicate string (lowercased).
+
+    Returns:
+        The canonical predicate.
+    """
+    normalized = predicate.strip().lower().replace(" ", "_")
+    return CANONICAL_MAP.get(normalized, normalized)