clm-kernel 0.0.0__py3-none-any.whl

clm/layer3/satori/beta_reduction.py

@@ -0,0 +1,359 @@
+"""
+Beta Reduction - Function application in Lambda Calculus
+
+Beta reduction (β-reduction) is the computational rule:
+  (λx.M) N →β M[x:=N]
+
+This module provides:
+- Single-step beta reduction
+- Full normalization with multiple strategies
+- Capture-avoiding substitution
+- Redex detection and search
+
+This module provides Python parity with mcard-js/src/ptr/lambda/BetaReduction.ts
+"""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Literal
+
+from clm.layer2.card_collection import CardCollection
+from clm.layer3.satori.alpha_conversion import alpha_rename
+from clm.layer3.satori.free_variables import generate_fresh_for, is_free_in
+from clm.layer3.satori.lambda_term import (
+    is_abs,
+    is_app,
+    is_var,
+    load_term,
+    mk_abs,
+    mk_app,
+    store_term,
+)
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Types
+# ─────────────────────────────────────────────────────────────────────────────
+
+ReductionStrategy = Literal["normal", "applicative", "lazy"]
+
+
+@dataclass
+class NormalizationResult:
+    """Result of normalization"""
+
+    normal_form: str  # Hash of the normal form
+    steps: int  # Number of reduction steps
+    reduction_path: list[str]  # Hashes of intermediate forms
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Substitution with Capture Avoidance
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def substitute_with_capture(
+    collection: CardCollection, term_hash: str, var_name: str, replacement_hash: str
+) -> str | None:
+    """
+    Perform capture-avoiding substitution: M[x:=N]
+
+    This is the core operation that replaces all free occurrences of x in M with N,
+    while avoiding variable capture by renaming bound variables as needed.
+    """
+    term = load_term(collection, term_hash)
+    if term is None:
+        return None
+
+    if is_var(term):
+        if term.name == var_name:
+            return replacement_hash
+        return term_hash
+
+    elif is_abs(term):
+        if term.param == var_name:
+            # x is bound here - no substitution in body
+            return term_hash
+
+        # Check for capture: if param is free in replacement
+        param_free_in_repl = is_free_in(collection, term.param, replacement_hash)
+        if param_free_in_repl is None:
+            return None
+
+        if param_free_in_repl:
+            # Need to alpha-rename to avoid capture
+            fresh = generate_fresh_for(
+                collection, term.param, term.body, replacement_hash
+            )
+            renamed_body = alpha_rename(collection, term.body, term.param, fresh)
+            if renamed_body is None:
+                return None
+
+            new_body = substitute_with_capture(
+                collection, renamed_body, var_name, replacement_hash
+            )
+            if new_body is None:
+                return None
+
+            return store_term(collection, mk_abs(fresh, new_body))
+
+        # Safe to substitute directly
+        new_body = substitute_with_capture(
+            collection, term.body, var_name, replacement_hash
+        )
+        if new_body is None:
+            return None
+
+        return store_term(collection, mk_abs(term.param, new_body))
+
+    elif is_app(term):
+        new_func = substitute_with_capture(
+            collection, term.func, var_name, replacement_hash
+        )
+        new_arg = substitute_with_capture(
+            collection, term.arg, var_name, replacement_hash
+        )
+        if new_func is None or new_arg is None:
+            return None
+        return store_term(collection, mk_app(new_func, new_arg))
+
+    return term_hash
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Redex Detection
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def is_redex(collection: CardCollection, hash_value: str) -> bool | None:
+    """
+    Check if a term is a beta-redex: (λx.M) N
+    """
+    term = load_term(collection, hash_value)
+    if term is None:
+        return None
+
+    if is_app(term):
+        func = load_term(collection, term.func)
+        if func is not None and is_abs(func):
+            return True
+
+    return False
+
+
+def find_leftmost_redex(collection: CardCollection, hash_value: str) -> str | None:
+    """
+    Find the leftmost-outermost beta-redex (normal order).
+    Returns the hash of the redex, or None if none found.
+    """
+    term = load_term(collection, hash_value)
+    if term is None:
+        return None
+
+    if is_app(term):
+        # Check if this is a redex
+        func = load_term(collection, term.func)
+        if func is not None and is_abs(func):
+            return hash_value
+
+        # Try left subtree first
+        left_redex = find_leftmost_redex(collection, term.func)
+        if left_redex:
+            return left_redex
+
+        # Then right subtree
+        return find_leftmost_redex(collection, term.arg)
+
+    elif is_abs(term):
+        return find_leftmost_redex(collection, term.body)
+
+    return None
+
+
+def find_innermost_redex(collection: CardCollection, hash_value: str) -> str | None:
+    """
+    Find the innermost-leftmost beta-redex (applicative order).
+    Returns the hash of the redex, or None if none found.
+    """
+    term = load_term(collection, hash_value)
+    if term is None:
+        return None
+
+    if is_app(term):
+        # Try subtrees first
+        left_redex = find_innermost_redex(collection, term.func)
+        if left_redex:
+            return left_redex
+
+        right_redex = find_innermost_redex(collection, term.arg)
+        if right_redex:
+            return right_redex
+
+        # Check if this is a redex
+        func = load_term(collection, term.func)
+        if func is not None and is_abs(func):
+            return hash_value
+
+    elif is_abs(term):
+        return find_innermost_redex(collection, term.body)
+
+    return None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Beta Reduction
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def beta_reduce(collection: CardCollection, hash_value: str) -> str | None:
+    """
+    Perform a single beta reduction step on a redex.
+
+    (λx.M) N →β M[x:=N]
+
+    Returns the hash of the reduced term, or None if not a redex.
+    """
+    term = load_term(collection, hash_value)
+    if term is None:
+        return None
+
+    if not is_app(term):
+        return None
+
+    func = load_term(collection, term.func)
+    if func is None or not is_abs(func):
+        return None
+
+    # Perform substitution: body[param:=arg]
+    return substitute_with_capture(collection, func.body, func.param, term.arg)
+
+
+def reduce_step(
+    collection: CardCollection, hash_value: str, strategy: ReductionStrategy = "normal"
+) -> str | None:
+    """
+    Perform a single reduction step using the specified strategy.
+    Returns None if no reduction is possible.
+    """
+    term = load_term(collection, hash_value)
+    if term is None:
+        return None
+
+    # Find redex based on strategy
+    if strategy == "normal":
+        redex_hash = find_leftmost_redex(collection, hash_value)
+    elif strategy == "applicative":
+        redex_hash = find_innermost_redex(collection, hash_value)
+    else:  # lazy
+        redex_hash = find_leftmost_redex(collection, hash_value)
+
+    if not redex_hash:
+        return None
+
+    # Reduce the redex
+    reduced = beta_reduce(collection, redex_hash)
+    if reduced is None:
+        return None
+
+    # Replace the redex in the original term
+    return replace_subterm(collection, hash_value, redex_hash, reduced)
+
+
+def replace_subterm(
+    collection: CardCollection, term_hash: str, target_hash: str, replacement_hash: str
+) -> str | None:
+    """
+    Replace a subterm (identified by hash) with another term.
+    """
+    if term_hash == target_hash:
+        return replacement_hash
+
+    term = load_term(collection, term_hash)
+    if term is None:
+        return None
+
+    if is_var(term):
+        return term_hash
+
+    elif is_abs(term):
+        new_body = replace_subterm(collection, term.body, target_hash, replacement_hash)
+        if new_body is None:
+            return None
+        if new_body == term.body:
+            return term_hash
+        return store_term(collection, mk_abs(term.param, new_body))
+
+    elif is_app(term):
+        new_func = replace_subterm(collection, term.func, target_hash, replacement_hash)
+        new_arg = replace_subterm(collection, term.arg, target_hash, replacement_hash)
+        if new_func is None or new_arg is None:
+            return None
+        if new_func == term.func and new_arg == term.arg:
+            return term_hash
+        return store_term(collection, mk_app(new_func, new_arg))
+
+    return term_hash
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Normalization
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def normalize(
+    collection: CardCollection,
+    hash_value: str,
+    strategy: ReductionStrategy = "normal",
+    max_steps: int = 1000,
+    on_step: Callable[[int, str], None] | None = None,
+) -> NormalizationResult | None:
+    """
+    Normalize a Lambda term by repeatedly applying reduction steps.
+
+    Args:
+        collection: The card collection containing terms
+        hash_value: Hash of the term to normalize
+        strategy: Reduction strategy ('normal', 'applicative', 'lazy')
+        max_steps: Maximum number of reduction steps
+        on_step: Optional callback for IO effects, called after each step
+
+    Returns the normal form if found within max_steps, or None if:
+    - Term not found
+    - Reduction diverges (exceeds max_steps)
+    """
+    current = hash_value
+    path = [current]
+    steps = 0
+
+    while steps < max_steps:
+        next_term = reduce_step(collection, current, strategy)
+
+        if next_term is None:
+            # No more reductions - we're in normal form
+            return NormalizationResult(
+                normal_form=current, steps=steps, reduction_path=path
+            )
+
+        steps += 1
+        current = next_term
+        path.append(current)
+
+        # IO Effect: emit step event
+        if on_step is not None:
+            on_step(steps, current)
+
+    # Exceeded max steps - possibly divergent
+    return None
+
+
+def is_normal_form(collection: CardCollection, hash_value: str) -> bool | None:
+    """Check if a term is in normal form (contains no redexes)"""
+    redex = find_leftmost_redex(collection, hash_value)
+    return redex is None
+
+
+def has_normal_form(
+    collection: CardCollection, hash_value: str, max_steps: int = 1000
+) -> bool | None:
+    """Check if a term has a normal form (within max_steps)"""
+    result = normalize(collection, hash_value, "normal", max_steps)
+    return result is not None

