research: split native AMP evaluation from matrix transport

sonnet/README.md

@@ -196,7 +196,11 @@ basis turns composition into an exact sparse nilpotent matrix and the
 long-horizon coordinate into a triangular linear solve.  It eliminates
 exponential symbolic support and supplies exact residual certificates, while a
 strong logarithmic recurrence prevents any claim of universal numerical
-speedup.  The result is `EXPAND-NARROW` and remains Sonnet-local.
+speedup.  Its second phase separates an exact inverse-state AMP evaluator from
+the coefficient compiler: scalar numerical limits now use a constant-width
+process recurrence with an analytic tail bound, while sparse matrices remain
+offline coefficient/replay certificates.  The result is `EXPAND-NARROW` and
+remains Sonnet-local.
 
 ## Research-local calibration — the \(S^6\) complex structure claim
 

sonnet/amp-polynomial-matrix-compiler/00-problem-frontier.md

@@ -1,7 +1,8 @@
 # Problem frontier: do AMP polynomials and matrices simplify an algorithm?
 
-Status: frozen contract for issue
-[#152](https://github.com/mountain/process-geometry/issues/152).
+Status: frozen contract for issues
+[#152](https://github.com/mountain/process-geometry/issues/152) and
+[#154](https://github.com/mountain/process-geometry/issues/154).
 
 ## 1. The question
 
@@ -43,27 +44,39 @@ F(y)=dy+\log(1+tq^d),
 g(q)=e^{-F(y)}=\frac{q^d}{1+tq^d}.
 \]
 
-The main observer is the normalized long-horizon quantity
+The scalar readout is the normalized long-horizon quantity
 
 \[
 G_N(y)=d^{-N}F^{\circ N}(y)
 \]
 
-and its limit when the asymptotic coordinate converges.  This is deliberately
+and its limit when the escape coordinate converges.  This is deliberately
 narrower than reconstructing the full iterate or orbit.
 
+Two computational tasks must not be conflated:
+
+1. **numerical limit:** evaluate one scalar escape coordinate to a requested
+   analytic-tail tolerance;
+2. **coefficient readout:** recover a finite polynomial-like coordinate and an
+   exact transport/residual certificate for reuse or symbolic inspection.
+
+The first task does not require coefficients.  The second task does.
+
 ## 3. Same-information baselines
 
-Three paths receive separate ledgers.
+Four paths receive separate ledgers.
 
 1. **Expanded symbolic baseline:** form `f^[N](x)` as one ordinary expanded
    polynomial.
 2. **Strong numerical baseline:** update `F(y)` directly in the logarithmic
    chart, accumulate the normalized correction, and stop when floating-point
    correction is zero.  It is forbidden to expand the polynomial.
-3. **AMP compiler:** compile a finite polynomial-like escape coordinate once
+3. **Native AMP evaluator:** update the inverse state `q` directly, accumulate
+   the exact process-level decomposition, and stop from an analytic tail bound.
+   It may not call the series or matrix compiler.
+4. **AMP compiler:** compile a finite polynomial-like escape coordinate once
    from a sparse substitution matrix, then evaluate it for the declared
-   observer.
+   readout.  Its online phase uses the degree-ray variable `z=q^d`.
 
 The expanded baseline measures symbolic support only.  It may not be used as
 the sole numerical competitor.
@@ -74,8 +87,9 @@ the sole numerical competitor.
 - observer order and nonzero polynomial-like terms;
 - dense versus sparse matrix entries;
 - exact compilation and residual certificate;
+- native process levels, state width, primitive evaluations, and tail bound;
 - strong-baseline executed steps;
-- compile-once/evaluate-many online work;
+- compile-once/evaluate-many Horner work;
 - numerical error across observer orders;
 - chart failure outside the asymptotic domain;
 - decoder and output scope.
@@ -100,13 +114,17 @@ Narrow or stop a claim if:
 - one scalar long-time observer is presented as full-orbit reconstruction;
 - a classical Böttcher/Koopman result is claimed as new.
 
+Here “Koopman observable” means a function on state used by the classical
+composition operator.  It is not identified with a Process Geometry observer,
+which also carries task, information, chart, and certification semantics.
+
 ## 6. Claim ceiling
 
 This phase does not claim a new Böttcher theorem, generic Koopman solver,
 complexity-class improvement, Ising solver, or Public API.
 
 ```text
-Epistemic maturity: T1 exact finite compiler + bounded numerical calibration
+Epistemic maturity: T1 exact finite compiler + certified native calibration
 Engineering status: Sonnet-local Python
 Mathematical Core: unchanged
 ```

sonnet/amp-polynomial-matrix-compiler/02-benchmark-results.md

@@ -1,7 +1,7 @@
 # Benchmark results
 
-Status: exact support/certificate measurements plus bounded floating-point
-calibration.
+Status: exact support/certificate measurements plus certified native and
+bounded compiled floating-point calibration.
 
 ## 1. Frozen instance
 
@@ -27,6 +27,15 @@ It detects that the interaction correction has underflowed to zero after nine
 executed steps in binary64 arithmetic.  This early stop is retained as a
 positive baseline result.
 
+The native inverse-state evaluator reaches the same binary64 value after four
+process levels and reports the analytic tail bound
+
+\[
+4.03\times10^{-23}<10^{-15}.
+\]
+
+This is a truncation-tail statement, not a total floating-point error bound.
+
 ## 2. Symbolic support
 
 For positive `t`, the fully expanded iterate has
@@ -49,7 +58,26 @@ polynomial; its observer state remains `K` ray coefficients plus the affine
 This is a real symbolic and storage simplification.  It does not imply the
 same factor against direct numerical recurrence.
 
-## 3. Sparse compilation and accuracy
+## 3. Native process calibration
+
+The native evaluator uses one initial exponential, one `log1p` and one inverse
+state update per retained process level, four persistent working scalars, and
+no series or matrix construction.  It fails closed if binary64 inverse-state
+or tail arithmetic underflows before a trustworthy bound can be reported.
+
+| Initial `y` | Process levels | Reported analytic tail bound | Binary64 value |
+|---:|---:|---:|---:|
+| 0.0 | 6 | `3.54e-25` | `0.4073545227394800` |
+| 0.5 | 5 | `5.53e-21` | `0.6746578808175746` |
+| 1.0 | 4 | `9.27e-17` | `1.0670158740022506` |
+| 1.5 | 4 | `4.03e-23` | `1.5248559772600594` |
+| 2.0 | 4 | `7.48e-30` | `2.0091558398904660` |
+
+The point `y=0`, where the finite asymptotic series becomes unstable, remains
+well behaved for the exact process recurrence.  This is a domain separation,
+not evidence that every AMP chart is global.
+
+## 4. Sparse compilation and accuracy
 
 | Order `K` | Dense entries | Sparse entries | Nonzero `h_k` | First residual | Absolute error |
 |---:|---:|---:|---:|---:|---:|
@@ -62,7 +90,20 @@ same factor against direct numerical recurrence.
 All coefficients, sparse entries, and residuals are exact rationals.  Only
 the final evaluation/error comparison uses floating point.
 
-## 4. Strong-baseline red team
+## 5. Same-accuracy and strong-baseline red team
+
+At `y=1.5`, choosing the smallest tested compiled order that meets each target
+gives the following structural online comparison.  `K/2` is the number of
+degree-ray Horner slots; the native column is the number of `log1p` process
+levels.
+
+| Target | Native levels | Compiled `K` | Compiled error | Horner slots | Sparse compile entries |
+|---:|---:|---:|---:|---:|---:|
+| `1e-6` | 3 | 8 | `2.60e-7` | 4 | 10 |
+| `1e-8` | 3 | 12 | `3.73e-10` | 6 | 21 |
+| `1e-10` | 3 | 14 | `4.82e-11` | 7 | 28 |
+| `1e-12` | 4 | 18 | `7.17e-13` | 9 | 45 |
+| `1e-15` | 4 | 22 | `6.66e-16` | 11 | 66 |
 
 For 100 queries at `K=20`:
 
@@ -71,16 +112,20 @@ compile once:
   55 sparse entries
   20 triangular divisions
 online compiled proxy:
-  9 nonzero series terms per query
+  10 degree-ray Horner slots (9 nonzero coefficients) per query
+native process:
+  4 log1p levels per query with a 4.03e-23 analytic tail
 strong recurrence:
   9 executed correction steps per query in binary64
 ```
 
-The online structural counts are comparable.  Compilation overhead means the
-AMP path does **not** earn a universal single-query floating-point speedup.
-At `K=10`, four nonzero terms give about `1.5e-8` absolute error and can be an
-economical batch approximation, but the tradeoff depends on tolerance,
-initial chart, numeric backend, and number of queries.
+The compiled Horner path may be faster after enough repeated same-chart
+queries, because its online operations are simple multiply-adds.  The native
+path has no coefficient build, accepts parameter variation directly, retains
+constant-width state, and supplies a stopping certificate.  Therefore neither
+path earns a universal runtime win: the crossover depends on tolerance,
+initial chart, backend, validation policy, and reuse count.  Wall-clock timing
+is deliberately not a CI assertion.
 
 The main earned advantages are instead:
 
@@ -90,7 +135,7 @@ The main earned advantages are instead:
 - a reusable compile-once coordinate for many states or parameter sweeps;
 - exposing the support geometry and failure boundary.
 
-## 5. Negative chart control
+## 6. Negative chart control
 
 At `y_0=0`, the asymptotic series is outside its safe region.  The errors are
 
@@ -102,9 +147,10 @@ K=20: more than 4.0
 Increasing observer order makes the answer worse.  A finite AMP truncation is
 therefore not a globally convergent numerical method.  The compiler must
 carry a chart/domain certificate or use residual-driven adaptation; order
-alone is not safety.
+alone is not safety.  The native process path is the default for this scalar
+numerical task in its certified `y>=0, t>0` domain.
 
-## 6. Replay
+## 7. Replay
 
 The executable tests independently verify:
 
@@ -113,6 +159,9 @@ The executable tests independently verify:
 - the exact eigenrelation and first omitted residual;
 - expanded support counts against explicit small iterates;
 - convergence against the strong logarithmic recurrence;
+- native evaluation without coefficient or matrix compiler calls;
+- analytic-tail, domain, process-budget, and primitive-cost reporting;
+- degree-ray Horner replay with a generic-support fallback;
 - sparse/dense cost separation;
 - failure outside the asymptotic chart;
 - typed refusal for invalid or cancellation-prone frozen tasks.

sonnet/amp-polynomial-matrix-compiler/03-disposition.md

@@ -1,6 +1,6 @@
 # Disposition: selective algorithmic simplification
 
-Status: issue #152 result.
+Status: issues #152 and #154 result.
 
 ## 1. Verdict by layer
 
@@ -9,8 +9,9 @@ Status: issue #152 result.
 | AMP polynomial-like basis | **EXPAND** | compresses degree-`d^N` expanded support into a fixed observer ray and exposes the correct asymptotic coordinate |
 | AMP matrix-like transport | **EXPAND** | composition becomes an exact sparse nilpotent matrix and the conjugacy becomes a triangular linear solve |
 | Exact certificate/replay | **EXPAND** | rational coefficients, finite eigenrelation, and first omitted residual replay independently |
-| Single-query floating-point speed | **NARROW** | strong logarithmic recurrence stops early and can equal or beat compiled evaluation |
-| Global numerical method | **STOP outside chart** | higher truncation can diverge near the non-asymptotic region |
+| Native inverse-state evaluator | **EXPAND** | evaluates the scalar limit without Taylor coefficients or matrices and returns a tail/cost ledger |
+| Compiled repeated-query speed | **NARROW** | degree-ray Horner can reduce online arithmetic, but compilation and crossover remain task dependent |
+| Finite series outside chart | **STOP** | higher truncation can diverge near the non-asymptotic region |
 | Generic interacting dynamics | **OPEN** | one power-dominant scalar family is not a general AMP solver |
 
 The overall disposition is
@@ -19,12 +20,12 @@ The overall disposition is
 \boxed{\texttt{EXPAND-NARROW}}.
 \]
 
-Both proposed layers earned real algorithmic roles, but only for specified
-observers and charts.
+The native and compiled layers earn different algorithmic roles.  Neither is
+promoted as a generic AMP runtime.
 
 ## 2. What was actually simplified
 
-The representation changes the algorithmic structure:
+For coefficient readout, the representation changes the algorithmic structure:
 
 \[
 \text{nonlinear repeated state map}
@@ -48,6 +49,17 @@ the result alone:
 This is the first exact example in the AMP line where the two sides form one
 algorithm rather than two analogies.
 
+For scalar numerical evaluation, however, linearization is unnecessary:
+
+\[
+q_{n+1}=\frac{q_n^d}{1+tq_n^d},\qquad
+H(y)=y+\sum_{n\ge0}d^{-n-1}\log(1+tq_n^d).
+\]
+
+This native recurrence is now the default path.  The matrix is an offline
+compiler/certificate for a different task, not the ontology of the nonlinear
+process and not a required runtime intermediate.
+
 ## 3. What remains classical and what is programme-specific
 
 The Böttcher conjugacy, escape-rate function, and Koopman composition operator