process-geometry 0.0.3__py3-none-any.whl

aeg_shakespeare/presentation/__init__.py

@@ -0,0 +1,23 @@
+"""Finite process presentations: history quotients, grammars, relations, and search."""
+
+from . import (
+    canonicalization,
+    constraints,
+    construction,
+    grammar,
+    history,
+    morphism,
+    relations,
+    search,
+)
+
+__all__ = [
+    "history",
+    "construction",
+    "constraints",
+    "canonicalization",
+    "grammar",
+    "relations",
+    "search",
+    "morphism",
+]

aeg_shakespeare/presentation/budget.py

@@ -0,0 +1,27 @@
+"""Explicit finite search budgets for process-presentation discovery."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class SearchBudget:
+    """Finite search limits for local representation discovery.
+
+    Bounded search is part of the presentation contract: general word/relation
+    problems need not be decidable, so search limits remain explicit data.
+    """
+
+    max_history_depth: int = 8
+    max_expression_degree: int = 4
+    max_relation_order: int = 8
+    max_new_primitives: int = 8
+
+    def __post_init__(self) -> None:
+        values = (
+            self.max_history_depth,
+            self.max_expression_degree,
+            self.max_relation_order,
+            self.max_new_primitives,
+        )
+        if any(value < 0 for value in values):
+            raise ValueError("search-budget values must be non-negative")

aeg_shakespeare/presentation/canonicalization.py

@@ -0,0 +1,143 @@
+"""Experimental exact constraint canonicalization.
+
+The generic research concept is *canonicalization*: a local rule selecting a
+low-complexity observer representation.  This module implements only the first
+backend forced by independent calibrations, namely exact finite equations
+
+    Phi(local data, observer parameters) = 0.
+
+``ConstraintCanonicalization`` obtains observer motion by differentiating those
+equations along declared base rates and solving for observer-parameter rates.
+This realizes
+
+    local canonicalization -> connection -> observer ODE
+
+without claiming that every useful canonicalization is algebraic.  Kepler
+orthogonality/osculation already provides a red team against such a claim;
+stationary, projection, or cost-based backends should be promoted separately
+only when their retained semantics are calibrated.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Mapping
+
+import sympy as sp
+
+
+@dataclass(frozen=True)
+class ConstraintCanonicalization:
+    """Exact local constraints selecting observer parameters."""
+
+    observer_parameters: tuple[sp.Symbol, ...]
+    constraints: tuple[sp.Expr, ...]
+    label: str = ""
+
+    def __post_init__(self) -> None:
+        parameters = tuple(self.observer_parameters)
+        if not parameters:
+            raise ValueError("canonicalization requires observer parameters")
+        if len(set(parameters)) != len(parameters):
+            raise ValueError("observer parameters must be distinct")
+        constraints = tuple(
+            sp.expand(sp.sympify(constraint))
+            for constraint in self.constraints
+            if sp.expand(sp.sympify(constraint)) != 0
+        )
+        if not constraints:
+            raise ValueError("canonicalization requires at least one nonzero constraint")
+        object.__setattr__(self, "observer_parameters", parameters)
+        object.__setattr__(self, "constraints", constraints)
+
+    def differentiated_constraints(
+        self,
+        base_rates: Mapping[sp.Symbol, sp.Expr],
+        observer_rates: Mapping[sp.Symbol, sp.Expr],
+    ) -> tuple[sp.Expr, ...]:
+        """Differentiate ``Phi=0`` along base and observer parameter rates.
+
+        Symbols not named in either mapping are treated as locally frozen
+        parameters.  This keeps the operation explicitly local and prevents the
+        canonicalization object from reaching into a trajectory or propagator.
+        """
+
+        missing = set(self.observer_parameters) - set(observer_rates)
+        if missing:
+            raise ValueError(
+                "missing rates for observer parameters: "
+                f"{sorted(map(str, missing))}"
+            )
+
+        rates = {
+            **{
+                symbol: sp.sympify(value)
+                for symbol, value in base_rates.items()
+            },
+            **{
+                symbol: sp.sympify(value)
+                for symbol, value in observer_rates.items()
+            },
+        }
+        return tuple(
+            sp.expand(
+                sum(
+                    sp.diff(constraint, symbol) * rate
+                    for symbol, rate in rates.items()
+                )
+            )
+            for constraint in self.constraints
+        )
+
+    def induced_connection(
+        self,
+        base_rates: Mapping[sp.Symbol, sp.Expr],
+        *,
+        label: str = "",
+    ):
+        """Solve the differentiated constraints for local observer rates.
+
+        The current implementation requires a unique symbolic local solution.
+        Residual gauge freedom, singular strata, least-squares stationarity, and
+        branch selection remain explicit future API questions rather than being
+        silently resolved here.
+        """
+
+        from ..analysis.connection import ObserverConnection
+
+        rate_symbols = {
+            parameter: sp.Dummy(f"d_{parameter}")
+            for parameter in self.observer_parameters
+        }
+        equations = self.differentiated_constraints(base_rates, rate_symbols)
+        unknowns = tuple(rate_symbols[parameter] for parameter in self.observer_parameters)
+        solutions = sp.solve(
+            tuple(sp.Eq(equation, 0) for equation in equations),
+            unknowns,
+            dict=True,
+            simplify=True,
+        )
+        if len(solutions) != 1 or any(
+            unknown not in solutions[0]
+            for unknown in unknowns
+        ):
+            raise ValueError(
+                "canonicalization does not induce a unique local observer connection"
+            )
+
+        solution = solutions[0]
+        observer_rates = {
+            parameter: sp.simplify(solution[rate_symbols[parameter]])
+            for parameter in self.observer_parameters
+        }
+        residuals = self.differentiated_constraints(base_rates, observer_rates)
+        return ObserverConnection(
+            canonicalization=self,
+            base_rates=base_rates,
+            observer_rates=observer_rates,
+            residuals=residuals,
+            label=label or self.label,
+        )
+
+
+__all__ = ["ConstraintCanonicalization"]

