docs/MATHEMATICAL_API.md

CAELQ mathematical API

This reference describes the public functions in caelq.phase, caelq.signature, caelq.illumination, and caelq.dynamics. They use Python's standard library. Run the examples from the project root with src on PYTHONPATH, or install the local package first. The executed walkthrough is notebooks/CAELQ_Walkthrough.ipynb.

Use integers and fractions.Fraction for exact numerical inputs. The signature and illumination modules reject floating-point coefficients. phase.parity_law currently converts its argument through Fraction(s); an accidentally supplied float consequently represents its exact binary value, which can differ from the intended rational. Prefer Fraction(1, 10) to 0.1.

These are finite reference implementations. Explicit phase laws, spans, tensor words, and leaf partitions can grow exponentially. Nothing here evaluates the ideal semantic horizon or certifies a limiting theorem by computation.

1. Phase algebra

Binary vectors are nonnegative integer bitmasks. Bit j is coordinate j; addition is XOR. A port subset uses the same encoding, but its bits index ports, not phase coordinates. charges[i] is column i of the binary matrix W. A constraint h imposes binary dot product h·phase=0. Width arguments prohibit out-of-range bits.

Function	Result and contract
gf2_basis(vectors)	Canonical reduced basis as an integer tuple, with decreasing pivot positions.
gf2_rank(vectors)	Integer dimension of the span.
gf2_contains(basis, vector)	Boolean membership; the supplied basis need not be reduced.
gf2_span(basis)	All span elements in numerical order; exponential in rank.
gf2_nullspace(rows, ncols)	Basis of vectors orthogonal to all rows, within ncols bits.
charge_sum(charges, subset)	The phase charge W(subset), as a bitmask.
relation_basis(charges, phase_dimension=None)	Basis of ker(W) in port coordinates. Omitted dimension is inferred from charge widths.
seam_relation_basis(charges, phase_dimension, constraints=())	Port relations surviving uniform phase on the constrained subspace H; equivalently W(subset) belongs to the constraint span.
seam_increment(charges, phase_dimension, constraints=())	Increase in relation-space dimension.
program_seam(charges, phase_dimension, target_relations)	Minimum-rank constraint basis realizing the supplied target span. Raises ValueError unless that span contains ker(W).
phase_moment(charges, subset, phase_dimension, constraints=(), shift=0)	Exact product moment on the affine seam shift+H: -1, 0, or 1.
parity_law(k, s)	Dictionary of all sign tuples and their Fraction probabilities, 2**(-k)*(1+s*product(signs)); requires k>=1, -1<=s<=1.

The phase functions describe specified finite distributions. They do not automatically construct the manuscript's disjoint-block history coupling.

2. Tensor and curve algebra

Word = tuple[int, ...] uses zero-based axis indices. Tensor = dict[Word, Fraction] is sparse; missing coefficients mean zero. () is the scalar word, (0,) is axis E, and (0,1) is the ordered tensor E⊗M. Thus {(0,1): Fraction(1), (1,0): Fraction(-1)} encodes [E,M]. Word length is degree; the tensor unit is {(): Fraction(1)}. A Vector is a tuple of rational increments.

Multiplication concatenates words chronologically: increments a then b give exp(a)*exp(b). The group commutator is g*h*g^-1*h^-1; the Lie bracket is A*B-B*A. All requested degrees are nonnegative integers. Operations assume correctly encoded word keys; scalar normalization alone does not certify that an arbitrary supplied tensor is a path signature.

Function	Result and contract
tensor_unit()	Scalar unit tensor.
tensor_add(*tensors)	Exact sum, omitting zero coefficients.
tensor_scale(tensor, scale)	Exact scalar multiple.
tensor_multiply(left, right, degree)	Product truncated above degree.
tensor_exp(tensor, degree)	Truncated exponential; scalar component must be zero.
tensor_log(group, degree)	Truncated logarithm; scalar component must be one.
tensor_inverse(group, degree)	Truncated inverse; scalar component must be one.
vector_tensor(increment)	Degree-one tensor of a vector.
straight_signature(increment, degree)	Exponential of its degree-one tensor.
path_signature(increments, degree)	Product of straight signatures. Vectors share one positive dimension; the empty path returns the unit.
group_commutator(left, right, degree)	Group commutator with the convention above.
lie_bracket(left, right, degree)	Truncated tensor Lie bracket.
nested_commutator(increments, degree=None)	Right-nested commutator of generator exponentials.
nested_lie(increments, degree=None)	Right-nested bracket of degree-one generators.
commutator_word(increments)	Expanded chronological increment list; reversing a subword reverses order and negates increments.
commutator_segment_count(order)	Unsimplified word length 3*2**(order-1)-2, for order>=1.
circuit_signs(bits, orientation=1)	Signs with total product orientation, which is +1 or -1. Nonempty bits map to 1-2*bit; the final sign closes the circuit.
two_axis_generators(order, scale=1, shape=1, signs=None)	For k=order>=2, first k-1 vectors are signed scale*shape*E; last is signed scale*shape**(1-k)*M. Requires positive shape; signs default positive.
coefficient(tensor, word)	Exact coefficient, including zero for missing words.
tensor_l1_norm(tensor)	Sum of absolute coefficients, including the scalar.
word_variation_l1(increments)	Sum of coordinatewise absolute increments; equals Euclidean path length for axis segments.
path_vertices(increments)	Cumulative vertices including the origin; returns [] for empty input.

