process-geometry 0.0.3__py3-none-any.whl

aeg_shakespeare/function_theory/am.py

@@ -0,0 +1,266 @@
+"""Function theory generated by Addition (A) and Multiplication (M).
+
+Mathematical lineage
+--------------------
+Ordinary calculus is usually taught after the additive coordinate line has
+already been chosen: translation is invisible background structure, and
+multiplication appears later as a nonlinear operation on numbers or functions.
+The AEG/Shakespeare reconstruction asks what changes if Addition and
+Multiplication themselves are treated as primitive process directions before a
+function theory is chosen.
+
+At finite scale the two processes are
+
+    T_t: (a, v) -> (a + t, v),
+    S_s: (a, v) -> (exp(s) * a, v + s),
+
+and their history is noncommutative:
+
+    S_s T_t = T_(exp(s) t) S_s.
+
+The infinitesimal shadow is therefore not two arbitrary differential operators
+but the arithmetic frame
+
+    A = d/da,
+    M = d/dv + a d/da,
+
+with ``[A, M] = A``. Function families are then judged by how simply they
+transform under these process histories. The power-weight lattice is one such
+family; process inversion exposes resonance loci, and those loci force
+logarithmic or Jordan-like extensions rather than assuming ``log`` in advance.
+
+Boundary
+--------
+A/M is the first concrete Shakespeare function theory, not the universal one.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import sympy as sp
+
+from ..process.local import ProcessFrame
+
+
+def affine_am_frame(a: sp.Symbol, v: sp.Symbol) -> ProcessFrame:
+    """Return the canonical Addition/Multiplication process frame."""
+    return ProcessFrame(
+        assignments=(a, v),
+        generators={
+            "A": {a: sp.S.One, v: sp.S.Zero},
+            "M": {a: a, v: sp.S.One},
+        },
+    )
+
+
+@dataclass(frozen=True)
+class AMState:
+    a: sp.Expr
+    v: sp.Expr
+
+
+@dataclass(frozen=True)
+class AMPowerWeight:
+    a: sp.Symbol
+    v: sp.Symbol
+    nu: sp.Expr
+    weight: sp.Expr
+
+    @property
+    def expression(self) -> sp.Expr:
+        return self.a ** self.nu * sp.exp((self.weight - self.nu) * self.v)
+
+    def product(self, other: "AMPowerWeight") -> "AMPowerWeight":
+        if self.a != other.a or self.v != other.v:
+            raise ValueError("power-weight elements must use the same A/M coordinates")
+        return AMPowerWeight(
+            self.a,
+            self.v,
+            sp.simplify(self.nu + other.nu),
+            sp.simplify(self.weight + other.weight),
+        )
+
+
+@dataclass(frozen=True)
+class AMPrimitive:
+    generator: str
+    integrand: AMPowerWeight
+    expression: sp.Expr
+    resonant: bool
+    exceptional_factor: sp.Expr
+
+
+@dataclass(frozen=True)
+class AMPathFlow:
+    start: sp.Expr
+    end: sp.Expr
+    beta_integral: sp.Expr
+    history_term: sp.Expr
+    a_end: sp.Expr
+    v_end: sp.Expr
+
+
+@dataclass(frozen=True)
+class AMFunctionTheory:
+    """Concrete function calculus generated by Addition and Multiplication."""
+
+    a: sp.Symbol
+    v: sp.Symbol
+
+    @property
+    def frame(self) -> ProcessFrame:
+        return affine_am_frame(self.a, self.v)
+
+    def A(self, expr: sp.Expr) -> sp.Expr:
+        return self.frame.apply("A", expr)
+
+    def M(self, expr: sp.Expr) -> sp.Expr:
+        return self.frame.apply("M", expr)
+
+    def commutator(self, expr: sp.Expr) -> sp.Expr:
+        return self.frame.commutator("A", "M", expr)
+
+    def add(self, state: AMState, amount: sp.Expr) -> AMState:
+        amount = sp.sympify(amount)
+        return AMState(sp.expand(state.a + amount), sp.sympify(state.v))
+
+    def multiply(self, state: AMState, log_scale: sp.Expr) -> AMState:
+        log_scale = sp.sympify(log_scale)
+        return AMState(
+            sp.expand(sp.exp(log_scale) * state.a),
+            sp.expand(state.v + log_scale),
+        )
+
+    def finite_relation_residual(
+        self,
+        state: AMState,
+        *,
+        amount: sp.Expr,
+        log_scale: sp.Expr,
+    ) -> tuple[sp.Expr, sp.Expr]:
+        amount = sp.sympify(amount)
+        log_scale = sp.sympify(log_scale)
+        left = self.multiply(self.add(state, amount), log_scale)
+        right = self.add(
+            self.multiply(state, log_scale),
+            sp.exp(log_scale) * amount,
+        )
+        return (
+            sp.simplify(left.a - right.a),
+            sp.simplify(left.v - right.v),
+        )
+
+    def power_weight(self, nu: sp.Expr, weight: sp.Expr) -> AMPowerWeight:
+        return AMPowerWeight(self.a, self.v, sp.sympify(nu), sp.sympify(weight))
+
+    def multiply_power_weights(
+        self,
+        left: AMPowerWeight,
+        right: AMPowerWeight,
+    ) -> AMPowerWeight:
+        return left.product(right)
+
+    def A_primitive(self, element: AMPowerWeight) -> AMPrimitive:
+        if element.a != self.a or element.v != self.v:
+            raise ValueError("power-weight element belongs to another A/M frame")
+        exceptional = sp.simplify(element.nu + 1)
+        if exceptional == 0:
+            primitive = sp.exp((element.weight + 1) * self.v) * sp.log(self.a)
+            return AMPrimitive(
+                generator="A",
+                integrand=element,
+                expression=primitive,
+                resonant=True,
+                exceptional_factor=exceptional,
+            )
+        next_element = self.power_weight(element.nu + 1, element.weight + 1)
+        return AMPrimitive(
+            generator="A",
+            integrand=element,
+            expression=sp.simplify(next_element.expression / exceptional),
+            resonant=False,
+            exceptional_factor=exceptional,
+        )
+
+    def M_primitive(self, element: AMPowerWeight) -> AMPrimitive:
+        if element.a != self.a or element.v != self.v:
+            raise ValueError("power-weight element belongs to another A/M frame")
+        exceptional = sp.simplify(element.weight)
+        if exceptional == 0:
+            return AMPrimitive(
+                generator="M",
+                integrand=element,
+                expression=sp.expand(self.v * element.expression),
+                resonant=True,
+                exceptional_factor=exceptional,
+            )
+        return AMPrimitive(
+            generator="M",
+            integrand=element,
+            expression=sp.simplify(element.expression / exceptional),
+            resonant=False,
+            exceptional_factor=exceptional,
+        )
+
+    def primitive_residual(self, primitive: AMPrimitive) -> sp.Expr:
+        if primitive.generator == "A":
+            image = self.A(primitive.expression)
+        elif primitive.generator == "M":
+            image = self.M(primitive.expression)
+        else:
+            raise ValueError(f"unknown A/M primitive generator: {primitive.generator!r}")
+        return sp.simplify(sp.expand(image - primitive.integrand.expression))
+
+    def shifted_M(self, expr: sp.Expr, shift: sp.Expr) -> sp.Expr:
+        return sp.expand(self.M(expr) - sp.sympify(shift) * sp.sympify(expr))
+
+    def pbw_residual(self, expr: sp.Expr, *, m: int, n: int) -> sp.Expr:
+        if m < 0 or n < 0:
+            raise ValueError("m and n must be non-negative")
+        left = self.frame.iterate("A", expr, m)
+        left = self.frame.iterate("M", left, n)
+        right = sp.sympify(expr)
+        for _ in range(n):
+            right = self.shifted_M(right, m)
+        right = self.frame.iterate("A", right, m)
+        return sp.simplify(sp.expand(left - right))
+
+    def path_flow(
+        self,
+        alpha: sp.Expr,
+        beta: sp.Expr,
+        time: sp.Symbol,
+        *,
+        start: sp.Expr,
+        end: sp.Expr,
+        a0: sp.Expr,
+        v0: sp.Expr,
+    ) -> AMPathFlow:
+        alpha = sp.sympify(alpha)
+        beta = sp.sympify(beta)
+        start = sp.sympify(start)
+        end = sp.sympify(end)
+        a0 = sp.sympify(a0)
+        v0 = sp.sympify(v0)
+
+        tau = sp.Dummy("tau")
+        sigma = sp.Dummy("sigma")
+        beta_sigma = beta.subs(time, sigma)
+        beta_integral = sp.integrate(beta_sigma, (sigma, start, end))
+        beta_to_tau = sp.integrate(beta_sigma, (sigma, start, tau))
+        alpha_tau = alpha.subs(time, tau)
+        history_term = sp.integrate(
+            sp.exp(beta_integral - beta_to_tau) * alpha_tau,
+            (tau, start, end),
+        )
+        a_end = sp.simplify(sp.exp(beta_integral) * a0 + history_term)
+        v_end = sp.simplify(v0 + beta_integral)
+        return AMPathFlow(
+            start=start,
+            end=end,
+            beta_integral=sp.simplify(beta_integral),
+            history_term=sp.simplify(history_term),
+            a_end=a_end,
+            v_end=v_end,
+        )

aeg_shakespeare/function_theory/intersection.py

@@ -0,0 +1,321 @@
+"""Sampled intersection pairing for lifted process cycles.
+
+Primitive question
+------------------
+A period matrix is only a candidate Riemann period presentation until the cycles
+carrying its periods have the right intersection structure.  On a genus-g
+oriented surface a canonical basis satisfies
+
+    a_i . a_j = 0,
+    b_i . b_j = 0,
+    a_i . b_j = delta_ij.
+
+How much of that structure can be measured directly from the sampled lifted
+histories already used by Shakespeare's period engine?
+
+Classical shadow
+----------------
+The algebraic intersection number of transverse oriented curves is the signed
+sum of their intersections.  On a hyperelliptic double cover, two projected
+base paths may cross at the same x-value while their lifts lie on opposite
+sheets, in which case there is *no* intersection on the Riemann surface.  A
+symplectic homology basis has intersection matrix
+
+    J = [[0, I], [-I, 0]].
+
+See Farkas--Kra and Forster in ``docs/REFERENCES.md``.
+
+Shakespeare reconstruction
+---------------------------
+The implementation works with the actual lifted histories rather than only the
+projected curves.  It first finds transverse intersections of polygonal base
+segments.  At each projected crossing it interpolates the two continued y
+values and asks whether the histories occupy the same sheet.  Only same-sheet
+crossings contribute their orientation sign to the sampled intersection number.
+
+This makes a subtle point executable: *projected crossing is not surface
+intersection*.  Sheet history is part of the topology.
+
+Executable contract
+-------------------
+``lifted_path_intersections`` reports every resolved projected crossing together
+with its orientation and sheet relation. ``sampled_intersection_number`` sums
+same-sheet signs and refuses unresolved sheet comparisons.  For an
+``AbelianCycleSystem``, ``sampled_intersection_form`` builds the full 2g-by-2g
+matrix in A-then-B order and compares it with the canonical symplectic form.
+
+``sampled_riemann_profile`` combines that sampled topological evidence with the
+symmetry/positive-imaginary-part checks of an ``AbelianPeriodMatrix``.
+
+Boundary
+--------
+This remains a sampled numerical topology engine, not a certified algebraic
+intersection algorithm.  Paths must be polygonally resolved, transverse, and
+away from branch points.  Tangencies, shared segments, endpoint crossings, and
+near-degenerate sheet comparisons are rejected or ignored rather than assigned
+an intersection number.  Exact homology classes and deformation invariance are
+future layers.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+import sympy as sp
+
+from .period_matrix import AbelianCycleSystem, AbelianPeriodMatrix
+from .periods import LiftedSquareRootPath
+
+SheetRelation = Literal["same", "opposite", "unresolved"]
+
+
+def _cross(left: complex, right: complex) -> float:
+    return float((left.conjugate() * right).imag)
+
+
+@dataclass(frozen=True)
+class LiftedCycleIntersection:
+    """One transverse crossing of two projected segments with sheet metadata."""
+
+    base_point: complex
+    left_segment: int
+    right_segment: int
+    orientation: int
+    sheet_relation: SheetRelation
+    relative_same_sheet_error: float
+    relative_opposite_sheet_error: float
+
+    @property
+    def contributes_on_surface(self) -> bool:
+        return self.sheet_relation == "same"
+
+
+def _proper_segment_intersection(
+    p: complex,
+    p_next: complex,
+    q: complex,
+    q_next: complex,
+    *,
+    geometry_tolerance: float,
+) -> tuple[float, float, complex, int] | None:
+    r = p_next - p
+    s = q_next - q
+    denominator = _cross(r, s)
+    if abs(denominator) <= geometry_tolerance:
+        return None
+
+    delta = q - p
+    t = _cross(delta, s) / denominator
+    u = _cross(delta, r) / denominator
+    margin = geometry_tolerance
+    if not (margin < t < 1.0 - margin and margin < u < 1.0 - margin):
+        return None
+
+    point = p + t * r
+    orientation = 1 if denominator > 0 else -1
+    return t, u, point, orientation
+
+
+def lifted_path_intersections(
+    left: LiftedSquareRootPath,
+    right: LiftedSquareRootPath,
+    *,
+    sheet_tolerance: float = 1e-3,
+    geometry_tolerance: float = 1e-12,
+    dedup_tolerance: float = 1e-8,
+) -> tuple[LiftedCycleIntersection, ...]:
+    """Measure transverse projected crossings and resolve their sheet relation."""
+
+    if left.curve != right.curve:
+        raise ValueError("lifted paths must belong to the same curve")
+    if sheet_tolerance <= 0 or geometry_tolerance <= 0 or dedup_tolerance <= 0:
+        raise ValueError("intersection tolerances must be positive")
+
+    intersections: list[LiftedCycleIntersection] = []
+    for i in range(len(left.x_values) - 1):
+        p = left.x_values[i]
+        p_next = left.x_values[i + 1]
+        left_min_x, left_max_x = sorted((p.real, p_next.real))
+        left_min_y, left_max_y = sorted((p.imag, p_next.imag))
+
+        for j in range(len(right.x_values) - 1):
+            q = right.x_values[j]
+            q_next = right.x_values[j + 1]
+            right_min_x, right_max_x = sorted((q.real, q_next.real))
+            right_min_y, right_max_y = sorted((q.imag, q_next.imag))
+
+            if left_max_x < right_min_x or right_max_x < left_min_x:
+                continue
+            if left_max_y < right_min_y or right_max_y < left_min_y:
+                continue
+
+            crossing = _proper_segment_intersection(
+                p,
+                p_next,
+                q,
+                q_next,
+                geometry_tolerance=geometry_tolerance,
+            )
+            if crossing is None:
+                continue
+            t, u, point, orientation = crossing
+
+            if any(abs(point - old.base_point) <= dedup_tolerance for old in intersections):
+                continue
+
+            left_y = left.y_values[i] + t * (left.y_values[i + 1] - left.y_values[i])
+            right_y = right.y_values[j] + u * (right.y_values[j + 1] - right.y_values[j])
+            scale = max(1.0, abs(left_y), abs(right_y))
+            same_error = abs(left_y - right_y) / scale
+            opposite_error = abs(left_y + right_y) / scale
+
+            if same_error <= sheet_tolerance and same_error < opposite_error:
+                sheet_relation: SheetRelation = "same"
+            elif opposite_error <= sheet_tolerance and opposite_error < same_error:
+                sheet_relation = "opposite"
+            else:
+                sheet_relation = "unresolved"
+
+            intersections.append(
+                LiftedCycleIntersection(
+                    base_point=point,
+                    left_segment=i,
+                    right_segment=j,
+                    orientation=orientation,
+                    sheet_relation=sheet_relation,
+                    relative_same_sheet_error=float(same_error),
+                    relative_opposite_sheet_error=float(opposite_error),
+                )
+            )
+
+    return tuple(intersections)
+
+
+def sampled_intersection_number(
+    left: LiftedSquareRootPath,
+    right: LiftedSquareRootPath,
+    *,
+    sheet_tolerance: float = 1e-3,
+) -> int:
+    """Signed same-sheet intersection count for two sampled lifted cycles."""
+
+    crossings = lifted_path_intersections(
+        left,
+        right,
+        sheet_tolerance=sheet_tolerance,
+    )
+    unresolved = [crossing for crossing in crossings if crossing.sheet_relation == "unresolved"]
+    if unresolved:
+        raise ValueError("sampled intersections contain unresolved sheet comparisons")
+    return sum(
+        crossing.orientation
+        for crossing in crossings
+        if crossing.contributes_on_surface
+    )
+
+
+def canonical_symplectic_form(genus: int) -> tuple[tuple[int, ...], ...]:
+    """Return J=[[0,I],[-I,0]] in A-then-B cycle order."""
+
+    if genus < 1:
+        raise ValueError("genus must be positive")
+    size = 2 * genus
+    rows = [[0 for _ in range(size)] for _ in range(size)]
+    for index in range(genus):
+        rows[index][genus + index] = 1
+        rows[genus + index][index] = -1
+    return tuple(tuple(row) for row in rows)
+
+
+@dataclass(frozen=True)
+class SampledIntersectionForm:
+    """Numerically measured intersection form for one A/B cycle system."""
+
+    cycles: AbelianCycleSystem
+    matrix: tuple[tuple[int, ...], ...]
+
+    @property
+    def genus(self) -> int:
+        return self.cycles.curve.generic_genus or 0
+
+    @property
+    def is_skew_symmetric(self) -> bool:
+        return all(
+            self.matrix[i][j] == -self.matrix[j][i]
+            for i in range(len(self.matrix))
+            for j in range(len(self.matrix))
+        )
+
+    @property
+    def determinant(self) -> int:
+        return int(sp.Matrix(self.matrix).det())
+
+    @property
+    def is_unimodular(self) -> bool:
+        return abs(self.determinant) == 1
+
+    @property
+    def canonical_residual(self) -> int:
+        expected = canonical_symplectic_form(self.genus)
+        return max(
+            abs(self.matrix[i][j] - expected[i][j])
+            for i in range(len(self.matrix))
+            for j in range(len(self.matrix))
+        )
+
+    @property
+    def is_canonical_symplectic(self) -> bool:
+        return (
+            self.is_skew_symmetric
+            and self.is_unimodular
+            and self.canonical_residual == 0
+        )
+
+
+def sampled_intersection_form(
+    cycles: AbelianCycleSystem,
+    *,
+    sheet_tolerance: float = 1e-3,
+) -> SampledIntersectionForm:
+    """Measure the 2g-by-2g sampled intersection matrix in A-then-B order."""
+
+    ordered = cycles.a_cycles + cycles.b_cycles
+    size = len(ordered)
+    matrix = [[0 for _ in range(size)] for _ in range(size)]
+    for i in range(size):
+        for j in range(i + 1, size):
+            value = sampled_intersection_number(
+                ordered[i],
+                ordered[j],
+                sheet_tolerance=sheet_tolerance,
+            )
+            matrix[i][j] = value
+            matrix[j][i] = -value
+    return SampledIntersectionForm(cycles, tuple(tuple(row) for row in matrix))
+
+
+@dataclass(frozen=True)
+class SampledRiemannProfile:
+    """Combined sampled topology + period-matrix consistency profile."""
+
+    periods: AbelianPeriodMatrix
+    intersections: SampledIntersectionForm
+
+    def __post_init__(self) -> None:
+        if self.periods.cycles != self.intersections.cycles:
+            raise ValueError("period and intersection data must use the same cycle system")
+
+    @property
+    def passes(self) -> bool:
+        return (
+            self.intersections.is_canonical_symplectic
+            and self.periods.riemann_shape_passes()
+        )
+
+
+def sampled_riemann_profile(
+    periods: AbelianPeriodMatrix,
+    intersections: SampledIntersectionForm,
+) -> SampledRiemannProfile:
+    return SampledRiemannProfile(periods=periods, intersections=intersections)

