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

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.