Research: observer-driven scale and chart compiler for effective asymptotic analysis

[mountain]

Context

Process Geometry already separates task-relative forgetting, retained fibres/residuals, chart and frame transport, filtered asymptotic quotients, operator descent, and effective calculation. Three existing research seams now meet:

• Research: covariant process calculus over objectified fibres #124 asks when operators descend through an objectified fibre and what retained datum repairs non-descent;
• Research: infinitesimalization gate from fibred change actions to tangent and jet calculus #125 separates finite response, scale/refinement, associated tangent/jet layers, and effective analytic closure;
• Benchmarks: build a cross-regime evidence corpus for effective analysis #109 asks for a reproducible cross-regime benchmark corpus with honest baselines and total-cost accounting.

This issue opens a distinct executable question:

Can a task-relative compiler propagate an output observer backwards through a finite log--exp--power expression graph, retain only the scale information that later operations can amplify, and discover a distinguished asymptotic chart with an exact certificate and explicit failure semantics?

The motivating larger idea is that finite observers see only a local window of a scale ensemble. Surreal numbers, Hahn fields, transseries, valuations, and nonstandard structures are relevant semantic comparison models for such ensembles. They are not assumed to be the runtime representation, and no computational advantage is credited to surreal arithmetic at issue creation.

This issue authorizes a new research-local Sonnet:

sonnet/observer-driven-scale-chart-compiler/

It does not authorize an Experimental or Public API.

Research target

Freeze a deliberately small compiler whose inputs are:

finite expression DAG
parameter regime and units
output task / observer / requested order
admissible scale and chart grammar
search and resource budget

and whose output is one of:

certified chart + transformed expression + retained residual + cost
multiple incomparable certified charts
inconclusive within budget
outside declared grammar or regime
non-descent / insufficient retained scale data

The first compiler must discover balances from the expression and task. It may not receive the expected scaling exponents, named normal form, or target asymptotic answer as hidden input.

Primitive audit and initial grammar

Expressions

Use a finite exact symbolic DAG generated by a frozen subset of:

• rational constants and declared variables/parameters;
• addition and multiplication;
• reciprocal and integer/rational powers where well typed;
• exp and log on declared domains.

Branch choices, signs, zero/cancellation loci, and units remain explicit. Unsupported nesting or an undecidable comparison returns a typed failure; the grammar must not silently grow to fit a calibration.

Scale information

The first runtime carrier should be the smallest exact finite structure that supports the workloads: symbolic weights/growth constraints, leading scale classes, retained ties/cancellations, and residual provenance. A full surreal implementation is neither required nor preferred before this finite carrier fails.

Observer and task

An observer declares which output distinctions must survive: leading order, a finite asymptotic band, a residual tolerance/order, a decision boundary, or another frozen task. Forward evaluation and backward precision transport are typed separately.

Compiler law under test

For each admissible node, derive a backward obligation saying which child distinctions can affect the declared parent task. Operations such as exponentiation, large powers, and cancellation may amplify distinctions that a forward local truncation would discard.

The compiler must record:

• propagated precision/scale obligations;
• equality, dominance, and balance constraints;
• retained branch/cancellation residuals;
• the chosen chart or Pareto set of charts;
• a replayable certificate;
• compilation and repeated-evaluation cost.

First exact calibration: coalescing Airy saddle

Start from the exponent

[
S_N(t,z)=N\left(\frac{t^3}{3}-zt\right)
]

with no supplied Airy scaling. Search charts of the declared monomial form

[
t=N^{-a}u,\qquad z=N^{-b}\xi.
]

A successful certificate must derive the balance equations from the task and expression graph,

[
1-3a=0,\qquad 1-a-b=0,
]

and hence discover

[
a=\frac13,\qquad b=\frac23,
]

while returning the normalized exponent and its scope. Hard-coding (1/3), (2/3), the word “Airy”, or an equivalent oracle before discovery invalidates the run.

This is a calibration, not the novelty claim.

Three parallel workstreams

A — mathematical semantics and obstruction

1. Define finite observer equivalence at a declared scale/order.
2. State exact descent and non-descent criteria for expression operators.
3. Prove the scale-transition/refinement law used by the compiler.
4. Compare the result with valuations, Hahn/transseries semantics, nonstandard analysis, and surreal normal forms.
5. Isolate precisely what surreal semantics changes, if anything, beyond vocabulary.
6. Supply invariants, counterexamples, and kill conditions.

