research: completed AM power-weight compiler

sonnet/README.md

@@ -83,6 +83,7 @@ deferred until its next oracle/evidence gate is affordable.
 | [`pcr3bp-history-cost/`](pcr3bp-history-cost/) | Phases 0–1 complete; Phase 2 frozen | lifted topology and scale-jet reconstruction separate word, clock, deck, and hyperbolic costs; no Bellman/Huffman source is yet justified | [Phase-2 contract](pcr3bp-history-cost/02-return-partition-holonomy-contract.md); next run the frozen two-gate covariance and convergence gates |
 | [`am-conformal-chart-normal-forms/`](am-conformal-chart-normal-forms/) | T0/T1; Phase 1 mechanism calibrated | exact Riccati lift, Möbius covariance, scalar-gauge invariance, cubic no-go, and eight-axis Pareto accounting; no discovery or economy theorem | [Phase-1 results](am-conformal-chart-normal-forms/02-phase1-riccati-results.md); next freeze a blind low-height grammar and run bounded recovery |
 | [`effective-scale-carrier-ladder/`](effective-scale-carrier-ladder/) | T1 / NARROW | finite syntax decision eliminates a surreal runtime; symbolic height is a real C2 obstruction, but semantic evaluation and C3/C4 separation remain open | [results](effective-scale-carrier-ladder/01-results.md), [compiler](../workstreams/carrier_ladder/compiler/), and [commit--reveal audit](../workstreams/carrier_ladder/redteam/); next implement an effective normalized hyperiteration fragment, not a general surreal runtime |
+| [`am-power-weight-compiler/`](am-power-weight-compiler/) | T1 / EXPAND | 12/12 frozen public cases and nonce-protected held-out pass with exact replay; sparse distant readout shows a 2-weight versus 33-weight window advantage, but no general performance or surreal claim | [results](am-power-weight-compiler/01-results.md), [compiler](../workstreams/am_weight_compiler/), and [commit--reveal audit](../workstreams/am_weight_compiler/HELD_OUT_REVEAL.json); next freeze a separate AM goal front-end and transport corpus |
 | [`s6-complex-arithmetic-tower/`](s6-complex-arithmetic-tower/) | T0 initialization | auditable two-question research contract only; neither the manuscript nor an arithmetic interface is verified | [problem frontier](s6-complex-arithmetic-tower/00-problem-frontier.md); next archive/checksum the source and reproduce its matrix/topology certificate |
 | [`boltzmann-bbgky-h-theorem/`](boltzmann-bbgky-h-theorem/) | Phase 1I charted fibre-response calibration passed | 47 exact certificates through Phases 1C and 1E–1I; target Lyapunov decrease need not survive continued fibre response; contrast/odds expose a chart-relative dynamics/composition tradeoff; no continuum response theorem, fibre objectification, or generic entropy claim | [Phase 1I result](boltzmann-bbgky-h-theorem/18-phase1i-charted-fibre-calculus-results.md); next run the separate finite collision-covector and continuum fibre-response gates |
 

sonnet/am-power-weight-compiler/00-problem-frontier.md