aeg_shakespeare/function_theory/module.py

@@ -0,0 +1,118 @@
+"""Finite function modules for process-based function theory.
+
+A function module is represented by a finite basis together with explicit action
+rules for named process generators. The action table is primary; matrices are
+not required by the public object. A symbolic ``ProcessFrame`` can be attached
+as a verifier so that a proposed low-complexity function language carries an
+exact certificate.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Mapping
+
+import sympy as sp
+
+from ..process.local import ProcessFrame
+
+Coordinates = tuple[sp.Expr, ...]
+
+
+@dataclass(frozen=True)
+class ProcessFunctionModule:
+    """A finite basis closed under declared process-generator actions."""
+
+    basis: tuple[sp.Expr, ...]
+    actions: Mapping[str, tuple[Coordinates, ...]]
+
+    def __post_init__(self) -> None:
+        basis = tuple(sp.sympify(item) for item in self.basis)
+        if not basis:
+            raise ValueError("function module requires a non-empty basis")
+        object.__setattr__(self, "basis", basis)
+
+        dimension = len(basis)
+        if not self.actions:
+            raise ValueError("function module requires at least one process action")
+        for generator, columns in self.actions.items():
+            if not generator:
+                raise ValueError("generator names must be non-empty")
+            if len(columns) != dimension:
+                raise ValueError(
+                    f"generator {generator!r} must provide one action column per basis item"
+                )
+            for coordinates in columns:
+                if len(coordinates) != dimension:
+                    raise ValueError("action coordinate vectors must match module dimension")
+
+    @property
+    def dimension(self) -> int:
+        return len(self.basis)
+
+    @property
+    def generators(self) -> tuple[str, ...]:
+        return tuple(self.actions)
+
+    def action_expression(self, generator: str, basis_index: int) -> sp.Expr:
+        if generator not in self.actions:
+            raise KeyError(f"unknown module generator: {generator!r}")
+        coordinates = self.actions[generator][basis_index]
+        return sp.expand(
+            sum(
+                sp.sympify(coefficient) * basis_item
+                for coefficient, basis_item in zip(coordinates, self.basis)
+            )
+        )
+
+    def verification_residuals(self, frame: ProcessFrame) -> Mapping[str, tuple[sp.Expr, ...]]:
+        result: dict[str, tuple[sp.Expr, ...]] = {}
+        for generator in self.generators:
+            if generator not in frame.generators:
+                raise KeyError(f"frame does not define module generator {generator!r}")
+            residuals = []
+            for index, basis_item in enumerate(self.basis):
+                declared = self.action_expression(generator, index)
+                actual = frame.apply(generator, basis_item)
+                residuals.append(sp.simplify(sp.expand(actual - declared)))
+            result[generator] = tuple(residuals)
+        return result
+
+    def verify(self, frame: ProcessFrame) -> bool:
+        return all(
+            residual == 0
+            for residuals in self.verification_residuals(frame).values()
+            for residual in residuals
+        )
+
+
+def polynomial_am_module(
+    a: sp.Symbol,
+    degree: int,
+) -> ProcessFunctionModule:
+    """Return the finite polynomial A/M module ``span(1,a,...,a**degree)``."""
+
+    if degree < 0:
+        raise ValueError("degree must be non-negative")
+    basis = tuple(a**k for k in range(degree + 1))
+    dimension = degree + 1
+
+    addition_columns: list[Coordinates] = []
+    multiplication_columns: list[Coordinates] = []
+    for k in range(dimension):
+        addition = [sp.S.Zero] * dimension
+        if k > 0:
+            addition[k - 1] = sp.Integer(k)
+        addition_columns.append(tuple(addition))
+
+        multiplication = [sp.S.Zero] * dimension
+        multiplication[k] = sp.Integer(k)
+        multiplication_columns.append(tuple(multiplication))
+
+    return ProcessFunctionModule(
+        basis=basis,
+        actions={
+            "A": tuple(addition_columns),
+            "M": tuple(multiplication_columns),
+        },
+    )