B — compiler prototype

1. Implement the frozen expression, observer, scale, residual, and certificate records inside the Sonnet.
2. Implement backward obligation propagation and bounded balance/chart search.
3. Discover the Airy chart without an answer oracle.
4. Expose exact failure states and replayable provenance.
5. Keep code research-local and do not introduce a generic solve(), Calculus, Jet, Surreal, or CanonicalCompiler API.

C — baselines and benchmark pressure

1. Audit and, where available, run honest baselines such as SymPy Gruntz/series, Sage asymptotic rings/growth groups, Wolfram asymptotics, and Mathemagix/transseries tooling.
2. Distinguish hand-supplied expansion variables/charts from automatic task-driven chart discovery.
3. Freeze at least:
   • the Airy calibration;
   • one independent positive candidate, preferably WKB/turning-point or singular perturbation;
   • one adversarial/negative case with ambiguity, branch dependence, cancellation, or no admissible chart;
   • one held-out case selected before compiler tuning.
4. Report correctness, compilation, evaluation, storage, residual, and decoder costs.

The three workstreams share one input/output and certificate contract. They must not evolve incompatible meanings of scale, observer, residual, or success.

Bounded phase plan

S0 — contract and evidence firewall

Freeze grammar, tasks, budgets, baselines, hidden-answer policy, held-out policy, exact/non-exact claim modes, and public coordination.

S1 — exact finite core

Produce the mathematical descent/refinement statements and an exact symbolic Airy discovery certificate.

S2 — independent pressure

Run at least one second positive candidate and one negative/adversarial case. Execute available conventional baselines on the same frozen inputs.

S3 — held-out and total-cost audit

Run a preselected held-out case without modifying the grammar or scoring rule. Separate discovery/compilation cost from repeated evaluation and charge retained residual/decoder state.

S4 — disposition

By 2026-08-31 Beijing time, publish one of:

• continue: the compiler exposes a reproducible capability absent from or materially different from the frozen baselines;
• narrow: a useful exact scale/balance certificate exists, but the broader compiler or surreal interpretation is not yet justified;
• stop: the result is notation, hard-coded balance solving, baseline-equivalent behavior, or uneconomic residual retention.

The date is a prototype decision gate, not a theorem deadline.

Acceptance criteria

• The grammar, observer, regime, units, search budget, and success/failure modes are frozen before tuning.
• Airy scales are discovered from exact balance constraints with no hidden answer or name-based rule.
• Backward observer obligations are distinguishable from ordinary forward truncation.
• One exact non-descent/amplification or cancellation certificate shows why prematurely discarded scale data changes a task result.
• At least one independent positive candidate is executed.
• At least one adversarial negative case returns the correct ambiguous/inconclusive/outside-domain result.
• One held-out case is selected before tuning and reported without grammar edits.
• Conventional baselines use the same supplied information and are reported honestly.
• Every positive result includes a replayable symbolic certificate or a declared numerical error contract.
• Compilation, evaluation, storage, residual, branch, and decoder costs are separated.
• The semantic role of surreal numbers is classified as necessary, useful, eliminable, or presently undecided.
• A machine-readable result summary and exact executable tests accompany the research note.
• The strongest claim remains no broader than the evidence.

Kill conditions

Narrow or stop the line if:

• expected scales, normal-form names, or solved charts enter the discovery input;
• the finite scale carrier merely stores the complete source expression/history under another name;
• legal reparameterizations change the answer with no typed transport or Pareto ambiguity;
• cancellation, branch changes, or competing balances are silently resolved by backend heuristics;
• the held-out case requires changing the grammar after inspection;
• an existing baseline discovers the same chart from the same information with equal or better certificates and total cost;
• any apparent gain disappears after compilation, precision growth, storage, residual, decoder, and lowering costs are charged;
• surreal arithmetic changes terminology but no theorem, obstruction, algorithm, certificate, or reachable workload;
• the research requires a generic transseries/surreal engine before the bounded finite question can be answered.

Explicit non-goals and claim ceiling

This issue does not claim or require:

• a general asymptotic, transseries, or Process Geometry compiler;
• a complete surreal-number implementation;
• that surreals replace manifolds, standard analysis, or numerical computation;
• a complexity-class separation or a new algorithm for 3D Ising;
• automatic resolution of arbitrary singular perturbations, WKB systems, phase transitions, or divergent series;
• canonical charts outside the declared grammar and task;
• a new arithmetic rank, generic tangent/jet object, or effective V5 closure theorem;
• changes to the Mathematical Core, stable Theory Map, Experimental namespace, or Public API.

