process-geometry 0.0.3__py3-none-any.whl

aeg_shakespeare/process/finite/families.py

@@ -0,0 +1,318 @@
+"""Finite parameterized process families and their scalar responses.
+
+This module is deliberately smaller than a group-, representation-, or harmonic-
+analysis framework.  It records only the structure forced by the Translation,
+Dilation, and Addition/Multiplication calibration sequence:
+
+* a named finite process family whose parameters have an explicit composition
+  law;
+* scalar multiplicative responses to one family;
+* an action of one family on the parameter space of another; and
+* transport/compatibility checks for those scalar responses.
+
+Topology, measure, inverses, Lie theory, spectra, Fourier transforms, and
+operator-valued representations are intentionally absent.  They should enter
+only when later mathematical vignettes require them.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, Generic, Sequence, TypeVar
+
+import sympy as sp
+
+ParamT = TypeVar("ParamT")
+ActingParamT = TypeVar("ActingParamT")
+TargetParamT = TypeVar("TargetParamT")
+
+
+def _default_parameter_equivalence(left, right) -> bool:
+    """Small exact/symbolic equality helper for family parameters.
+
+    Tuples are compared componentwise.  Scalar symbolic values are compared by
+    simplifying their difference when possible.  Callers with richer parameter
+    objects may supply their own equivalence predicate to ``ProcessFamily``.
+    """
+
+    if isinstance(left, tuple) and isinstance(right, tuple):
+        return len(left) == len(right) and all(
+            _default_parameter_equivalence(a, b) for a, b in zip(left, right)
+        )
+    try:
+        return sp.simplify(sp.sympify(left) - sp.sympify(right)) == 0
+    except (TypeError, ValueError, sp.SympifyError):
+        return left == right
+
+
+@dataclass(frozen=True)
+class FamilyStep(Generic[ParamT]):
+    """One finite step from a named parameterized process family."""
+
+    family_name: str
+    parameter: ParamT
+
+
+@dataclass(frozen=True)
+class ProcessFamily(Generic[ParamT]):
+    """A finite process family with an explicit parameter-composition law.
+
+    ``ProcessFamily`` intentionally does not assert that the parameters form a
+    group.  A family may later turn out to have identities, inverses, topology,
+    or measure, but none of those structures are required here.
+    """
+
+    name: str
+    combine: Callable[[ParamT, ParamT], ParamT] = field(repr=False, compare=False)
+    identity: ParamT | None = None
+    equivalent: Callable[[ParamT, ParamT], bool] | None = field(
+        default=None,
+        repr=False,
+        compare=False,
+    )
+
+    def __post_init__(self) -> None:
+        if not self.name:
+            raise ValueError("process-family name must be non-empty")
+
+    def step(self, parameter: ParamT) -> FamilyStep[ParamT]:
+        return FamilyStep(self.name, parameter)
+
+    def compose_parameters(self, left: ParamT, right: ParamT) -> ParamT:
+        """Parameter of the composed finite process ``F_left F_right``."""
+
+        return self.combine(left, right)
+
+    def parameters_equivalent(self, left: ParamT, right: ParamT) -> bool:
+        predicate = self.equivalent or _default_parameter_equivalence
+        return bool(predicate(left, right))
+
+    def fold_parameters(self, parameters: Sequence[ParamT]) -> ParamT:
+        """Reduce an ordered same-family history to one family parameter."""
+
+        parameters = tuple(parameters)
+        if not parameters:
+            if self.identity is None:
+                raise ValueError("empty family history requires a declared identity")
+            return self.identity
+        value = parameters[0]
+        for parameter in parameters[1:]:
+            value = self.compose_parameters(value, parameter)
+        return value
+
+
+@dataclass(frozen=True)
+class ProcessCharacter(Generic[ParamT]):
+    """A SymPy-valued scalar response candidate for one finite process family.
+
+    The defining mathematical test is multiplicativity with respect to the
+    family's own composition law.  Analytic regularity and completeness are not
+    part of this object.
+    """
+
+    family: ProcessFamily[ParamT]
+    response: Callable[[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, parameter: ParamT) -> sp.Expr:
+        return sp.sympify(self.response(parameter))
+
+    def multiplicativity_residual(self, left: ParamT, right: ParamT) -> sp.Expr:
+        combined = self.family.compose_parameters(left, right)
+        residual = self.value(combined) - self.value(left) * self.value(right)
+        return sp.sympify(self.simplify(residual))
+
+    def normalization_residual(self) -> sp.Expr:
+        if self.family.identity is None:
+            raise ValueError("character normalization requires a declared family identity")
+        return sp.sympify(self.simplify(self.value(self.family.identity) - 1))
+
+
+@dataclass(frozen=True)
+class CharacterVerification:
+    """Exact residual certificate for a bounded character check."""
+
+    multiplicativity_residuals: tuple[sp.Expr, ...]
+    normalization_residual: sp.Expr | None = None
+
+    @property
+    def exact(self) -> bool:
+        return all(residual == 0 for residual in self.multiplicativity_residuals) and (
+            self.normalization_residual in (None, 0)
+        )
+
+
+def verify_process_character(
+    character: ProcessCharacter[ParamT],
+    parameter_pairs: Sequence[tuple[ParamT, ParamT]],
+    *,
+    check_identity: bool = True,
+) -> CharacterVerification:
+    """Verify multiplicativity on caller-supplied parameter pairs.
+
+    This is a bounded exact certificate, not a proof over an unbounded parameter
+    domain unless the supplied symbolic pairs themselves establish such an
+    identity through the backend simplifier.
+    """
+
+    residuals = tuple(
+        character.multiplicativity_residual(left, right)
+        for left, right in parameter_pairs
+    )
+    normalization = None
+    if check_identity and character.family.identity is not None:
+        normalization = character.normalization_residual()
+    return CharacterVerification(residuals, normalization)
+
+
+@dataclass(frozen=True)
+class FamilyAction(Generic[ActingParamT, TargetParamT]):
+    """An explicit action of one process family on another family's parameters.
+
+    For a left action ``alpha`` the intended law is
+
+    ``alpha(g*h, b) = alpha(g, alpha(h, b))``
+
+    together with preservation of the target-family composition law.  The
+    action itself is primary; no semidirect-product or group object is created.
+    """
+
+    acting: ProcessFamily[ActingParamT]
+    target: ProcessFamily[TargetParamT]
+    apply: Callable[[ActingParamT, TargetParamT], TargetParamT] = field(
+        repr=False,
+        compare=False,
+    )
+    name: str = "action"
+
+    def __post_init__(self) -> None:
+        if not self.name:
+            raise ValueError("family-action name must be non-empty")
+
+    def transport_parameter(
+        self,
+        acting_parameter: ActingParamT,
+        target_parameter: TargetParamT,
+    ) -> TargetParamT:
+        return self.apply(acting_parameter, target_parameter)
+
+
+@dataclass(frozen=True)
+class FamilyActionVerification:
+    """Bounded law certificate for a ``FamilyAction``."""
+
+    target_homomorphism_checks: tuple[bool, ...]
+    acting_composition_checks: tuple[bool, ...]
+    identity_checks: tuple[bool, ...] = ()
+
+    @property
+    def exact(self) -> bool:
+        return all(
+            (*self.target_homomorphism_checks, *self.acting_composition_checks, *self.identity_checks)
+        )
+
+
+def verify_family_action(
+    action: FamilyAction[ActingParamT, TargetParamT],
+    *,
+    acting_parameters: Sequence[ActingParamT] = (),
+    acting_pairs: Sequence[tuple[ActingParamT, ActingParamT]] = (),
+    target_parameters: Sequence[TargetParamT] = (),
+    target_pairs: Sequence[tuple[TargetParamT, TargetParamT]] = (),
+    check_identities: bool = True,
+) -> FamilyActionVerification:
+    """Verify the two elementary finite-action laws on supplied samples."""
+
+    target_checks: list[bool] = []
+    for acting_parameter in acting_parameters:
+        for left, right in target_pairs:
+            lhs = action.transport_parameter(
+                acting_parameter,
+                action.target.compose_parameters(left, right),
+            )
+            rhs = action.target.compose_parameters(
+                action.transport_parameter(acting_parameter, left),
+                action.transport_parameter(acting_parameter, right),
+            )
+            target_checks.append(action.target.parameters_equivalent(lhs, rhs))
+
+    acting_checks: list[bool] = []
+    for left, right in acting_pairs:
+        combined = action.acting.compose_parameters(left, right)
+        for target_parameter in target_parameters:
+            lhs = action.transport_parameter(combined, target_parameter)
+            rhs = action.transport_parameter(
+                left,
+                action.transport_parameter(right, target_parameter),
+            )
+            acting_checks.append(action.target.parameters_equivalent(lhs, rhs))
+
+    identity_checks: list[bool] = []
+    if check_identities:
+        if action.acting.identity is not None:
+            for target_parameter in target_parameters:
+                image = action.transport_parameter(action.acting.identity, target_parameter)
+                identity_checks.append(
+                    action.target.parameters_equivalent(image, target_parameter)
+                )
+        if action.target.identity is not None:
+            for acting_parameter in acting_parameters:
+                image = action.transport_parameter(
+                    acting_parameter,
+                    action.target.identity,
+                )
+                identity_checks.append(
+                    action.target.parameters_equivalent(image, action.target.identity)
+                )
+
+    return FamilyActionVerification(
+        target_homomorphism_checks=tuple(target_checks),
+        acting_composition_checks=tuple(acting_checks),
+        identity_checks=tuple(identity_checks),
+    )
+
+
+def transport_process_character(
+    character: ProcessCharacter[TargetParamT],
+    action: FamilyAction[ActingParamT, TargetParamT],
+    acting_parameter: ActingParamT,
+    *,
+    label: object | None = None,
+) -> ProcessCharacter[TargetParamT]:
+    """Pull a target-family character along one finite family action."""
+
+    if action.target.name != character.family.name:
+        raise ValueError("family action target must match character family")
+    transported_label = label
+    if transported_label is None:
+        transported_label = (action.name, acting_parameter, character.label)
+    return ProcessCharacter(
+        family=character.family,
+        response=lambda parameter: character.value(
+            action.transport_parameter(acting_parameter, parameter)
+        ),
+        label=transported_label,
+        simplify=character.simplify,
+    )
+
+
+def character_invariance_residual(
+    character: ProcessCharacter[TargetParamT],
+    action: FamilyAction[ActingParamT, TargetParamT],
+    acting_parameter: ActingParamT,
+    target_parameter: TargetParamT,
+) -> sp.Expr:
+    """Residual for whether a scalar character survives a family action unchanged.
+
+    Nonzero residual is an obstruction to treating the target character as an
+    action-invariant scalar response of the combined finite process structure.
+    """
+
+    transported = transport_process_character(character, action, acting_parameter)
+    residual = transported.value(target_parameter) - character.value(target_parameter)
+    return sp.sympify(character.simplify(residual))

aeg_shakespeare/process/history.py

@@ -0,0 +1,53 @@
+"""Literal ordered process histories and caller-supplied semantics."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Generic, Iterator, TypeVar
+
+StepT = TypeVar("StepT")
+StateT = TypeVar("StateT")
+
+
+@dataclass(frozen=True)
+class ProcessWord(Generic[StepT]):
+    """An ordered finite process history.
+
+    ``ProcessWord`` deliberately stores steps without interpreting them. The
+    same history can therefore be given different semantics by different
+    presentations or observers.
+    """
+
+    steps: tuple[StepT, ...] = ()
+
+    def __iter__(self) -> Iterator[StepT]:
+        return iter(self.steps)
+
+    def __len__(self) -> int:
+        return len(self.steps)
+
+    @property
+    def depth(self) -> int:
+        return len(self.steps)
+
+    def then(self, step: StepT) -> "ProcessWord[StepT]":
+        return ProcessWord(self.steps + (step,))
+
+    def compose(self, other: "ProcessWord[StepT]") -> "ProcessWord[StepT]":
+        return ProcessWord(self.steps + other.steps)
+
+
+def interpret_history(
+    history: ProcessWord[StepT],
+    initial: StateT,
+    transition,
+) -> StateT:
+    """Interpret an ordered history under a caller-supplied transition rule."""
+
+    state = initial
+    for step in history:
+        state = transition(state, step)
+    return state
+
+
+__all__ = ["ProcessWord", "interpret_history"]

