clm-kernel 0.0.0__py3-none-any.whl

clm/layer3/satori/lambda_term.py

@@ -0,0 +1,230 @@
+"""
+Lambda Term - Algebraic Data Type for Lambda Calculus
+
+Represents Lambda Calculus terms as content-addressable MCards.
+Each term variant is stored as JSON in MCard content, with sub-terms
+referenced by their SHA-256 hashes for structural sharing.
+
+The three term constructors mirror the BNF grammar:
+  M, N ::= x | λx.M | M N
+
+This module provides Python parity with mcard-js/src/ptr/lambda/LambdaTerm.ts
+"""
+
+import json
+from dataclasses import dataclass
+from typing import Literal
+
+from clm.layer0.model.card import MCard
+from clm.layer2.card_collection import CardCollection
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Lambda Term ADT
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class VarTerm:
+    """Variable term: x"""
+
+    tag: Literal["Var"] = "Var"
+    name: str = ""
+
+    def __init__(self, name: str):
+        object.__setattr__(self, "name", name)
+        object.__setattr__(self, "tag", "Var")
+
+
+@dataclass(frozen=True)
+class AbsTerm:
+    """Abstraction term: λx.M - Body is stored as MCard hash"""
+
+    tag: Literal["Abs"] = "Abs"
+    param: str = ""
+    body: str = ""  # MCard hash of body term
+
+    def __init__(self, param: str, body: str):
+        object.__setattr__(self, "param", param)
+        object.__setattr__(self, "body", body)
+        object.__setattr__(self, "tag", "Abs")
+
+
+@dataclass(frozen=True)
+class AppTerm:
+    """Application term: M N - Both func and arg are MCard hashes"""
+
+    tag: Literal["App"] = "App"
+    func: str = ""  # MCard hash of function
+    arg: str = ""  # MCard hash of argument
+
+    def __init__(self, func: str, arg: str):
+        object.__setattr__(self, "func", func)
+        object.__setattr__(self, "arg", arg)
+        object.__setattr__(self, "tag", "App")
+
+
+LambdaTerm = VarTerm | AbsTerm | AppTerm
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Constructors (Smart Constructors)
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def mk_var(name: str) -> VarTerm:
+    """Create a variable term"""
+    return VarTerm(name=name)
+
+
+def mk_abs(param: str, body_hash: str) -> AbsTerm:
+    """Create an abstraction term"""
+    return AbsTerm(param=param, body=body_hash)
+
+
+def mk_app(func_hash: str, arg_hash: str) -> AppTerm:
+    """Create an application term"""
+    return AppTerm(func=func_hash, arg=arg_hash)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Serialization
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def serialize_term(term: LambdaTerm) -> str:
+    """Serialize a Lambda term to MCard content (JSON string)"""
+    if isinstance(term, VarTerm):
+        return json.dumps({"tag": "Var", "name": term.name})
+    elif isinstance(term, AbsTerm):
+        return json.dumps({"tag": "Abs", "param": term.param, "body": term.body})
+    elif isinstance(term, AppTerm):
+        return json.dumps({"tag": "App", "func": term.func, "arg": term.arg})
+    else:
+        raise ValueError(f"Unknown term type: {type(term)}")
+
+
+def deserialize_term(content: str) -> LambdaTerm:
+    """Deserialize MCard content to Lambda term"""
+    parsed = json.loads(content)
+
+    if not parsed.get("tag"):
+        raise ValueError("Invalid Lambda term: missing tag")
+
+    tag = parsed["tag"]
+
+    if tag == "Var":
+        if not isinstance(parsed.get("name"), str):
+            raise ValueError("Invalid Var term: name must be string")
+        return mk_var(parsed["name"])
+
+    elif tag == "Abs":
+        if not isinstance(parsed.get("param"), str) or not isinstance(
+            parsed.get("body"), str
+        ):
+            raise ValueError("Invalid Abs term: param and body must be strings")
+        return mk_abs(parsed["param"], parsed["body"])
+
+    elif tag == "App":
+        if not isinstance(parsed.get("func"), str) or not isinstance(
+            parsed.get("arg"), str
+        ):
+            raise ValueError("Invalid App term: func and arg must be strings")
+        return mk_app(parsed["func"], parsed["arg"])
+
+    else:
+        raise ValueError(f"Unknown Lambda term tag: {tag}")
+
+
+def term_to_mcard(term: LambdaTerm) -> MCard:
+    """Create an MCard from a Lambda term"""
+    return MCard(content=serialize_term(term))
+
+
+def mcard_to_term(mcard: MCard) -> LambdaTerm:
+    """Extract Lambda term from MCard"""
+    content = mcard.get_content(as_text=True)
+    return deserialize_term(content)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Collection Operations
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def store_term(collection: CardCollection, term: LambdaTerm) -> str:
+    """Store a Lambda term in the collection and return its hash"""
+    mcard = term_to_mcard(term)
+    collection.add(mcard)
+    return mcard.hash
+
+
+def load_term(collection: CardCollection, hash_value: str) -> LambdaTerm | None:
+    """Retrieve a Lambda term from the collection by hash"""
+    mcard = collection.get(hash_value)
+    if mcard is None:
+        return None
+    return mcard_to_term(mcard)
+
+
+def term_exists(collection: CardCollection, hash_value: str) -> bool:
+    """Check if a term exists in the collection"""
+    return collection.get(hash_value) is not None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Pretty Printing
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def pretty_print_shallow(term: LambdaTerm) -> str:
+    """Pretty-print a Lambda term (shallow - shows hashes for subterms)"""
+    if isinstance(term, VarTerm):
+        return term.name
+    elif isinstance(term, AbsTerm):
+        return f"λ{term.param}.〈{term.body[:8]}…〉"
+    elif isinstance(term, AppTerm):
+        return f"(〈{term.func[:8]}…〉 〈{term.arg[:8]}…〉)"
+    else:
+        return str(term)
+
+
+def pretty_print_deep(collection: CardCollection, hash_value: str) -> str:
+    """Pretty-print a Lambda term (deep - resolves all subterms from collection)"""
+    term = load_term(collection, hash_value)
+    if term is None:
+        return f"〈missing:{hash_value[:8]}…〉"
+
+    if isinstance(term, VarTerm):
+        return term.name
+
+    elif isinstance(term, AbsTerm):
+        body = pretty_print_deep(collection, term.body)
+        return f"(λ{term.param}.{body})"
+
+    elif isinstance(term, AppTerm):
+        func = pretty_print_deep(collection, term.func)
+        arg = pretty_print_deep(collection, term.arg)
+        return f"({func} {arg})"
+
+    else:
+        return str(term)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Type Guards
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def is_var(term: LambdaTerm) -> bool:
+    """Check if term is a variable"""
+    return isinstance(term, VarTerm)
+
+
+def is_abs(term: LambdaTerm) -> bool:
+    """Check if term is an abstraction"""
+    return isinstance(term, AbsTerm)
+
+
+def is_app(term: LambdaTerm) -> bool:
+    """Check if term is an application"""
+    return isinstance(term, AppTerm)