aeg_shakespeare/presentation/constraints.py

@@ -0,0 +1,5 @@
+"""Exact algebraic constraints used by finite process presentations."""
+
+from ..constraints import AlgebraicConstraintSet, constraint_prolongation
+
+__all__ = ["AlgebraicConstraintSet", "constraint_prolongation"]

aeg_shakespeare/presentation/construction.py

@@ -0,0 +1,19 @@
+"""Construction-history-preserving primitive proposals."""
+
+from ..construction import (
+    PrimitiveConstruction,
+    PrimitiveProposal,
+    PrimitiveProposalResult,
+    RejectedPrimitiveProposal,
+    SymbolicOperation,
+    generate_primitive_proposals,
+)
+
+__all__ = [
+    "PrimitiveConstruction",
+    "PrimitiveProposal",
+    "PrimitiveProposalResult",
+    "RejectedPrimitiveProposal",
+    "SymbolicOperation",
+    "generate_primitive_proposals",
+]

aeg_shakespeare/presentation/grammar.py

@@ -0,0 +1,15 @@
+"""Generated finite process grammars and presentations."""
+
+from ..grammar import (
+    GeneratedGrammar,
+    GeneratedPresentation,
+    discover_generated_grammar,
+    discover_generated_presentation,
+)
+
+__all__ = [
+    "GeneratedGrammar",
+    "GeneratedPresentation",
+    "discover_generated_grammar",
+    "discover_generated_presentation",
+]

aeg_shakespeare/presentation/history.py

@@ -0,0 +1,45 @@
+"""History rewriting, task signatures, and finite history geometry."""
+
+from ..history_geometry import (
+    BoundaryProfile,
+    PrefixCode,
+    PrefixCodeMetrics,
+    boundary_profile,
+    history_depth,
+    huffman_prefix_code,
+)
+from ..rewrite import (
+    RewriteResult,
+    RewriteStep,
+    WordRewriteRule,
+    normalize_word,
+    rewrite_once,
+)
+from ..signature import (
+    ProcessJetSignature,
+    enumerate_process_words,
+    histories_task_equivalent,
+    history_process_jet_signature,
+    process_jet_signature,
+    signatures_equivalent,
+)
+
+__all__ = [
+    "RewriteResult",
+    "RewriteStep",
+    "WordRewriteRule",
+    "normalize_word",
+    "rewrite_once",
+    "ProcessJetSignature",
+    "enumerate_process_words",
+    "histories_task_equivalent",
+    "history_process_jet_signature",
+    "process_jet_signature",
+    "signatures_equivalent",
+    "BoundaryProfile",
+    "PrefixCode",
+    "PrefixCodeMetrics",
+    "boundary_profile",
+    "history_depth",
+    "huffman_prefix_code",
+]