Initial classification:

Epistemic maturity: T1 target; T0 until S0 is frozen
Role: local research kernel with reusable pressure
Code status: Sonnet-local
Claim mode: exact symbolic + bounded search; numerical only if separately declared

Governance effects

Mathematical Core: uses filtered fibres, task-relative adequacy, retained residuals, forward state/backward observer variance, chart/unit covariance, and objectification boundaries; no change at creation.

Research Programme: pressures U1 (task-sufficient presentation), U2 (effective analysis), and E (covariance/economy). It does not establish Arithmetic Universality.

Theory Map: research pressure on H4, filtered/refined asymptotic fibres, the task-covariant evaluation transversal, and the I3--I5 seam from #125; no maturity promotion at creation.

Engineering Architecture: opens a research-local instance of candidate generation, task adequacy, symbolic certification, failure semantics, and the benchmark-corpus gap. SymPy may compute certificates but does not define semantics.

Public API pressure: none. A successful prototype is at most an extraction candidate after independent-domain review.

[mountain]

Architecture decision: Python/SymPy shell, optional Rust kernel

The long-term implementation may use a Rust core exposed to Python, but S0/S1 remains pure Python/SymPy until the mathematical and failure contracts are frozen.

Proposed seam:

SymPy / problem-local Python grammar
    -> canonical backend-neutral expression + task contract
    -> exact kernel
       - rational scale constraints
       - DAG obligation propagation
       - dominance/tie/cancellation bookkeeping
       - bounded chart/Pareto search
       - replayable certificate and cost counters
    -> Python certificate verifier
    -> SymPy transformed expression / report / baselines

Why this split

Rust is appropriate for deterministic, ownership-heavy, repeatedly executed kernels after their semantics stabilize. Python/SymPy remains the right layer for rapidly changing research grammar, assumptions/branches, symbolic transformations, benchmark orchestration, and readable proof artifacts.

The native core must not accept or define equality through opaque SymPy objects. It should consume a small versioned IR using exact integers/rationals and return a backend-neutral certificate that Python can replay with exact equations. A Rust result is therefore an optimization, not the semantic authority.

PyO3 plus maturin is the leading packaging route for a mixed Rust/Python project. An abi3 wheel strategy is a later distribution decision, not part of this prototype.

Migration gates

Do not introduce Rust merely because a prototype exists. Migrate a component only when:

1. its input/output/failure/certificate semantics survived the Airy calibration, an independent positive case, a negative case, and held-out pressure;
2. profiling shows that the pure kernel, rather than SymPy simplification or search design, is a material bottleneck;
3. Python and Rust implementations can be differential-tested against the same exact corpus;
4. native wheel/CI/platform maintenance fits the total-cost audit;
5. the Python fallback remains usable for semantic debugging unless measurements justify removing it.

Likely Rust-owned later: exact rational constraint solving, arena DAGs, backward requirement propagation, certificate replay primitives, Pareto enumeration, and cost accounting.

Python/SymPy-owned: research grammar, domain and branch assumptions, symbolic adapters, exploratory controlled extensions, conventional CAS baselines, numerical reference solvers, and report generation.

Current decision: architecture pressure recorded; no Rust dependency or rewrite in the Monday prototype.

[mountain]

S0 evidence firewall frozen before held-out reveal

The compiler grammar, implementation, tests, scoring/failure semantics, and contract were frozen before the held-out input was revealed.

• compiler freeze manifest: 377972b2f674a06ffb66a9e99a7ac992744d214f520cacff9ac61f1a14253680
• sealed held-out commitment: 475733c57a34b3cfe2990445f38965e1d277329b7b38795ae0f85cd289f32a89

The first hash is the SHA-256 of the sorted per-file hash lines recorded in FREEZE_MANIFEST.sha256; the manifest excludes itself. The held-out preimage has not yet been supplied to the compiler workstream.

The Bessel large-order transition is conservatively not counted as strict held-out evidence because evaluator-only oracle material existed in the shared benchmark workspace. It remains an independent killer-pressure baseline.

Any grammar or implementation edit after reveal will be reported as post-held-out development and receives no discovery credit for this case.

[mountain]