@@ -0,0 +1,123 @@
+# Completed AM power--weight compiler
+
+## Problem and task
+
+Can the native Addition/Multiplication affine function language be made into
+an exact, replayable coefficient compiler whose semantic carrier is the
+power--weight algebra and its observer-directed completion, rather than an
+ordinary polynomial, matrix, jet, or generic computer-algebra series?
+
+The primitive continuous processes are
+
+\[
+T_t(a,v)=(a+t,v),
+\qquad
+S_s(a,v)=(e^s a,v+s),
+\]
+
+with finite and infinitesimal laws
+
+\[
+S_sT_t=T_{e^st}S_s,
+\qquad
+[A,M]=A.
+\]
+
+The native basis is
+
+\[
+\Phi_{\nu,w}=a^\nu e^{(w-\nu)v},
+\]
+
+not the polynomial calibration module `span(1,a,...,a^n)`. Literal ordered
+process words, their symbolic action, and observer coefficient readouts remain
+separately typed.
+
+## Primitive audit
+
+- **base coefficient domain:** exact rationals;
+- **constant readout extension:** finite rational linear combinations of
+  formal `exp(q)` atoms, with `exp(q)exp(r)=exp(q+r)`;
+- **power degree:** integer `nu`;
+- **exponential character:** rational `lambda = w - nu`;
+- **M-weight:** rational `w`;
+- **base algebra:** finite support in `(nu,w)`;
+- **completion:** allowed only along a declared positive rational weight cone;
+- **task:** one exact target weight or bounded weight band;
+- **residual:** all weights strictly above the observer horizon;
+- **resonance:** a typed extension, never a silent base-algebra element.
+
+The finite-LE chart from issue #144 is not identified with the native AM
+frame. Any later bridge must be an explicit task-relative adapter.
+
+## Construction and laws
+
+Multiplication is sparse convolution on the power--weight lattice. The native
+operators satisfy
+
+\[
+M\Phi_{\nu,w}=w\Phi_{\nu,w},
+\qquad
+A\Phi_{\nu,w}=\nu\Phi_{\nu-1,w-1},
+\]
+
+and replay must verify
+
+\[
+M^nA^m=A^m(M-m)^n.
+\]
+
+`ExpPositive` and `LogOnePlusPositive` denote elements of the declared
+completion. They must answer a finite observer by dependency-directed exact
+coefficient extraction. Neither compiler nor replay may call a generic
+`limit()` or unrestricted `series()` oracle.
+
+At `nu=-1`, an Addition primitive requires the positive-real logarithmic
+extension; at `w=0`, a Multiplication primitive requires the `v` Jordan
+extension. With `ordinary-only` policy those inputs fail closed.
+
+## Solver plan
+
+- research-local Python implementation with `Fraction` and a small exact
+  formal exponential-constant algebra;
+- strict JSON corpus and canonical digests;
+- memoized coefficient dependency evaluation;
+- specialized monomial coefficient rules where independently replayable;
+- compact certificate containing source/context digests, requested and
+  visited weights, operator laws, extensions, failures, costs, and claim scope;
+- replay from source and context, not from a stored expansion trace;
+- same-information SymPy baseline kept non-authoritative;
+- seconds-scale unit, corpus, tamper, manifest, and default-CI bridge tests.
+
+## Cost axes
+
+Compilation, coefficient operations, visited weights, maximum live support,
+certificate bytes, replay operations, baseline wall time, and baseline peak
+support are reported separately. Shorter syntax or a correct coefficient does
+not establish economy.
+
+## Evidence firewall
+
+Grammar, coefficient domain, positive-cone semantics, operator laws,
+completion rules, resonance policy, budgets, public controls, scoring, and one
+self-committed held-out payload freeze before evaluator source. The hidden
+payload receives generalization evidence but no independent-discovery credit.
+
+## Claim boundary
+
+The maximum positive claim is a reusable exact compiler for the frozen
+rank-one rational AM power--weight fragment. This is pressure on U2 and E, not
+evidence for multivariable AM, V5 analytic closure, transseries, hyperseries,
+surreal arithmetic, symbolic-height iteration, or Arithmetic Universality.
+Mathematical Core, Engineering Architecture, Theory Map, and Public API remain
+unchanged at creation.
+
+## Kill conditions
+
+Publish `STOP` if the result requires answer storage, unrestricted series or
+limit calls, post-reveal grammar/scoring changes, or full expansion traces.
+Publish `ELIMINATE` if it adds no semantic or material software capability
+beyond a certificate wrapper around the baseline. Publish `NARROW` if native
+laws work but completion/transport is not reusable. Publish `EXPAND` only if
+the frozen task family gains replayable semantics or a material measured
+dependency/support/certificate advantage.

sonnet/am-power-weight-compiler/01-results.md

