process-geometry 0.0.3__py3-none-any.whl

aeg_shakespeare/function_theory/weierstrass.py

@@ -0,0 +1,136 @@
+"""Exact cubic algebraization data for a genus-one process quotient.
+
+Mathematical lineage
+--------------------
+The Weierstrass model is one of the decisive bridges between elliptic function
+theory and algebraic curves.  A nonsingular cubic can be written in the short
+form
+
+    W^2 = 4 X^3 - g2 X - g3,
+
+and the same invariants ``g2`` and ``g3`` occur in the differential equation of
+the Weierstrass ``wp`` function.  The discriminant ``g2^3-27*g3^2`` detects
+singularity, while the modular invariant records the complex-isomorphism class.
+See NIST DLMF §§23.2, 23.3, and 23.19 and Silverman, *The Arithmetic of
+Elliptic Curves*.
+
+Shakespeare reconstruction
+---------------------------
+This module is downstream of process reduction.  It does not decide that a
+problem "should use Weierstrass functions".  Instead, once a process has
+already emitted a nonsingular cubic ``y^2=P_3(x)``, we expose the exact affine
+change of variables that turns that algebraic quotient into short Weierstrass
+form.  The resulting invariants can then be compared with independently
+constructed period data.
+
+Boundary
+--------
+Equal ``j`` is a statement about complex elliptic-curve isomorphism after the
+usual field hypotheses; it is not equality of process presentations, physical
+systems, period bases, or tasks.  This module does not construct ``wp`` or a
+period lattice and does not choose an analytic branch of the Abelian integral.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import sympy as sp
+
+from .algebraic import HyperellipticProfile
+
+
+@dataclass(frozen=True)
+class WeierstrassCubicProfile:
+    """Short-Weierstrass invariants and exact coordinate map for ``y^2=P_3(x)``."""
+
+    curve: HyperellipticProfile
+    X: sp.Symbol
+    W: sp.Symbol
+    x_image: sp.Expr
+    y_image: sp.Expr
+    g2: sp.Expr
+    g3: sp.Expr
+    discriminant: sp.Expr
+    klein_J: sp.Expr
+    j_invariant: sp.Expr
+
+    @property
+    def relation(self) -> sp.Expr:
+        """Return ``W^2 - (4 X^3 - g2 X - g3)``."""
+
+        return sp.expand(self.W**2 - (4 * self.X**3 - self.g2 * self.X - self.g3))
+
+    def transformation_residual(self) -> sp.Expr:
+        """Verify the affine map modulo the original cubic relation."""
+
+        pulled = sp.expand(
+            self.relation.subs({self.X: self.x_image, self.W: self.y_image})
+        )
+        reduced = sp.expand(pulled.subs(self.curve.y**2, self.curve.polynomial))
+        return sp.factor(reduced)
+
+
+def weierstrass_cubic_profile(
+    curve: HyperellipticProfile,
+    X: sp.Symbol,
+    W: sp.Symbol,
+) -> WeierstrassCubicProfile:
+    """Convert a cubic ``y^2=P_3(x)`` to short Weierstrass form exactly.
+
+    Write
+
+        P_3(x) = a x^3 + b x^2 + c x + d.
+
+    The affine change
+
+        X = (3 a x + b) / 12,
+        W = a y / 4
+
+    gives
+
+        W^2 = 4 X^3 - g2 X - g3
+
+    with
+
+        g2 = (b^2 - 3 a c) / 12,
+        g3 = (-2 b^3 + 9 a b c - 27 a^2 d) / 432.
+
+    ``Klein J`` follows the DLMF convention ``J=g2^3/Delta``; the algebraic
+    ``j`` invariant is ``1728*J``.
+    """
+
+    if curve.degree != 3:
+        raise ValueError("Weierstrass cubic profile requires degree exactly 3")
+    if curve.generic_genus != 1:
+        raise ValueError("Weierstrass cubic profile requires a generically smooth cubic")
+    if X == W:
+        raise ValueError("Weierstrass coordinates X and W must be distinct")
+
+    poly = sp.Poly(curve.polynomial, curve.x)
+    a, b, c, d = poly.all_coeffs()
+    x_image = sp.cancel((3 * a * curve.x + b) / 12)
+    y_image = sp.cancel(a * curve.y / 4)
+    g2 = sp.factor((b**2 - 3 * a * c) / 12)
+    g3 = sp.factor((-2 * b**3 + 9 * a * b * c - 27 * a**2 * d) / 432)
+    discriminant = sp.factor(g2**3 - 27 * g3**2)
+    if discriminant == 0:
+        raise ValueError("short Weierstrass discriminant vanishes identically")
+    klein_J = sp.cancel(g2**3 / discriminant)
+    j_invariant = sp.cancel(1728 * klein_J)
+
+    profile = WeierstrassCubicProfile(
+        curve=curve,
+        X=X,
+        W=W,
+        x_image=x_image,
+        y_image=y_image,
+        g2=g2,
+        g3=g3,
+        discriminant=discriminant,
+        klein_J=klein_J,
+        j_invariant=j_invariant,
+    )
+    if profile.transformation_residual() != 0:
+        raise AssertionError("internal Weierstrass transformation certificate failed")
+    return profile

aeg_shakespeare/grammar.py

@@ -0,0 +1,225 @@
+"""Bounded discovery of process-generated finite grammars.
+
+This module moves Shakespeare one step earlier than relation decomposition. A
+caller supplies seed expressions and a process action; the library grows the
+smallest exact process span it can find within an explicit search budget. If the
+span closes, the existing template-free relation machinery is applied to that
+discovered grammar.
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass
+from typing import Sequence
+
+import sympy as sp
+
+from .presentation.budget import SearchBudget
+from .process.local import ProcessSystem
+from .relations import (
+    RelationDecomposition,
+    coefficient_vector,
+    decompose,
+    discover_relation_decomposition,
+)
+
+
+@dataclass(frozen=True)
+class GeneratedGrammar:
+    """A finite grammar generated from seed expressions by process action.
+
+    ``basis`` contains only expressions that added a new exact direction to the
+    current span. ``depths`` records the process depth at which each basis item
+    first appeared. ``residuals`` are process images that escaped the discovered
+    span because a search bound was reached.
+    """
+
+    seeds: tuple[sp.Expr, ...]
+    basis: tuple[sp.Expr, ...]
+    depths: tuple[int, ...]
+    residuals: tuple[sp.Expr, ...]
+
+    @property
+    def closed(self) -> bool:
+        return not self.residuals
+
+    @property
+    def dimension(self) -> int:
+        return len(self.basis)
+
+    @property
+    def max_depth(self) -> int:
+        return max(self.depths, default=0)
+
+    def growth_profile(self) -> tuple[int, ...]:
+        """Cumulative number of independent grammar directions by depth."""
+        if not self.depths:
+            return ()
+        return tuple(
+            sum(depth <= level for depth in self.depths)
+            for level in range(self.max_depth + 1)
+        )
+
+
+@dataclass(frozen=True)
+class GeneratedPresentation:
+    """A generated grammar plus its discovered relation presentation."""
+
+    grammar: GeneratedGrammar
+    relations: RelationDecomposition | None
+    seed_coordinates: tuple[tuple[sp.Expr, ...], ...] = ()
+
+    @property
+    def complete(self) -> bool:
+        return (
+            self.grammar.closed
+            and self.relations is not None
+            and self.relations.complete
+            and len(self.seed_coordinates) == len(self.grammar.seeds)
+        )
+
+    @property
+    def primitives(self) -> tuple[sp.Expr, ...]:
+        if self.relations is None:
+            return ()
+        return self.relations.primitives
+
+
+def _in_span(
+    expr: sp.Expr,
+    basis: Sequence[sp.Expr],
+    variables: Sequence[sp.Symbol],
+) -> bool:
+    expr = sp.expand(sp.sympify(expr))
+    if expr == 0:
+        return True
+    if not basis:
+        return False
+    try:
+        coefficient_vector(expr, basis, variables)
+    except ValueError:
+        return False
+    return True
+
+
+def _polynomial_degree(expr: sp.Expr, variables: Sequence[sp.Symbol]) -> int:
+    try:
+        degree = sp.Poly(sp.expand(expr), *variables).total_degree()
+    except sp.PolynomialError as exc:
+        raise ValueError(
+            "generated-grammar discovery currently requires polynomial expressions"
+        ) from exc
+    if degree is sp.S.NegativeInfinity:
+        return 0
+    return int(degree)
+
+
+def _append_unique(residuals: list[sp.Expr], expr: sp.Expr) -> None:
+    expr = sp.expand(expr)
+    if all(sp.expand(expr - current) != 0 for current in residuals):
+        residuals.append(expr)
+
+
+def discover_generated_grammar(
+    system: ProcessSystem,
+    seeds: Sequence[sp.Expr],
+    budget: SearchBudget | None = None,
+) -> GeneratedGrammar:
+    """Grow a finite process grammar from caller-supplied seed expressions.
+
+    The algorithm performs an exact, bounded closure search. It repeatedly
+    applies the represented process generator and adds an expression only when
+    it lies outside the current span. Search stops locally when history depth,
+    polynomial degree, or the primitive-addition budget is exceeded; escaping
+    expressions are returned as residual certificates rather than projected
+    away.
+
+    ``max_new_primitives`` counts new directions added *after* the independent
+    seed directions.
+    """
+
+    budget = budget or SearchBudget()
+    normalized_seeds = tuple(sp.expand(sp.sympify(seed)) for seed in seeds)
+    if not normalized_seeds:
+        raise ValueError("at least one seed expression is required")
+
+    basis: list[sp.Expr] = []
+    depths: list[int] = []
+    queue: deque[tuple[sp.Expr, int]] = deque()
+
+    for seed in normalized_seeds:
+        _polynomial_degree(seed, system.assignments)
+        if not _in_span(seed, basis, system.assignments):
+            basis.append(seed)
+            depths.append(0)
+            queue.append((seed, 0))
+
+    if not basis:
+        raise ValueError("at least one nonzero independent seed is required")
+
+    additions = 0
+    residuals: list[sp.Expr] = []
+
+    while queue:
+        expression, depth = queue.popleft()
+        derived = sp.expand(system.derive(expression))
+        if _in_span(derived, basis, system.assignments):
+            continue
+
+        if depth >= budget.max_history_depth:
+            _append_unique(residuals, derived)
+            continue
+        if _polynomial_degree(derived, system.assignments) > budget.max_expression_degree:
+            _append_unique(residuals, derived)
+            continue
+        if additions >= budget.max_new_primitives:
+            _append_unique(residuals, derived)
+            continue
+
+        basis.append(derived)
+        depths.append(depth + 1)
+        queue.append((derived, depth + 1))
+        additions += 1
+
+    for expression in basis:
+        derived = sp.expand(system.derive(expression))
+        if not _in_span(derived, basis, system.assignments):
+            _append_unique(residuals, derived)
+
+    return GeneratedGrammar(
+        seeds=normalized_seeds,
+        basis=tuple(basis),
+        depths=tuple(depths),
+        residuals=tuple(residuals),
+    )
+
+
+def discover_generated_presentation(
+    system: ProcessSystem,
+    seeds: Sequence[sp.Expr],
+    budget: SearchBudget | None = None,
+) -> GeneratedPresentation:
+    """Discover a finite grammar, its relation factors, primitives, and decoder."""
+    budget = budget or SearchBudget()
+    grammar = discover_generated_grammar(system, seeds, budget=budget)
+    if not grammar.closed:
+        return GeneratedPresentation(grammar=grammar, relations=None)
+
+    relations = discover_relation_decomposition(
+        system,
+        grammar.basis,
+        max_order=budget.max_relation_order,
+    )
+    if relations is None or not relations.complete:
+        return GeneratedPresentation(grammar=grammar, relations=relations)
+
+    seed_coordinates = tuple(
+        decompose(seed, relations.primitives, system.assignments)
+        for seed in grammar.seeds
+    )
+    return GeneratedPresentation(
+        grammar=grammar,
+        relations=relations,
+        seed_coordinates=seed_coordinates,
+    )