S4 disposition: NARROW

The three parallel workstreams are now integrated in draft PR #141.

What is earned:

• an exact quotient/descent criterion and information-minimal observer repair;
• a frozen, oracle-free monomial-balance certificate generator;
• unhinted Airy scaling t=N^-1/3, z=N^-2/3;
• strict held-out recovery t=N^-1/4, p=N^-1/2, q=N^-3/4 after pre-reveal commitment;
• deterministic certificate replay, failure/resource budgets, and cost ledger.

What is not earned:

• no general asymptotic compiler;
• no independent-domain theorem or economy theorem;
• no claim that surreal numbers are needed at runtime;
• no Bessel turning-point discovery from raw special-function input yet.

Engineering boundary: keep the evolving grammar, SymPy adapters, and baselines in Python; extract only the stable exact-constraint/DAG/certificate kernel to Rust (PyO3 + maturin) after the IR and certificate schema are frozen.

Validation: CI run 33041081896 is green across Python 3.10/3.14 compatibility, Python 3.12 full suite, public quickstarts, distribution build, metadata checks, and wheel verification.

Next gate: a generic analytic-germ adapter plus a raw Bessel turning-point benchmark and an executable/comparable Wolfram baseline. Until that gate passes, the claim remains NARROW.

[mountain]

S2 next gate frozen before implementation

Commit db9898888402d7be8bbd7458c7e6b7d86d011497 adds the public raw-Bessel gate contract.

The frozen input is besselj(N, N*z) for positive integer N → +∞, locally at z=1. A versioned representation registry may supply a domain-qualified integral representation and provenance, but it may not contain expected scale exponents, an Airy lookup result, or benchmark-specific solver branches.

The required path is raw call → representation provenance → exact local germ → Newton-face selection → rational balance → independent certificate replay. The declared success scales are t ~ N^-1/3 and z-1 ~ N^-2/3, with non-Bessel cubic/quartic controls and typed invalid-domain failures.

Disposition remains precommitted: EXPAND only if the full pipeline and independent competitive baseline both support it; NARROW if a representation registry remains necessary or novelty is unproved; STOP on scale leakage, hidden oracle, or unreplayable certificates.

[mountain]

S2 gate completed — final disposition: NARROW

Draft PR #141 now contains the post-freeze mathematical, compiler, and independent-red-team artifacts.

Earned:

• raw besselj(N, N*z) is recognized under the declared positive-integer/real domain;
• a versioned DLMF 10.9.2 representation bridge exposes the oscillatory phase without storing scale or Airy answers;
• the generic analytic-germ path derives theta ~ N^-1/3 and z-1 ~ N^-2/3;
• local_chart_certified = true and uniform_integral_certified = false are separate machine-visible claims;
• non-Bessel cubic and frozen quartic-cusp controls pass;
• bessely, noninteger use of the integer registry, unsafe fixed scales inside analytic functions, regular saddles, and ambiguous balances fail closed;
• 15/15 S2 tests, 12/12 frozen S0/S1 tests, 10/10 post-freeze manifest checks, mathematical replay, and independent black-box replay pass.

Baseline:

• SymPy 1.14 does not discover the coupled chart from the same raw input;
• Wolfram was not executable in the available environment, so no comparative win is claimed.

Public CI run #1798 (33042749894) is green across Python 3.10/3.14 compatibility, Python 3.12 full suite, quickstarts, distribution build, metadata checks, and isolated wheel verification.

Why NARROW: the result still depends on a classical representation registry and does not certify contour localization, remote-tail cancellation, Stokes/branch data, uniform error, or economy.

Next claim-expansion gate: require a second independent representation family plus an executable same-information comparison against Wolfram or a comparably strong automatic asymptotics system.

[mountain]

The next independent representation family is now frozen as #158: Brownian scale, endpoint fibres, and heat-kernel lowering.

It uses the native-method firewall merged in #157 and addresses this issue's next gate without adding another Bessel registry entry:

• raw symmetric increment law, with no supplied Gaussian or exponent 1/2;
• blind population/scale balance;
• exact endpoint fibres and concatenation/Chapman–Kolmogorov certificate;
• Gaussian, PDE, Fourier, and Monte Carlo kept in explicit lowering/baseline lanes;
• biased and heavy-tail held-out failures.

Draft PR #141 remains a declared dependency. The Brownian initial phase will not silently copy its scale compiler while that PR is unmerged.