From b2ed8132031feed0c0916f418e477ef08963a85a Mon Sep 17 00:00:00 2001 From: allaun Date: Fri, 31 Jul 2026 04:22:13 -0500 Subject: [PATCH] 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 Claude-Session: https://claude.ai/code/session_01WY6SfRYvm8zFKMX9GcjS8u --- .../submission/THE_ENCODER_APPROACH.md | 170 ++++++++++++++++++ 1 file changed, 170 insertions(+) create mode 100644 experiments/ramanujan_28/submission/THE_ENCODER_APPROACH.md diff --git a/experiments/ramanujan_28/submission/THE_ENCODER_APPROACH.md b/experiments/ramanujan_28/submission/THE_ENCODER_APPROACH.md new file mode 100644 index 0000000..90ccd3c --- /dev/null +++ b/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.