docs(p28): the encoder approach -- method, evidence, and honest limits

Documents the compact-form method: re-express opaque exact data in a
structurally-chosen fixed basis and read the coordinates, treating a successful
short exact encoding as a receipt of provenance rather than as compression.

Concrete instance, verified exactly: the challenge's eight large seed integers
decode in the Pascal basis to the Chudnovsky constants A=13591409,
B=545140134, S=426880, which in turn satisfy A = den(s2)-num(s2),
B = 6*den(s2), A/B = (1-s2)/6 for the CM invariant s2 = 77265280/90856689.
Chain: opaque integers -> Pascal coordinates -> Chudnovsky constants -> CM
invariant -> modular origin.

States the limits plainly:
  - NOT a compressor. Measured 3.54x (588 -> 166 bits); unremarkable, and any
    compression claim should be rejected. Consistent with the finding elsewhere
    in this programme that char-poly encoding adds overhead vs an entropy-coded
    baseline.
  - Falsifiable, not numerology: basis fixed in advance, encoding exact with no
    tolerance, and the recovered coordinates were pinned beforehand by an
    unrelated classical formula.
  - Distinctiveness assessed fairly: this is a disciplined exact-arithmetic
    variant of established inverse-symbolic practice (PSLQ, ISC), unusual mainly
    in targeting structured integer arrays and in carrying the encoding into the
    proof. 'Unique' would overclaim.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WY6SfRYvm8zFKMX9GcjS8u

experiments/ramanujan_28/submission/THE_ENCODER_APPROACH.md