clm/layer3/satori/sheaf_audit.py

@@ -0,0 +1,261 @@
+"""Layer 3 Satori Sheaf Cohomology & Multi-Agent Consensus Auditing (DEL-390-02, INV-390-02).
+
+Implements Sheaf-theoretic multi-agent state consistency and Maxwell's Demon gating:
+- Local sections s_i over open sets U_i must agree on intersections:
+    s_i|_{U_i ∩ U_j} == s_j|_{U_i ∩ U_j}   ∀ i, j
+- Vanishing first cohomology class H¹ = 0 guarantees zero conflict obstruction,
+  enabling unique global gluing into the SSOT state section.
+- Maxwell's Demon (§3.2, INV-362-04): validates contributor DID grounding,
+  non-empty content, and zero synthetic hallucination markers.
+"""
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+from clm.layer3.satori.speech_act import encode_satori_binary
+
+
+@dataclass(frozen=True)
+class Place:
+    """An open-set place identifier in a distributed topological space."""
+    id: str
+
+
+@dataclass
+class Marking:
+    """Maps token places / colors to their associated content hashes or values."""
+    tokens: Dict[str, List[str]] = field(default_factory=dict)
+
+    def with_token(self, place: str, val: str) -> Marking:
+        tokens = dict(self.tokens)
+        if place not in tokens:
+            tokens[place] = []
+        else:
+            tokens[place] = list(tokens[place])
+        tokens[place].append(val)
+        return Marking(tokens=tokens)
+
+    def restrict(self, places: Set[Place]) -> Marking:
+        """Restrict marking to a subset of places."""
+        place_ids = {p.id for p in places}
+        restricted = {k: list(v) for k, v in self.tokens.items() if k in place_ids}
+        return Marking(tokens=restricted)
+
+    def to_digest(self) -> str:
+        items = sorted((k, sorted(v)) for k, v in self.tokens.items())
+        raw = str(items).encode("utf-8")
+        return hashlib.sha256(raw).hexdigest()
+
+
+@dataclass(frozen=True)
+class OpenSet:
+    """An open set consisting of a collection of discrete Places."""
+    places: frozenset[Place] = field(default_factory=frozenset)
+
+    @classmethod
+    def from_ids(cls, *ids: str) -> OpenSet:
+        return cls(frozenset(Place(id=i) for i in ids))
+
+    def intersection(self, other: OpenSet) -> OpenSet:
+        return OpenSet(self.places.intersection(other.places))
+
+    def union(self, other: OpenSet) -> OpenSet:
+        return OpenSet(self.places.union(other.places))
+
+    def is_empty(self) -> bool:
+        return len(self.places) == 0
+
+    def is_subset(self, other: OpenSet) -> bool:
+        return self.places.issubset(other.places)
+
+
+@dataclass
+class Section:
+    """A local section pairing an open set cover with a state marking."""
+    open_set: OpenSet
+    marking: Marking
+
+    def restrict(self, subset: OpenSet) -> Section:
+        if not subset.is_subset(self.open_set):
+            raise ValueError("Cannot restrict section to non-subset open set")
+        return Section(open_set=subset, marking=self.marking.restrict(set(subset.places)))
+
+
+@dataclass
+class SheafAuditReport:
+    """Outcome of a sheaf consensus audit evaluating the H¹ = 0 condition."""
+    h1_vanishes: bool
+    cohomology_h1: int
+    obstructions: List[str]
+    global_section: Optional[Section] = None
+
+
+class Sheaf:
+    """Sheaf engine verifying the gluing axiom on open covers."""
+
+    @staticmethod
+    def gluing_check(sections: List[Section], open_cover: List[OpenSet]) -> Tuple[Optional[Section], List[str]]:
+        """Verifies that local sections agree on all pairwise intersections.
+        Returns:
+            (global_section, []) if H¹ = 0 holds.
+            (None, [obstruction_reasons...]) if H¹ != 0 (obstruction detected).
+        """
+        if len(sections) != len(open_cover):
+            return None, ["Input length mismatch between sections and open cover"]
+
+        if not sections:
+            return Section(open_set=OpenSet(), marking=Marking()), []
+
+        obstructions: List[str] = []
+        n = len(sections)
+
+        for i in range(n):
+            for j in range(i + 1, n):
+                u_ij = open_cover[i].intersection(open_cover[j])
+                if u_ij.is_empty():
+                    continue
+
+                sec_i_res = sections[i].restrict(u_ij)
+                sec_j_res = sections[j].restrict(u_ij)
+
+                if sec_i_res.marking.to_digest() != sec_j_res.marking.to_digest():
+                    obstructions.append(
+                        f"Cohomology class H¹ != 0 obstruction on overlap {sorted(p.id for p in u_ij.places)}: "
+                        f"Section {i} digest {sec_i_res.marking.to_digest()[:8]} != Section {j} digest {sec_j_res.marking.to_digest()[:8]}"
+                    )
+
+        if obstructions:
+            return None, obstructions
+
+        # Glue into unified global section
+        all_places = set()
+        merged_tokens: Dict[str, List[str]] = {}
+        for s in sections:
+            all_places.update(s.open_set.places)
+            for k, v in s.marking.tokens.items():
+                if k not in merged_tokens:
+                    merged_tokens[k] = list(v)
+
+        global_sec = Section(open_set=OpenSet(frozenset(all_places)), marking=Marking(tokens=merged_tokens))
+        return global_sec, []
+
+
+class SheafAuditor:
+    """Auditor for multi-agent distributed consensus."""
+
+    @classmethod
+    def audit_consensus(
+        cls,
+        sections: List[Section],
+        open_cover: Optional[List[OpenSet]] = None,
+    ) -> SheafAuditReport:
+        """Audit pairwise section agreement. Vanishing H¹ (cohomology_h1 = 0) indicates consensus."""
+        if open_cover is None:
+            open_cover = [s.open_set for s in sections]
+
+        global_sec, obstructions = Sheaf.gluing_check(sections, open_cover)
+        if obstructions:
+            return SheafAuditReport(
+                h1_vanishes=False,
+                cohomology_h1=1,
+                obstructions=obstructions,
+                global_section=None,
+            )
+        return SheafAuditReport(
+            h1_vanishes=True,
+            cohomology_h1=0,
+            obstructions=[],
+            global_section=global_sec,
+        )
+
+    @classmethod
+    def audit_partitions(
+        cls,
+        partitions: List[Dict[str, Any]],
+        shared_keys: Optional[Set[str]] = None,
+    ) -> SheafAuditReport:
+        """Audit distributed agent state partition dictionaries.
+        Each partition has a 'did', 'places' (keys), and 'state' (mapping).
+        """
+        sections: List[Section] = []
+        covers: List[OpenSet] = []
+
+        for p in partitions:
+            keys = set(p.get("places", p.get("state", {}).keys()))
+            open_set = OpenSet.from_ids(*keys)
+            tokens = {}
+            for k, v in p.get("state", {}).items():
+                tokens[k] = [str(v)] if not isinstance(v, list) else [str(x) for x in v]
+            sections.append(Section(open_set=open_set, marking=Marking(tokens=tokens)))
+            covers.append(open_set)
+
+        return cls.audit_consensus(sections, covers)
+
+
+def audit_maxwell_demon(node: Dict[str, Any]) -> Dict[str, Any]:
+    """Audits a Satori message speech act via Maxwell's Demon (§3.2, INV-362-04).
+    Validates DID grounding, non-empty content, and absence of synthetic hallucination markers.
+    Returns receipt dict with 'verified', 'cohomology_h1', 'lagrangian_delta', 'hash', 'rejection_reason'.
+    """
+    encoded = encode_satori_binary(node)
+    msg_hash = hashlib.sha256(encoded).hexdigest()
+
+    user_did = node.get("user_did", "")
+    if not isinstance(user_did, str) or not user_did.startswith("did:"):
+        return {
+            "verified": False,
+            "cohomology_h1": 1,
+            "lagrangian_delta": -1,
+            "hash": msg_hash,
+            "rejection_reason": f"Cohomology Class H^1 != 0: Un-grounded DID contributor identity '{user_did}'",
+        }
+
+    children = node.get("elements", node.get("children", []))
+    if not children:
+        return {
+            "verified": False,
+            "cohomology_h1": 1,
+            "lagrangian_delta": -1,
+            "hash": msg_hash,
+            "rejection_reason": "Cohomology Class H^1 != 0: Empty message section cannot glue into Data Harness",
+        }
+
+    def _has_hallucination(n: Dict[str, Any]) -> bool:
+        txt = str(n.get("text", ""))
+        if "[HALLUCINATED]" in txt or "<hallucination>" in txt:
+            return True
+        for c in n.get("elements", n.get("children", [])):
+            if _has_hallucination(c):
+                return True
+        return False
+
+    if _has_hallucination(node):
+        return {
+            "verified": False,
+            "cohomology_h1": 1,
+            "lagrangian_delta": -1,
+            "hash": msg_hash,
+            "rejection_reason": "Cohomology Class H^1 != 0: Detected ungrounded hallucinated tokens in execution section",
+        }
+
+    return {
+        "verified": True,
+        "cohomology_h1": 0,
+        "lagrangian_delta": 1,
+        "hash": msg_hash,
+        "rejection_reason": None,
+    }
+
+
+__all__ = [
+    "Place",
+    "Marking",
+    "OpenSet",
+    "Section",
+    "Sheaf",
+    "SheafAuditReport",
+    "SheafAuditor",
+    "audit_maxwell_demon",
+]