clm/layer3/satori/continuation.py

@@ -0,0 +1,38 @@
+"""Layer 3 Satori Delimited Continuations (DEL-390-02).
+
+Provides delimited continuation tokens and multi-turn state resumption
+for Satori conversational speech-act threads.
+"""
+from __future__ import annotations
+
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class ContinuationToken:
+    """Represents a suspended execution turn in a conversational speech-act thread."""
+    turn_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    timestamp: float = field(default_factory=time.time)
+    captured_state: Dict[str, Any] = field(default_factory=dict)
+    prompt_history: List[Dict[str, Any]] = field(default_factory=list)
+    resume_target: Optional[str] = None
+    is_resumed: bool = False
+
+    def resume(self, response_act: Dict[str, Any]) -> Dict[str, Any]:
+        """Resumes the suspended continuation by appending the new speech act."""
+        if self.is_resumed:
+            raise RuntimeError(f"ContinuationToken {self.turn_id} has already been resumed.")
+        self.is_resumed = True
+        self.prompt_history.append(response_act)
+        return {
+            "turn_id": self.turn_id,
+            "resumed_at": time.time(),
+            "history_depth": len(self.prompt_history),
+            "state": self.captured_state,
+        }
+
+
+__all__ = ["ContinuationToken"]

clm/layer3/satori/eta_conversion.py