@@ -0,0 +1,147 @@
+# Completed AM power--weight compiler: first results
+
+Status: T1 / `EXPAND` within a strict rank-one rational claim ceiling.
+
+Issue: [#146](https://github.com/mountain/process-geometry/issues/146)  
+Draft implementation: [#147](https://github.com/mountain/process-geometry/pull/147)
+
+## 1. Result
+
+The first executable completed AM carrier now exists as a research-local
+compiler. Its native terms are
+
+\[
+\Phi_{\nu,w}=a^\nu e^{(w-\nu)v},
+\qquad \nu\in\mathbb Z,
+\qquad w\in\mathbb Q,
+\]
+
+with exact product and generator actions
+
+\[
+\Phi_{\nu,w}\Phi_{\mu,z}=\Phi_{\nu+\mu,w+z},
+\qquad
+A\Phi_{\nu,w}=\nu\Phi_{\nu-1,w-1},
+\qquad
+M\Phi_{\nu,w}=w\Phi_{\nu,w}.
+\]
+
+The completion does not construct a full coefficient window. After an
+observer declares one target weight, the compiler recursively requests only
+the dependencies needed for that readout. Exact coefficients live in the
+finite group algebra
+
+\[
+\mathbb Q[\exp(\mathbb Q)],
+\qquad
+\exp(q)\exp(r)=\exp(q+r).
+\]
+
+This is a power--weight/exponential-polynomial carrier. A jet or matrix may be
+an observer product, but neither receives semantic-carrier credit.
+
+## 2. Frozen public gate
+
+All 12 preimplementation cases passed and replayed:
+
+- the product, `A`, `M`, PBW identity, and finite affine relation are exact;
+- `power-weight` and `power-character` encodings canonicalize to the same term;
+- positive-cone `exp` and `log1p` completion produces exact target weights;
+- the `A` resonance produces typed `log-a` with the witness `a>0`;
+- the `M` resonance produces typed `v-jordan`;
+- missing positivity, negative completion input, excessive lattice
+  denominator, excessive target weight, ordinary-only resonance, and symbolic
+  height all fail closed with the frozen taxonomy.
+
+The two public completion probes were:
+
+| Case | Exact readout | Dependency requests | Distinct weights | Exact coefficient operations | Certificate |
+|---|---:|---:|---:|---:|---:|
+| weight-32 log cancellation | `-1/32` | 4 | 2 | 3 | 864 B |
+| nested completed exponential | `exp(2)` | 8 | 2 | 7 | 863 B |
+
+The first case is the clearest observer-directed result: it asks directly for
+weight 32 of a monomial logarithm and the cancelling finite term, rather than
+constructing weights 0 through 32.
+
+## 3. Commit--reveal result
+
+The hidden payload was committed before implementation by
+
+`d578b7ed9f5193cc5b0a0212c3edad025a3b2cee4cf3f90885dd95a412ce5597`.
+
+The evaluator and replay were then remotely frozen at
+
+`a4cd0a7918b4d79ea049852bb829e0feb92d5e2f`.
+
+Only afterwards was the payload revealed:
+
+\[
+[x^0]\,x^{-7}\left(
+\exp\!\left(\log(1+2x)+x^2\right)
+-\left(1+2x+x^2+2x^3+\frac{x^4}{2}+x^5+\frac{x^6}{6}\right)
+\right).
+\]
+
+The compiler returned
+
+\[
+\boxed{\frac13}.
+\]
+
+The commitment verified exactly. The certificate used 29 dependency requests
+over weights 0 through 7, 111 exact coefficient operations, and 888 bytes; a
+fresh semantic replay reproduced the same certificate digest.
+
+This is generalization evidence, not independent-discovery evidence: the
+held-out was a nonce-protected preimplementation self-commit.
+
+## 4. Same-information baseline
+
+The declared SymPy baseline obtained all three exact readouts. It was allowed
+to materialize a truncated coefficient window but received no credit for AM
+carrier semantics, completion-domain witnesses, resonance typing, or replay.
+
+| Case | Baseline window | AM distinct weights | SymPy median | AM median | Interpretation |
+|---|---:|---:|---:|---:|---|
+| weight-32 cancellation | 33 | 2 | 19.76 ms | 0.37 ms | material support advantage |
+| nested exponential | 2 | 2 | 14.46 ms | 0.17 ms | same weight span |
+| held-out weight 7 | 8 | 8 | 13.63 ms | 0.76 ms | same weight span |
+
+Timing is a warm, local microbenchmark and is explicitly non-authoritative.
+It is not a performance theorem. The defensible economy claim is narrower:
+observer-directed extraction avoids a full intervening window on sparse,
+distant readouts such as the weight-32 cancellation probe. The other two
+cases demonstrate exact semantics and replay, not reduced weight support.
+
+## 5. Evaluation
+
+The frozen scoring rule gives `EXPAND`, for two reasons:
+
+1. a reusable completed-AM task family now has executable, replayable
+   semantics rather than only a matrix or polynomial proxy;
+2. one frozen workload demonstrates a material dependency-window advantage.
+
+This does **not** establish a general computational advantage over SymPy, a
+general AM function theory, multivariable completion, or any surreal-number
+runtime claim. In fact, the result sharpens the surreal assessment: no surreal
+object was needed for this bounded rational-rank AM layer. Surreal height may
+become relevant only at a later rank/iteration boundary; importing it here
+would have added ontology without adding capability.
+
+## 6. Next gate
+
+Freeze a separate AM goal front-end and transport corpus. Its job is to map
+existing mathematical vignettes and tests into the validated carrier, for
+example a future textual request of the form
+
+```text
+\goal coefficient weight=7 of exp(log1p(2*x)+x^2)
+```
+
+without changing the now-tested evaluator. The front-end must preserve exact
+source/context digests, reject ambiguous coordinate identifications, and
+compare each transported task with its same-information baseline.
+
+The current implementation consumes the frozen JSON AST; the textual
+`\goal` form above is a next-stage interface proposal, not current syntax.

tests/test_am_weight_compiler_workstream.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+
+
+WORKSTREAM = Path(__file__).resolve().parents[1] / "workstreams" / "am_weight_compiler"
+sys.path.insert(0, str(WORKSTREAM))
+
+from am_weight_compiler.corpus import run_corpus  # noqa: E402
+
+
+def test_am_weight_compiler_public_gate() -> None:
+    result = run_corpus(
+        WORKSTREAM / "PUBLIC_CORPUS.json",
+        WORKSTREAM / "FROZEN_CONTRACT.json",
+    )
+    assert result["passed"] is True
+    assert result["pass_count"] == result["case_count"] == 12

workstreams/am_weight_compiler/BASELINE_CONTRACT.json

@@ -0,0 +1,25 @@
+{
+  "schema": "process-geometry/am-weight-baseline-contract/v0",
+  "engine": "SymPy",
+  "same_information": true,
+  "authority": "non-authoritative",
+  "allowed": [
+    "expand or series in the baseline only",
+    "exact coefficient extraction",
+    "wall-time and expression-support measurement"
+  ],
+  "forbidden_credit": [
+    "semantic carrier",
+    "completion proof",
+    "branch or resonance proof",
+    "replay certificate"
+  ],
+  "comparison": [
+    "exact readout equality",
+    "source support",
+    "visited/dependency weights",
+    "certificate bytes",
+    "coefficient operations",
+    "wall time as non-authoritative"
+  ]
+}

workstreams/am_weight_compiler/FROZEN_CONTRACT.json

@@ -0,0 +1,62 @@
+{
+  "schema": "process-geometry/am-weight-contract/v0",
+  "issue": 146,
+  "claim_mode": "exact-symbolic",
+  "native_frame": {
+    "finite_law": "S_s T_t = T_(exp(s)*t) S_s",
+    "infinitesimal_law": "[A,M]=A",
+    "basis": "Phi_(nu,w)=a^nu*exp((w-nu)*v)",
+    "power_degrees": "integers",
+    "weights": "finitely generated rational rank-one lattice"
+  },
+  "coefficient_domain": {
+    "base": "Q",
+    "readout": "finite Q-linear combinations of formal exp(q), q in Q",
+    "law": "exp(q)*exp(r)=exp(q+r)"
+  },
+  "completion": {
+    "cone": "positive normalized integer weights",
+    "exp": "argument has no negative weight and has a rational constant coefficient",
+    "log1p": "argument has strictly positive weight",
+    "observer": "one exact target weight or finite band",
+    "residual": "all weights above the observer horizon",
+    "semantic_carrier": "completed AM power-weight algebra; generated matrices or jets have no carrier credit"
+  },
+  "resonance": {
+    "A": "nu=-1 forces a positive-real log(a) extension",
+    "M": "w=0 forces a v Jordan extension",
+    "ordinary_only": "fail closed at either resonance"
+  },
+  "grammar": [
+    "native-power-weight",
+    "native-power-character",
+    "finite-weight-series",
+    "add",
+    "multiply",
+    "scale",
+    "weight-shift",
+    "exp-positive",
+    "log-one-plus-positive",
+    "primitive-request",
+    "symbolic-height-negative-control"
+  ],
+  "budgets": {
+    "max_nodes": 1024,
+    "max_lattice_denominator": 24,
+    "max_abs_power": 256,
+    "max_target_weight": 256,
+    "max_coefficient_operations": 100000,
+    "max_certificate_bytes": 65536
+  },
+  "forbidden": [
+    "generic limit call in compiler or replay",
+    "generic unrestricted series call in compiler or replay",
+    "stored expected answer",
+    "stored full expansion trace",
+    "post-reveal grammar or scoring change",
+    "identifying a jet or matrix window as the semantic carrier",
+    "silently identifying the finite-LE N/t chart with native AM coordinates"
+  ],
+  "dispositions": ["EXPAND", "NARROW", "ELIMINATE", "STOP"],
+  "claim_ceiling": "exact observer-directed coefficient semantics for the frozen rank-one rational completed AM power-weight fragment"
+}

workstreams/am_weight_compiler/HELD_OUT_COMMITMENT.json

@@ -0,0 +1,8 @@
+{
+  "schema": "process-geometry/am-weight-heldout-commitment/v0",
+  "scheme": "sha256(canonical-json-with-256-bit-nonce)",
+  "payload_sha256": "d578b7ed9f5193cc5b0a0212c3edad025a3b2cee4cf3f90885dd95a412ce5597",
+  "reveal_rule": "Reveal only after grammar, coefficient domain, completion rules, resonance policy, budgets, evaluator source, replay, and scoring are publicly frozen.",
+  "anti_bruteforce": "The payload includes a random 256-bit nonce.",
+  "independence_boundary": "This is a preimplementation self-commit, not an independent-agent held-out; it receives generalization evidence but no independent-discovery credit."
+}