aeg_shakespeare/history_geometry.py

@@ -0,0 +1,276 @@
+"""Finite history geometry and prefix-code representation strategies.
+
+This module makes one representation scheme explicit: ordered process histories
+form a prefix tree, process time can be measured by root-to-node depth, and the
+number of distinguishable prefixes at each depth gives a finite boundary/frontier
+profile.  A Huffman code is provided as one optional way to redistribute depth
+when a probability/usage measure on task-relevant outcomes is supplied.
+
+The tree geometry is a representation object, not a claim that every notion of
+computational time or space is identical to tree depth or boundary width.
+Likewise Huffman coding is a strategy layered on top of history/task structure;
+it is not part of Shakespeare's process ontology.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import heapq
+import itertools
+import math
+from typing import Callable, Generic, Hashable, Mapping, Sequence, TypeVar
+
+from .process.history import ProcessWord
+
+StepT = TypeVar("StepT")
+SymbolT = TypeVar("SymbolT", bound=Hashable)
+KeyT = TypeVar("KeyT", bound=Hashable)
+
+
+@dataclass(frozen=True)
+class BoundaryProfile:
+    """Finite prefix-frontier profile of a history family.
+
+    ``widths[d]`` is the number of distinguishable prefixes at process depth
+    ``d``.  The root is depth zero.  ``information_widths`` stores
+    ``log2(width)`` and is therefore the number of bits needed merely to name a
+    frontier element under an ideal uniform code; it is not by itself a memory
+    bound for an arbitrary execution model.
+    """
+
+    widths: tuple[int, ...]
+    information_widths: tuple[float, ...]
+
+    @property
+    def max_depth(self) -> int:
+        return len(self.widths) - 1
+
+    @property
+    def peak_width(self) -> int:
+        return max(self.widths, default=0)
+
+    @property
+    def peak_information_width(self) -> float:
+        return max(self.information_widths, default=0.0)
+
+    def exponential_growth_rates(self) -> tuple[float, ...]:
+        """Return ``log(width[d]) / d`` for positive depths."""
+        rates: list[float] = []
+        for depth, width in enumerate(self.widths[1:], start=1):
+            rates.append(math.log(width) / depth if width > 0 else -math.inf)
+        return tuple(rates)
+
+
+def history_depth(
+    history: ProcessWord[StepT],
+    step_cost: Mapping[StepT, float] | Callable[[StepT], float] | None = None,
+) -> float:
+    """Return unweighted or caller-weighted process depth of one history."""
+    if step_cost is None:
+        return float(history.depth)
+
+    if callable(step_cost):
+        cost_of = step_cost
+    else:
+        cost_of = step_cost.__getitem__
+
+    total = 0.0
+    for step in history:
+        value = float(cost_of(step))
+        if not math.isfinite(value) or value < 0:
+            raise ValueError("step costs must be finite and non-negative")
+        total += value
+    return total
+
+
+def boundary_profile(
+    histories: Sequence[ProcessWord[StepT]],
+    *,
+    max_depth: int | None = None,
+    quotient_key: Callable[[ProcessWord[StepT]], Hashable] | None = None,
+) -> BoundaryProfile:
+    """Compute finite frontier widths for a set of literal histories."""
+    histories = tuple(histories)
+    if max_depth is None:
+        bound = max((history.depth for history in histories), default=0)
+    else:
+        if max_depth < 0:
+            raise ValueError("max_depth must be non-negative")
+        bound = max_depth
+
+    identify = quotient_key or (lambda word: word)
+    widths: list[int] = []
+    information: list[float] = []
+
+    for depth in range(bound + 1):
+        prefixes: set[Hashable] = set()
+        if depth == 0:
+            prefixes.add(identify(ProcessWord()))
+        else:
+            for history in histories:
+                if history.depth < depth:
+                    continue
+                prefix = ProcessWord(history.steps[:depth])
+                prefixes.add(identify(prefix))
+        width = len(prefixes)
+        widths.append(width)
+        information.append(math.log2(width) if width > 0 else -math.inf)
+
+    return BoundaryProfile(tuple(widths), tuple(information))
+
+
+@dataclass(frozen=True)
+class PrefixCodeMetrics:
+    """Geometry/information metrics of one finite prefix presentation."""
+
+    expected_depth: float
+    worst_depth: int
+    kraft_sum: float
+    entropy: float
+    redundancy: float
+    leaf_count: int
+
+
+@dataclass(frozen=True)
+class PrefixCode(Generic[SymbolT]):
+    """A finite binary prefix code together with its source weights."""
+
+    codes: Mapping[SymbolT, tuple[int, ...]]
+    weights: Mapping[SymbolT, float]
+
+    def __post_init__(self) -> None:
+        if set(self.codes) != set(self.weights):
+            raise ValueError("codes and weights must have identical symbol sets")
+        for code in self.codes.values():
+            if not code or any(bit not in (0, 1) for bit in code):
+                raise ValueError("binary codes must be non-empty tuples of 0/1")
+        if not self.is_prefix_free():
+            raise ValueError("codes are not prefix-free")
+
+    def is_prefix_free(self) -> bool:
+        codewords = tuple(self.codes.values())
+        for i, left in enumerate(codewords):
+            for j, right in enumerate(codewords):
+                if i == j:
+                    continue
+                if len(left) <= len(right) and right[: len(left)] == left:
+                    return False
+        return True
+
+    def metrics(self) -> PrefixCodeMetrics:
+        total = sum(float(weight) for weight in self.weights.values())
+        if total <= 0:
+            raise ValueError("total code weight must be positive")
+
+        expected = 0.0
+        entropy = 0.0
+        for symbol, raw_weight in self.weights.items():
+            probability = float(raw_weight) / total
+            if probability > 0:
+                expected += probability * len(self.codes[symbol])
+                entropy -= probability * math.log2(probability)
+
+        kraft = sum(2.0 ** (-len(code)) for code in self.codes.values())
+        worst = max((len(code) for code in self.codes.values()), default=0)
+        return PrefixCodeMetrics(
+            expected_depth=expected,
+            worst_depth=worst,
+            kraft_sum=kraft,
+            entropy=entropy,
+            redundancy=expected - entropy,
+            leaf_count=len(self.codes),
+        )
+
+    def encode(self, symbols: Sequence[SymbolT]) -> tuple[int, ...]:
+        bits: list[int] = []
+        for symbol in symbols:
+            try:
+                bits.extend(self.codes[symbol])
+            except KeyError as exc:
+                raise KeyError(f"symbol has no prefix code: {symbol!r}") from exc
+        return tuple(bits)
+
+    def decode(self, bits: Sequence[int]) -> tuple[SymbolT, ...]:
+        """Decode a concatenation of codewords; reject incomplete prefixes."""
+        inverse = {code: symbol for symbol, code in self.codes.items()}
+        out: list[SymbolT] = []
+        prefix: tuple[int, ...] = ()
+        valid_prefixes = {
+            code[:length]
+            for code in inverse
+            for length in range(1, len(code) + 1)
+        }
+
+        for raw_bit in bits:
+            if raw_bit not in (0, 1):
+                raise ValueError("encoded stream must contain only 0/1")
+            prefix = prefix + (int(raw_bit),)
+            if prefix in inverse:
+                out.append(inverse[prefix])
+                prefix = ()
+            elif prefix not in valid_prefixes:
+                raise ValueError("bit stream does not match the prefix code")
+
+        if prefix:
+            raise ValueError("bit stream ends in an incomplete codeword")
+        return tuple(out)
+
+
+@dataclass(frozen=True)
+class _HuffmanNode(Generic[SymbolT]):
+    symbol: SymbolT | None = None
+    left: "_HuffmanNode[SymbolT] | None" = None
+    right: "_HuffmanNode[SymbolT] | None" = None
+
+    @property
+    def is_leaf(self) -> bool:
+        return self.symbol is not None
+
+
+def huffman_prefix_code(weights: Mapping[SymbolT, float]) -> PrefixCode[SymbolT]:
+    """Build a deterministic binary Huffman code for a finite weighted boundary."""
+    if not weights:
+        raise ValueError("at least one symbol is required")
+
+    normalized: dict[SymbolT, float] = {}
+    for symbol, raw_weight in weights.items():
+        weight = float(raw_weight)
+        if not math.isfinite(weight) or weight < 0:
+            raise ValueError("Huffman weights must be finite and non-negative")
+        normalized[symbol] = weight
+    if sum(normalized.values()) <= 0:
+        raise ValueError("at least one Huffman weight must be positive")
+
+    counter = itertools.count()
+    heap: list[tuple[float, int, _HuffmanNode[SymbolT]]] = []
+    for symbol, weight in normalized.items():
+        heapq.heappush(heap, (weight, next(counter), _HuffmanNode(symbol=symbol)))
+
+    if len(heap) == 1:
+        _weight, _serial, node = heap[0]
+        assert node.symbol is not None
+        return PrefixCode(codes={node.symbol: (0,)}, weights=normalized)
+
+    while len(heap) > 1:
+        left_weight, _left_serial, left = heapq.heappop(heap)
+        right_weight, _right_serial, right = heapq.heappop(heap)
+        parent = _HuffmanNode(left=left, right=right)
+        heapq.heappush(
+            heap,
+            (left_weight + right_weight, next(counter), parent),
+        )
+
+    root = heap[0][2]
+    codes: dict[SymbolT, tuple[int, ...]] = {}
+
+    def visit(node: _HuffmanNode[SymbolT], prefix: tuple[int, ...]) -> None:
+        if node.is_leaf:
+            assert node.symbol is not None
+            codes[node.symbol] = prefix
+            return
+        assert node.left is not None and node.right is not None
+        visit(node.left, prefix + (0,))
+        visit(node.right, prefix + (1,))
+
+    visit(root, ())
+    return PrefixCode(codes=codes, weights=normalized)

aeg_shakespeare/linear.py

@@ -0,0 +1,70 @@
+"""Linear/Krylov calibration backend.
+
+This module exists to verify that ordinary linear-algebra structure can be
+recovered *from process return relations*. Eigen/Jordan data are intentionally
+not part of the discovery API.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import reduce
+from math import gcd
+
+import sympy as sp
+
+
+@dataclass(frozen=True)
+class KrylovReturnRelation:
+    coefficients: tuple[sp.Expr, ...]
+
+    @property
+    def order(self) -> int:
+        return len(self.coefficients) - 1
+
+    def as_polynomial(self, symbol: sp.Symbol | None = None) -> sp.Expr:
+        z = symbol or sp.Symbol("X")
+        return sp.expand(sum(c * z**i for i, c in enumerate(self.coefficients)))
+
+
+def _primitive(v: sp.Matrix) -> tuple[sp.Expr, ...]:
+    qs = [sp.Rational(x) for x in v]
+    lcm = sp.ilcm(*[q.q for q in qs]) if qs else 1
+    ints = [int(q * lcm) for q in qs]
+    nz = [abs(i) for i in ints if i]
+    common = reduce(gcd, nz) if nz else 1
+    ints = [i // common for i in ints]
+    if next((i for i in ints if i), 1) < 0:
+        ints = [-i for i in ints]
+    return tuple(sp.Integer(i) for i in ints)
+
+
+def discover_krylov_relation(
+    operator: sp.Matrix,
+    vector: sp.Matrix,
+    max_order: int | None = None,
+) -> KrylovReturnRelation | None:
+    """Discover the shortest bounded recurrence in ``v, Xv, X^2v, ...``."""
+    operator = sp.Matrix(operator)
+    vector = sp.Matrix(vector)
+    if operator.rows != operator.cols:
+        raise ValueError("operator must be square")
+    if vector.rows != operator.rows or vector.cols != 1:
+        raise ValueError("vector must be a compatible column vector")
+    bound = max_order if max_order is not None else operator.rows + 1
+    orbit = [vector]
+    for _ in range(bound):
+        orbit.append(operator * orbit[-1])
+    for order in range(1, bound + 1):
+        matrix = sp.Matrix.hstack(*orbit[: order + 1])
+        candidates = [v for v in matrix.nullspace() if v[-1] != 0]
+        if candidates:
+            coeffs = _primitive(candidates[0])
+            certificate = sum(
+                (coeffs[i] * orbit[i] for i in range(order + 1)),
+                sp.zeros(operator.rows, 1),
+            )
+            if certificate != sp.zeros(operator.rows, 1):
+                raise AssertionError("Krylov return-relation verification failed")
+            return KrylovReturnRelation(coeffs)
+    return None