aeg_shakespeare/process/local/__init__.py

@@ -0,0 +1,7 @@
+"""Local/infinitesimal process realizations."""
+
+from .direction import ProcessDirection
+from .frame import ProcessFrame
+from .system import ProcessSystem
+
+__all__ = ["ProcessSystem", "ProcessFrame", "ProcessDirection"]

aeg_shakespeare/process/local/direction.py

@@ -0,0 +1,88 @@
+"""Experimental local process directions over a declared ``ProcessFrame``.
+
+This module is the first vertical slice for the canonical-observer programme.
+A ``ProcessDirection`` is deliberately smaller than a path, flow, solver, or
+connection: it is only the local combination
+
+    D = sum_i u_i X_i
+
+of already-declared process generators.  Ordinary assignment ODEs are obtained
+only after projecting this process direction to the assignment symbols.
+
+The object is intentionally not reparameterization-invariant.  Two proportional
+directions can have different analytic and reconstruction costs (Sundman-type
+regularization is the motivating red team), so quotienting them is a task-level
+decision rather than process ontology.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Mapping
+
+import sympy as sp
+
+from .frame import ProcessFrame
+from .system import ProcessSystem
+
+
+@dataclass(frozen=True)
+class ProcessDirection:
+    """One local linear combination of named process generators.
+
+    Missing frame generators have coefficient zero.  Coefficients may depend on
+    assignments, external parameters, or other symbolic local data; the class
+    does not interpret where those coefficients came from.
+    """
+
+    frame: ProcessFrame
+    coefficients: Mapping[str, sp.Expr]
+    label: str = ""
+
+    def __post_init__(self) -> None:
+        unknown = set(self.coefficients) - set(self.frame.names)
+        if unknown:
+            raise ValueError(
+                "direction coefficients reference unknown generators: "
+                f"{sorted(unknown)}"
+            )
+        normalized = {
+            name: sp.expand(sp.sympify(value))
+            for name, value in self.coefficients.items()
+        }
+        object.__setattr__(self, "coefficients", normalized)
+
+    def coefficient(self, generator: str) -> sp.Expr:
+        if generator not in self.frame.generators:
+            raise KeyError(f"unknown process generator: {generator!r}")
+        return sp.sympify(self.coefficients.get(generator, sp.S.Zero))
+
+    def apply(self, expr: sp.Expr) -> sp.Expr:
+        """Apply the combined process direction to one symbolic expression."""
+
+        out = sp.S.Zero
+        for generator in self.frame.names:
+            coefficient = self.coefficient(generator)
+            if coefficient != 0:
+                out += coefficient * self.frame.apply(generator, expr)
+        return sp.expand(out)
+
+    def assignment_rules(self) -> Mapping[sp.Symbol, sp.Expr]:
+        """Return the assignment shadow of this process direction."""
+
+        return {
+            assignment: self.apply(assignment)
+            for assignment in self.frame.assignments
+        }
+
+    def as_system(self, *, name: str = "D") -> ProcessSystem:
+        """Lower the direction to the existing one-generator symbolic backend."""
+
+        return ProcessSystem(
+            assignments=self.frame.assignments,
+            rules=self.assignment_rules(),
+            name=name,
+        )
+
+
+__all__ = ["ProcessDirection"]

aeg_shakespeare/process/local/frame.py

@@ -0,0 +1,73 @@
+"""Generic symbolic frames with multiple ordered process generators.
+
+A ``ProcessFrame`` is a representation backend for several named derivations on
+one assignment algebra. It connects literal ``ProcessWord`` history to symbolic
+process calculus without assuming commutativity or a universal Lie algebra.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Mapping
+
+import sympy as sp
+
+from ..history import ProcessWord
+
+
+@dataclass(frozen=True)
+class ProcessFrame:
+    """A finite family of named derivations on a symbolic assignment algebra."""
+
+    assignments: tuple[sp.Symbol, ...]
+    generators: Mapping[str, Mapping[sp.Symbol, sp.Expr]]
+
+    def __post_init__(self) -> None:
+        if not self.assignments:
+            raise ValueError("process frame requires at least one assignment")
+        if not self.generators:
+            raise ValueError("process frame requires at least one generator")
+        for name, rules in self.generators.items():
+            if not name:
+                raise ValueError("generator names must be non-empty")
+            missing = [symbol for symbol in self.assignments if symbol not in rules]
+            if missing:
+                raise ValueError(f"generator {name!r} is missing rules for {missing}")
+
+    @property
+    def names(self) -> tuple[str, ...]:
+        return tuple(self.generators)
+
+    def apply(self, generator: str, expr: sp.Expr) -> sp.Expr:
+        """Apply one named derivation using the Leibniz/chain rule."""
+        if generator not in self.generators:
+            raise KeyError(f"unknown process generator: {generator!r}")
+        expr = sp.sympify(expr)
+        rules = self.generators[generator]
+        out = sp.S.Zero
+        for assignment in self.assignments:
+            out += sp.diff(expr, assignment) * rules[assignment]
+        return sp.expand(out)
+
+    def apply_word(self, word: ProcessWord[str], expr: sp.Expr) -> sp.Expr:
+        """Apply generators in literal process-history order."""
+        value = sp.sympify(expr)
+        for generator in word:
+            value = self.apply(generator, value)
+        return sp.expand(value)
+
+    def commutator(self, left: str, right: str, expr: sp.Expr) -> sp.Expr:
+        """Return ``[left,right] expr = left(right(expr))-right(left(expr))``."""
+        return sp.expand(
+            self.apply(left, self.apply(right, expr))
+            - self.apply(right, self.apply(left, expr))
+        )
+
+    def iterate(self, generator: str, expr: sp.Expr, count: int) -> sp.Expr:
+        """Apply one generator repeatedly ``count`` times."""
+        if count < 0:
+            raise ValueError("count must be non-negative")
+        value = sp.sympify(expr)
+        for _ in range(count):
+            value = self.apply(generator, value)
+        return sp.expand(value)