Both nested functions require at least one generator and default to degree equal to generator count. At step k, the nested group commutator equals the exponential of the nested Lie bracket. Higher truncations generally expose additional terms. Generator deletion applies throughout its expanded word, not just to one occurrence.

3. Masses, probabilities, and expected light

Here weights means a nonempty iterable of strictly positive exact masses summing exactly to one. signal=s lies in [-1,1]; epsilon lies strictly between zero and one. Orders k are at least two. Invalid domains raise errors.

Function	Result and contract
bernoulli_masses(p, depth)	Exact tuple of 2**depth masses, lexicographic binary order; bit zero contributes p, bit one 1-p. Requires 0<p<1, integer depth>=0.
central_mean_variance(weights, signal)	Exact pair (s, (1-s*s)*sum(w*w)) for independent leaf signs.
effective_samples(weights)	Exact 1/sum(w*w).
prescribed_variation(weights, k)	Numerical c_k*sum(w**(1/k)).
sharp_variation_lower(weights, k)	Numerical expression c_k*N_eff**(1-1/k).
sampling_lower_bound(epsilon)	Exact necessary sample-count expression (1-epsilon**2)/(4*epsilon**2), without integer rounding.
parity_total_variation(epsilon)	Exact distance epsilon between opposite parity laws.
parity_relative_entropy(epsilon)	Numerical natural-log divergence epsilon*log((1+epsilon)/(1-epsilon)).
sample_parity(k, signal, rng)	Complete sign tuple from the parity law using integer probability decisions.
sample_weighted_anchor(weights, signal, rng)	Exact rational weighted sum of independently drawn signs.
mixed_germ_expected(k, degree, signal, mode)	Exact truncated evaluation of a theoretical limiting expected germ; mode is "common" or "independent".

rng is an explicit random.Random instance. The probability protocol uses integer decisions; the generator remains pseudorandom. Numerical root and entropy outputs are floats, not interval certificates. In particular, sharp_variation_lower is not guaranteed to round downward.

The sampling bound assumes a fixed number of independent complete-vector samples, equal priors, and average error at most 1/4. Common leaf signs instead have anchor variance 1-s*s. For L=[E,[E,...,M]], the two limiting expected germs are (1+s)/2*exp(L)+(1-s)/2*exp(-L) and exp(s*L). These formulas do not give full finite-partition signatures. Their expected degree-k summaries agree; degree 2*k distinguishes them when |s|<1.

4. Finite cusp dynamics and the semantic boundary

Seam(depth, sign) requires integer depth at least three and sign ±1. Its exact properties are epsilon=4**(-depth), defect=sign*epsilon, and parameter=1/4+defect. analytic_classification is "bounded" for negative sign and "escaping" for positive sign, by the stated real-seam theorem.

Function	Result and contract
seam_product(left, right)	Seam(left.depth+right.depth, -left.sign*right.sign); defects multiply with a minus sign.
escape_bounds(depth)	EscapeBounds for (pi/4)*2**depth <= N < 2*pi*2**depth+3.
finite_prefix_gap_bound(depth, steps)	Exact 2*steps*4**(-depth); requires 0<=steps<=2**(depth-2).
observe_escape(depth, *, sign=1, precision=80, max_steps=1_000_000)	Capped Decimal orbit observation.
iterate_seam(depth, sign, steps, *, precision=80)	Tuple of Decimal values including z_0=0, stopping early at z>2.
toy_horizon(budget)	Exact finite grammar maximum plus one for E=1|E+E|E*E, with at most budget>=1 syntax nodes.
semantic_horizon(budget)	Always raises SemanticOracleRequired for valid nonnegative budgets.

The recurrence is z[n+1]=z[n]**2+parameter. Indices start at zero: crossing_index first records z>=1; escape_index first records z>2. EscapeObservation also exposes depth, sign, steps, last_value, precision, escaped, and status. Missing crossings are None. Status is "observed_escape" or "unresolved"; reaching the cap never proves boundedness.

EscapeBounds stores depth, exact lower_pi_factor, upper_pi_factor, and upper_offset; as_floats() returns numerical endpoints. Orbit precision must be at least max(30, ceil(2*depth*log10(2))+12). This guard preserves the defect, without providing interval certification. The finite grammar is a separate definition, with no claimed approximation theorem for the ideal semantic horizon.

5. Three tiny examples

Exact circuit and orientation

from caelq.phase import relation_basis, phase_moment
charges = (1, 2, 3)
assert relation_basis(charges, 2) == (7,)
assert phase_moment(charges, 3, 2) == 0
assert phase_moment(charges, 7, 2) == 1

Conserved area and synchronization

from fractions import Fraction
from caelq.signature import two_axis_generators, nested_commutator, coefficient
from caelq.illumination import mixed_germ_expected
area = nested_commutator(two_axis_generators(2, shape=3), degree=2)
assert coefficient(area, (0, 1)) == 1
common = mixed_germ_expected(2, 4, Fraction(1, 3), "common")
independent = mixed_germ_expected(2, 4, Fraction(1, 3), "independent")
assert coefficient(common, (0, 1, 0, 1)) == Fraction(1, 2)
assert coefficient(independent, (0, 1, 0, 1)) == Fraction(1, 18)

Capped observation and explicit refusal

from caelq.dynamics import observe_escape, semantic_horizon, SemanticOracleRequired
assert observe_escape(8, max_steps=64).status == "unresolved"
assert observe_escape(8, max_steps=2048).escape_index == 802  # Numerical observation.
try:
    semantic_horizon(8)
except SemanticOracleRequired as error:
    print(error)