@@ -0,0 +1,170 @@
+# The encoder approach
+
+## What it is
+
+Given opaque numerical data — here, the eight large integers the challenge
+supplies as initial conditions — re-express them **exactly** in a fixed,
+structured basis chosen in advance. Then read the coordinates.
+
+If the coordinates turn out to be small, or turn out to be constants with
+independent meaning, that is evidence about where the data came from. The
+encoding is treated as a **receipt of provenance**, not as a compression scheme.
+
+## The concrete instance in this submission
+
+The challenge states Problem 2.8's initial conditions as two rows of large
+integers:
+
+```
+A = (37169305760442252761441, 111507917281327441564208,
+     111507917281327599720129, 37169305760442410917362)
+B = (1167416361542639692320,  3502249084627896132160,
+     3502249084627879697280,  1167416361542622723840)
+```
+
+Nothing about these suggests structure. They are 8 integers of up to 77 bits.
+
+Fix the four rows of the lower-triangular Pascal matrix
+
+```
+b0 = (1,0,0,0)   b1 = (1,1,0,0)   b2 = (1,2,1,0)   b3 = (1,3,3,1)
+```
+
+and the single row
+
+```
+C(x) = (18/x)·b3 + (5/4)·b0 + (23/2)·b1 + 27·b2
+     = (18/x + 159/4,  54/x + 131/2,  54/x + 27,  18/x).
+```
+
+Then, at `x_0 = 1/R`, **exactly**:
+
+```
+A_1 = S·C
+A_0 = A·C − (5/4)·H_0,      H_0 = A·b0 + B·b1 = (A+B, B, 0, 0)
+```
+
+with
+
+```
+A = 13591409,   B = 545140134,   S = 426880.
+```
+
+These are not fitted parameters. They are **the Chudnovsky constants** — the
+same `A`, `B`, `S` appearing in
+
+```
+1/π = (12 / 640320^{3/2}) · Σ_k (6k)!/((3k)!(k!)^3) · (A + Bk) · (−640320^{−3})^k.
+```
+
+Verified exactly in `p28_official_object_certificate.py`.
+
+## What the encoding revealed
+
+The coordinates are not merely small — they are arithmetically meaningful, and
+they continue to factor:
+
+```
+s_2(τ_163) = 77265280 / 90856689          (the weight-zero CM invariant)
+
+A   = 90856689 − 77265280   = den(s_2) − num(s_2)
+B   = 6 · 90856689          = 6 · den(s_2)
+A/B = (1 − s_2)/6
+```
+
+All three verified exactly. So the chain runs
+
+```
+opaque official integers
+  → Pascal-basis coordinates
+  → Chudnovsky constants A, B, S
+  → the CM invariant s_2(τ_163)
+  → the modular origin of the problem
+```
+
+The encoder did not *prove* anything here. It **located** the structure, which
+then told the proof where to go. That is its actual function.
+
+## What it is NOT: an honest accounting
+
+**It is not a compressor.** Measured directly:
+
+| | bits |
+|---|---|
+| raw official seed data (8 integers) | 588 |
+| encoder payload (`A, B, S, R` + 9 small Pascal coordinates) | 166 |
+| ratio | **3.54×** |
+
+3.54× is unremarkable. A general-purpose entropy coder would do comparably on
+data this small, and the Pascal basis had to be known in advance. **Any claim
+that this approach compresses data should be rejected**, including by the
+author. The same conclusion was reached independently elsewhere in this
+programme: characteristic-polynomial encoding of matrices *adds* overhead
+relative to an entropy-coded baseline. It is a receipt, not a compressor.
+
+The value is entirely in *which* basis makes the coordinates meaningful — and
+that is a statement about the data's origin, not about its entropy.
+
+## Why it is falsifiable rather than numerology
+
+The obvious objection is that with enough freedom, any basis can be tuned to
+make any data look structured. Three constraints prevent that here:
+
+1. **The basis is fixed before looking.** Pascal rows are a canonical choice,
+   not searched over.
+2. **The encoding is exact, not approximate.** No tolerance, no fitting; the
+   identities hold in `Fraction` arithmetic and fail if any coefficient is
+   perturbed by one unit.
+3. **The recovered coordinates have independent meaning.** `A`, `B`, `S` were
+   not free parameters to be solved for — they were already known constants from
+   a different context (Chudnovsky's series), and they had to come out *exactly
+   right* or the encoding fails.
+
+Criterion 3 is what separates this from numerology. A coincidence is cheap when
+the target is unconstrained; here the target was pinned in advance by an
+unrelated classical formula.
+
+## How distinctive is this, honestly
+
+The user's sense that this is unusual is **partly right, and worth stating
+precisely rather than overclaiming.**
+
+**Established precedent.** Recovering closed forms from numerical data is a
+mature field: integer-relation algorithms (PSLQ, LLL), the Inverse Symbolic
+Calculator, and experimental-mathematics practice generally. Finding that a
+constant equals a combination of known constants is routine. This work uses PSLQ
+directly elsewhere (e.g. to identify `s_2` across Heegner discriminants).
+
+**What is less standard here:**
+
+- The target is **structured integer data** (seed rows, matrix entries) rather
+  than a single real constant. Integer-relation tools are usually pointed at one
+  number at a time; here an entire row must decode simultaneously in one basis.
+- The encoding is used as a **provenance argument** feeding a proof, not as a
+  discovery heuristic to be discarded once the answer is known. The compact form
+  survives into the manuscript because it is what makes the seed rows tractable.
+- The basis is chosen for **structural** reasons (Pascal ↔ the binomial structure
+  of the transfer matrix's second row `(−u³, −3u², −3u, −1)`), not by search.
+  That second row *is* a signed Pascal row, which is why the Pascal basis was the
+  natural guess and not a lucky one.
+
+**Fair summary:** the technique is a disciplined, exact-arithmetic variant of
+established inverse-symbolic practice, distinguished mainly by being applied to
+structured integer arrays and by being carried into the proof as a provenance
+receipt rather than dropped after discovery. Calling it "unique" would be too
+strong; calling it a recognisable method used unusually systematically is
+defensible.
+
+## The general recipe
+
+1. Take opaque exact data.
+2. Choose a basis for structural reasons, and fix it before looking.
+3. Solve for coordinates in exact arithmetic. No tolerances.
+4. Ask whether the coordinates are small, or known, or both.
+5. If they are known constants from another context, you have found a provenance
+   link — treat it as a lead requiring proof, never as a proof.
+6. Report the compression ratio honestly, and expect it to be unimpressive.
+
+Step 5 is the discipline that keeps this from becoming numerology. In this
+submission the lead was `A/B = (1 − s_2)/6`, which reduced the whole problem to a
+single CM value — and that reduction then had to be proved separately.