aeg_shakespeare/process/local/system.py

@@ -0,0 +1,43 @@
+"""One-generator local process realizations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Mapping
+
+import sympy as sp
+
+
+@dataclass(frozen=True)
+class ProcessSystem:
+    """A named derivation-style representation of a local process generator.
+
+    ``derive`` is one symbolic realization of process action. Shakespeare does
+    not equate this backend with the full process-history ontology.
+    """
+
+    assignments: tuple[sp.Symbol, ...]
+    rules: Mapping[sp.Symbol, sp.Expr]
+    name: str = "D"
+
+    def __post_init__(self) -> None:
+        missing = [a for a in self.assignments if a not in self.rules]
+        if missing:
+            raise ValueError(f"missing process rules for assignments: {missing}")
+
+    def derive(self, expr: sp.Expr) -> sp.Expr:
+        """Apply the represented process generator using the Leibniz chain rule."""
+        expr = sp.sympify(expr)
+        out = sp.S.Zero
+        for assignment in self.assignments:
+            out += sp.diff(expr, assignment) * self.rules[assignment]
+        return sp.expand(out)
+
+    def iterate(self, expr: sp.Expr, depth: int) -> list[sp.Expr]:
+        """Return ``[expr, D(expr), ..., D**depth(expr)]``."""
+        if depth < 0:
+            raise ValueError("depth must be non-negative")
+        orbit = [sp.expand(sp.sympify(expr))]
+        for _ in range(depth):
+            orbit.append(self.derive(orbit[-1]))
+        return orbit