@@ -0,0 +1,205 @@
+"""
+Eta Conversion - Extensional equality in Lambda Calculus
+
+Eta conversion (η-conversion) captures extensional equivalence:
+  λx.(M x) ≡η M  (when x is not free in M)
+
+This expresses that two functions are equal if they produce the same
+result for all inputs.
+
+This module provides Python parity with mcard-js/src/ptr/lambda/EtaConversion.ts
+"""
+
+from clm.layer2.card_collection import CardCollection
+from clm.layer3.satori.alpha_conversion import alpha_equivalent
+from clm.layer3.satori.free_variables import generate_fresh_for, is_free_in
+from clm.layer3.satori.lambda_term import (
+    is_abs,
+    is_app,
+    is_var,
+    load_term,
+    mk_abs,
+    mk_app,
+    mk_var,
+    store_term,
+)
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Eta Reduction
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def eta_reduce(collection: CardCollection, hash_value: str) -> str | None:
+    """
+    Perform eta reduction on a term.
+
+    λx.(M x) →η M  (when x is not free in M)
+
+    Returns the reduced term hash, or the original if not reducible.
+    """
+    term = load_term(collection, hash_value)
+    if term is None:
+        return None
+
+    if is_abs(term):
+        # Check if body is application
+        body = load_term(collection, term.body)
+        if body is None:
+            return None
+
+        if is_app(body):
+            # Check if arg is the bound variable
+            arg = load_term(collection, body.arg)
+            if arg is None:
+                return None
+
+            if is_var(arg) and arg.name == term.param:
+                # Check if param is NOT free in func
+                free_check = is_free_in(collection, term.param, body.func)
+                if free_check is not None and not free_check:
+                    # η-reduction applies!
+                    return body.func
+
+    # No reduction possible at top level, try subterms
+    if is_abs(term):
+        new_body = eta_reduce(collection, term.body)
+        if new_body is None:
+            return None
+        if new_body != term.body:
+            return store_term(collection, mk_abs(term.param, new_body))
+        return hash_value
+
+    elif is_app(term):
+        new_func = eta_reduce(collection, term.func)
+        new_arg = eta_reduce(collection, term.arg)
+        if new_func is None or new_arg is None:
+            return None
+        if new_func != term.func or new_arg != term.arg:
+            return store_term(collection, mk_app(new_func, new_arg))
+        return hash_value
+
+    return hash_value
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Eta Expansion
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def eta_expand(
+    collection: CardCollection, hash_value: str, fresh_var: str | None = None
+) -> str | None:
+    """
+    Perform eta expansion on a term.
+
+    M →η λx.(M x)  (where x is fresh)
+
+    Returns the expanded term hash.
+    """
+    term = load_term(collection, hash_value)
+    if term is None:
+        return None
+
+    # Generate fresh variable if not provided
+    if fresh_var is None:
+        fresh_var = generate_fresh_for(collection, "η", hash_value)
+
+    # Create variable term
+    var_hash = store_term(collection, mk_var(fresh_var))
+
+    # Create application: M x
+    app_hash = store_term(collection, mk_app(hash_value, var_hash))
+
+    # Create abstraction: λx.(M x)
+    return store_term(collection, mk_abs(fresh_var, app_hash))
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Eta Equivalence
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def eta_equivalent(collection: CardCollection, hash1: str, hash2: str) -> bool | None:
+    """
+    Check if two terms are η-equivalent.
+
+    Performs full η-reduction on both terms and checks α-equivalence.
+    """
+    # Fully eta-reduce both terms
+    reduced1 = fully_eta_reduce(collection, hash1)
+    reduced2 = fully_eta_reduce(collection, hash2)
+
+    if reduced1 is None or reduced2 is None:
+        return None
+
+    # Check alpha equivalence
+    return alpha_equivalent(collection, reduced1, reduced2)
+
+
+def fully_eta_reduce(
+    collection: CardCollection, hash_value: str, max_steps: int = 100
+) -> str | None:
+    """
+    Repeatedly apply eta reduction until no more reductions apply.
+    """
+    current = hash_value
+    steps = 0
+
+    while steps < max_steps:
+        reduced = eta_reduce(collection, current)
+        if reduced is None:
+            return None
+
+        if reduced == current:
+            # No more reductions
+            return current
+
+        current = reduced
+        steps += 1
+
+    return current
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Combined Beta-Eta Reduction
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def beta_eta_reduce(collection: CardCollection, hash_value: str) -> str | None:
+    """
+    Perform one step of beta or eta reduction.
+    Tries beta first, then eta.
+    """
+    from clm.layer3.satori.beta_reduction import reduce_step
+
+    # Try beta reduction first
+    beta_result = reduce_step(collection, hash_value, "normal")
+    if beta_result is not None:
+        return beta_result
+
+    # Try eta reduction
+    eta_result = eta_reduce(collection, hash_value)
+    if eta_result is not None and eta_result != hash_value:
+        return eta_result
+
+    return None
+
+
+def beta_eta_normalize(
+    collection: CardCollection, hash_value: str, max_steps: int = 1000
+) -> str | None:
+    """
+    Normalize a term using both beta and eta reductions.
+    """
+    current = hash_value
+    steps = 0
+
+    while steps < max_steps:
+        reduced = beta_eta_reduce(collection, current)
+        if reduced is None:
+            return current
+
+        current = reduced
+        steps += 1
+
+    return None