aeg_shakespeare/presentation/morphism.py

@@ -0,0 +1,66 @@
+"""Evidence-bearing transformations between process presentations.
+
+Mathematical pressure
+---------------------
+Three independent research calibrations now force the same minimal shape.
+
+* KdV: a tau presentation and a parametric scattering-history presentation can
+  encode the same pair/three-body interaction data, while a locally confluent
+  rewrite can still be incomplete for the tau task.
+* Resistor networks: Schur/Y-Delta transformations can produce syntactically
+  different graphs with exactly the same declared boundary response.
+* Braids: Markov stabilization can preserve closure semantics while changing
+  braid index and therefore the dimension/type of the chosen representation.
+
+The shared object is not a universal rewrite rule.  It is an evidence-bearing
+arrow between a source presentation and a target presentation, whose validity is
+always relative to an explicitly declared task semantics.
+
+Boundary
+--------
+``PresentationMorphism`` deliberately does *not* define:
+
+* a universal equality or verification method;
+* composition, inverses, identities, or a category/groupoid structure;
+* a normal-form relation;
+* a requirement that source and target have the same Python type;
+* a requirement that certificates be exact rather than numerical/bounded.
+
+Those structures should be promoted only when further independent calibrations
+show what information composition and verification must retain.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Generic, TypeVar
+
+SourceT = TypeVar("SourceT")
+TargetT = TypeVar("TargetT")
+TaskSemanticsT = TypeVar("TaskSemanticsT")
+CertificateT = TypeVar("CertificateT")
+
+
+@dataclass(frozen=True)
+class PresentationMorphism(
+    Generic[SourceT, TargetT, TaskSemanticsT, CertificateT]
+):
+    """A task-relative, certificate-carrying presentation transformation.
+
+    ``source`` and ``target`` may be entirely different representation types.
+    ``task_semantics`` records what meaning is claimed to be preserved.
+    ``certificate`` is caller-defined evidence for that claim; Shakespeare does
+    not interpret it generically.  ``witness`` may record a rewrite trace,
+    construction history, parameter map, or other provenance for how the target
+    was obtained.
+    """
+
+    source: SourceT
+    target: TargetT
+    task_semantics: TaskSemanticsT
+    certificate: CertificateT
+    witness: object | None = None
+    label: str = ""
+
+
+__all__ = ["PresentationMorphism"]

aeg_shakespeare/presentation/relations.py

@@ -0,0 +1,31 @@
+"""Exact process relations, factorization, kernels, and decomposition."""
+
+from ..relations import (
+    ProcessPolynomialRelation,
+    RelationDecomposition,
+    RelationKernel,
+    ReturnRelation,
+    action_matrix,
+    coefficient_vector,
+    decompose,
+    discover_operator_relation,
+    discover_relation_decomposition,
+    discover_relation_kernel,
+    discover_return_relation,
+    factor_process_relation,
+)
+
+__all__ = [
+    "ProcessPolynomialRelation",
+    "RelationDecomposition",
+    "RelationKernel",
+    "ReturnRelation",
+    "action_matrix",
+    "coefficient_vector",
+    "decompose",
+    "discover_operator_relation",
+    "discover_relation_decomposition",
+    "discover_relation_kernel",
+    "discover_return_relation",
+    "factor_process_relation",
+]

aeg_shakespeare/presentation/search.py

@@ -0,0 +1,31 @@
+"""Budgets, costs, Pareto filtering, and presentation search."""
+
+from .budget import SearchBudget
+from ..cost import PresentationCost
+from ..search import (
+    ConstructedPrimitivePresentation,
+    ExactReconstructionPresentation,
+    PresentationCandidate,
+    PresentationSearchResult,
+    construction_aware_exact_reconstruction_cost,
+    evaluate_exact_reconstruction_presentation,
+    pareto_frontier,
+    search_exact_reconstruction_presentations,
+    search_primitive_proposals,
+    structural_exact_reconstruction_cost,
+)
+
+__all__ = [
+    "SearchBudget",
+    "PresentationCost",
+    "ConstructedPrimitivePresentation",
+    "ExactReconstructionPresentation",
+    "PresentationCandidate",
+    "PresentationSearchResult",
+    "construction_aware_exact_reconstruction_cost",
+    "evaluate_exact_reconstruction_presentation",
+    "pareto_frontier",
+    "search_exact_reconstruction_presentations",
+    "search_primitive_proposals",
+    "structural_exact_reconstruction_cost",
+]

aeg_shakespeare/process/__init__.py

@@ -0,0 +1,16 @@
+"""Process ontology: histories, finite process families, and local generators."""
+
+from . import finite, history, local
+from .finite import ProcessFamily
+from .history import ProcessWord
+from .local import ProcessFrame, ProcessSystem
+
+__all__ = [
+    "history",
+    "finite",
+    "local",
+    "ProcessWord",
+    "ProcessFamily",
+    "ProcessSystem",
+    "ProcessFrame",
+]

aeg_shakespeare/process/finite/__init__.py

@@ -0,0 +1,43 @@
+"""Finite parameterized process structure.
+
+Families, scalar responses, actions, and additive central composition residuals
+live together here because they are structures on finite process composition.
+The package deliberately stops before universal group, representation,
+cohomology, topology, or measure hierarchies.
+"""
+
+from .cocycle import (
+    CocycleVerification,
+    ProcessCocycle,
+    central_commutator_residual,
+    verify_process_cocycle,
+)
+from .families import (
+    CharacterVerification,
+    FamilyAction,
+    FamilyActionVerification,
+    FamilyStep,
+    ProcessCharacter,
+    ProcessFamily,
+    character_invariance_residual,
+    transport_process_character,
+    verify_family_action,
+    verify_process_character,
+)
+
+__all__ = [
+    "ProcessFamily",
+    "FamilyStep",
+    "ProcessCharacter",
+    "CharacterVerification",
+    "verify_process_character",
+    "FamilyAction",
+    "FamilyActionVerification",
+    "verify_family_action",
+    "transport_process_character",
+    "character_invariance_residual",
+    "ProcessCocycle",
+    "CocycleVerification",
+    "verify_process_cocycle",
+    "central_commutator_residual",
+]

aeg_shakespeare/process/finite/cocycle.py

@@ -0,0 +1,166 @@
+"""Additive central residuals for finite process-family composition.
+
+This module is intentionally narrower than a central-extension or cohomology
+framework.  It records one structure now forced independently by Galilean
+mechanics and magnetic translations:
+
+* a visible ``ProcessFamily`` has its ordinary parameter-composition law;
+* a lifted realization may compose with an additional additive scalar residual
+  ``omega(g, h)``; and
+* associativity of the lifted composition is exactly the 2-cocycle identity.
+
+The central value is represented by a SymPy expression and combined additively.
+It may be an action-like quantity, a phase exponent, or another caller-defined
+central coordinate.  Shakespeare does not identify it with U(1), choose a
+quantization convention, quotient cocycles by coboundaries, or construct a full
+central-extension group.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, Generic, Sequence, TypeVar
+
+import sympy as sp
+
+from .families import ProcessFamily
+
+ParamT = TypeVar("ParamT")
+
+
+@dataclass(frozen=True)
+class ProcessCocycle(Generic[ParamT]):
+    """An additive central composition residual over one ``ProcessFamily``.
+
+    For a visible composition ``g*h``, a lifted realization is represented by
+
+    ``(g, z) * (h, w) = (g*h, z + w + omega(g, h))``.
+
+    The object stores only ``omega`` and the visible family.  Whether a given
+    residual is physically a phase, action, charge, mass contribution, flux, or
+    something else belongs to the caller's realization.
+    """
+
+    family: ProcessFamily[ParamT]
+    residual: Callable[[ParamT, ParamT], sp.Expr] = field(repr=False, compare=False)
+    label: object | None = None
+    simplify: Callable[[sp.Expr], sp.Expr] = field(
+        default=sp.simplify,
+        repr=False,
+        compare=False,
+    )
+
+    def value(self, left: ParamT, right: ParamT) -> sp.Expr:
+        return sp.sympify(self.simplify(sp.sympify(self.residual(left, right))))
+
+    def cocycle_residual(self, first: ParamT, second: ParamT, third: ParamT) -> sp.Expr:
+        """Residual of the additive 2-cocycle identity.
+
+        Exact associativity of lifted composition requires
+
+        ``omega(g,h) + omega(g*h,k) = omega(h,k) + omega(g,h*k)``.
+        """
+
+        gh = self.family.compose_parameters(first, second)
+        hk = self.family.compose_parameters(second, third)
+        residual = (
+            self.value(first, second)
+            + self.value(gh, third)
+            - self.value(second, third)
+            - self.value(first, hk)
+        )
+        return sp.sympify(self.simplify(sp.expand(residual)))
+
+    def compose_lifted(
+        self,
+        left: tuple[ParamT, sp.Expr],
+        right: tuple[ParamT, sp.Expr],
+    ) -> tuple[ParamT, sp.Expr]:
+        """Compose two lifted elements using the declared central residual."""
+
+        left_parameter, left_central = left
+        right_parameter, right_central = right
+        parameter = self.family.compose_parameters(left_parameter, right_parameter)
+        central = self.simplify(
+            sp.sympify(left_central)
+            + sp.sympify(right_central)
+            + self.value(left_parameter, right_parameter)
+        )
+        return parameter, sp.sympify(central)
+
+
+@dataclass(frozen=True)
+class CocycleVerification:
+    """Bounded exact certificate for a ``ProcessCocycle``."""
+
+    cocycle_residuals: tuple[sp.Expr, ...]
+    normalization_residuals: tuple[sp.Expr, ...] = ()
+
+    @property
+    def exact(self) -> bool:
+        return all(
+            residual == 0
+            for residual in (*self.cocycle_residuals, *self.normalization_residuals)
+        )
+
+
+def verify_process_cocycle(
+    cocycle: ProcessCocycle[ParamT],
+    triples: Sequence[tuple[ParamT, ParamT, ParamT]],
+    *,
+    normalization_parameters: Sequence[ParamT] = (),
+) -> CocycleVerification:
+    """Verify the cocycle law and optional identity normalization exactly.
+
+    Like the family/character verification layer, this is a bounded certificate.
+    Symbolic triples may establish identities over an unbounded parameter domain
+    when the backend simplifies the resulting residuals exactly.
+    """
+
+    cocycle_residuals = tuple(
+        cocycle.cocycle_residual(first, second, third)
+        for first, second, third in triples
+    )
+
+    normalization: list[sp.Expr] = []
+    if normalization_parameters:
+        if cocycle.family.identity is None:
+            raise ValueError("cocycle normalization requires a declared family identity")
+        identity = cocycle.family.identity
+        for parameter in normalization_parameters:
+            normalization.append(cocycle.value(identity, parameter))
+            normalization.append(cocycle.value(parameter, identity))
+
+    return CocycleVerification(
+        cocycle_residuals=cocycle_residuals,
+        normalization_residuals=tuple(normalization),
+    )
+
+
+def central_commutator_residual(
+    cocycle: ProcessCocycle[ParamT],
+    left: ParamT,
+    right: ParamT,
+    *,
+    require_visible_commutation: bool = True,
+) -> sp.Expr:
+    """Return the ordering residual for visibly commuting family elements.
+
+    If the base compositions ``left*right`` and ``right*left`` agree, their
+    lifted compositions can still differ centrally by
+
+    ``omega(left,right) - omega(right,left)``.
+
+    By default the function refuses to call this a *central commutator* unless
+    the visible family elements commute.  Callers studying noncommuting base
+    elements should inspect the two cocycle values directly.
+    """
+
+    if require_visible_commutation:
+        left_right = cocycle.family.compose_parameters(left, right)
+        right_left = cocycle.family.compose_parameters(right, left)
+        if not cocycle.family.parameters_equivalent(left_right, right_left):
+            raise ValueError("central commutator residual requires visibly commuting parameters")
+
+    residual = cocycle.value(left, right) - cocycle.value(right, left)
+    return sp.sympify(cocycle.simplify(sp.expand(residual)))