# Toward a structural proof of KR1
## Support bounds, finite-path preservation, and positive auxiliary models

**Local research article draft, 25 October 2026.** Research direction and compact fiber-splitting motivation: Christopher Yamba. Development: Codex, with separate constructive, formal and critic roles. Novelty and publication suitability are **unverified**. This article does **not** claim a full structural KR1 bijection.

### Abstract

We investigate explicit weight-preserving inverse algorithms between residue partitions for the first Kanade–Russell identity and its difference-condition partitions. The remaining construction is expressed as a map between two concrete intermediate classes, cluster data C and encoded flat columns U. We prove that a weight-preserving injection of an entire fixed cluster sector (a,b) cannot have a uniform cap K on the number of distinct output column values unless K≥a+b. The proof gives an explicit finite obstruction and a quantitative weight-bounded variant. We also prove that any total structural seed bijection can be modified, using only finite alternating paths, to preserve every previously accepted assignment. Both central statements have local Lean certificates, with their exact scopes recorded below. A uniform three-state C↔A endpoint is separately constructed from positive recurrences and exact gap tails. A reversible terminal-gap normalization also provides positive colored cut quotients at every auxiliary level. None of these results supplies the missing full C↔U seed. They identify which compact constructions cannot suffice and remove accepted-image compatibility as a separate constraint on a future seed.

### 1. Which problem remains?

Let B be the ascending integer partitions with parts congruent to 1,3,6 or8 modulo9. Let A be the ascending positive partitions λ such that λᵢ₊₂−λᵢ≥3, and adjacent parts differing by at most one have sum divisible by three. The classical counting target is

\[
\sum_{a,b\ge0}\frac{q^{a^2+3ab+3b^2}}{(q;q)_a(q^3;q^3)_b}
=\frac1{(q,q^3,q^6,q^8;q^9)_\infty}.
\]

Mizuno’s 2026 paper proves the three symmetric identities analytically and cites an accompanying Lean development. We inspected the paper’s theorem and proof architecture and the project’s actual challenge definitions and final theorem assembly. The challenge specifies coefficientwise `HasSum` statements over integer formal power series; the production project supplies their proofs. The public registry reports mechanical verification. We did **not** rebuild that external project locally or audit its entire proof dependency graph. This is attributed existing work, not a result of this investigation. [Mizuno, v3](https://arxiv.org/html/2609.09653v3), [production Lean project](https://github.com/yuma-mizuno/KR-mod9-lean), [registry record](https://palomar-registry.org/entry?id=PALOMAR-2026-09-10-000002&version=1).

Our task remains a structural construction: explicit terminating mutually inverse algorithms, without ranking a weight fiber, hidden enumerated matching, or adding labels to final objects. The intermediate source is

\[
C=(a,b,\mu,\nu),\qquad
\mathrm{wt}(C)=Q(a,b)+|\mu|+3|\nu|,\quad Q=a^2+3ab+3b^2,
\]

where μ and ν are nonnegative ascending vectors of exact lengths a and b. The target U consists of descending positive encoded columns F(h), with

\[
F(h)=9\lfloor h/5\rfloor+(0,1,3,6,8)_{h\bmod5}.
\]

Decoded heights are nonincreasing and **every** drop, including the last positive height to zero, is at most four. The weight is the sum of encoded column values. A column of encoded value9 contains nine actual unit boxes; its decoded height is5. These two numbers are kept separate.

The B↔U endpoint is the attributed weighted Stockhofe construction; the C↔A endpoint comes from cluster/positive-recursion constructions. Andrews and Keith explicitly give the periodic weighting (1,2,3,2,1) and its relation to the KR1 residue product. Their theorem provides this endpoint, not the missing U↔C map. [Andrews–Keith, §5](https://arxiv.org/html/2203.05202v2).

The retained implementation at commit `bd6bfe283f703e9926f7d1a118baafe28ff8d5b6` consists of R, eight component extensions, and the h000 and h002 extensions. Its inherited conditional, separately reviewed ordinary assurance is unchanged. Finite coverage of selected sectors is not global exhaustion. The new generic code and endpoint are separate adapters; accepted output functions were not edited.

An accepted weight24 example, checked in both endpoint directions, is

\[
(3,21)_B\longleftrightarrow(9,9,3,3)_U
\longleftrightarrow(3,1,(1,1,1),(0))_C
\longleftrightarrow(1,2,5,7,9)_A.
\]

The U decoded heights are (5,5,2,2). The C base has pair (1,2), singles (4,6,8), and three additional arm boxes. Each displayed diagram in the companion visual has24 unit boxes. This is an inherited accepted example, not a new proof of all original endpoints.

### 2. A universal support obstruction

Define s(U) as the number of **distinct** encoded column values, irrespective of their multiplicities.

**Theorem 1 (sector support bound).** Fix nonnegative integers a,b,K. If f maps every C in the complete sector (a,b) injectively into valid U, preserves weight, and satisfies s(f(C))≤K for every such C, then K≥a+b.

This permits arbitrary dependence of column values and multiplicities on the whole input. It makes no linearity, locality or bounded-move assumption. It is not a statement that every individual image needs a+b values, nor a lower bound on the spatial dimension of a drawing.

**Proof.** Write the distinct decoded target heights in ascending order h₁<⋯<hᵣ. Put d₁=h₁ and dᵢ=hᵢ−hᵢ₋₁. Validity, including the terminal drop, gives dᵢ∈{1,2,3,4}. For weight≤N each positive multiplicity mᵢ is at most N. Thus a target with r≤K has the unique code

\[
((d_1,m_1),\ldots,(d_r,m_r),0,\ldots,0)
\]

of length K. The alphabet has4N positive tokens and one sentinel. Removing sentinels, summing the dᵢ, applying F and expanding multiplicities reconstructs U. Consequently

\[
\#\{U:\mathrm{wt}(U)\le N,\ s(U)\le K\}\le(4N+1)^K. \tag{1}
\]

This includes empty objects and K=N=0.

Take successive source gaps δᵢ=μᵢ−μᵢ₋₁ and εⱼ=νⱼ−νⱼ₋₁, with initial entries zero. They freely parameterize the entire sector, and

\[
|\mu|=\sum_{i=1}^a(a-i+1)\delta_i,\qquad
|\nu|=\sum_{j=1}^b(b-j+1)\epsilon_j.
\]

Set L=a+b and D=a(a+1)/2+3b(b+1)/2. Gaps in[0,T] give exactly (T+1)^L sources, each of weight at most N=Q+DT. If K<L, choose

\[
A_0=4D+5,\qquad T=\max(1,Q,A_0^K+1).
\]

Then N≤(D+1)T and 4N+1≤A₀T. Since T>A₀^K and L−K≥1,

\[
(4N+1)^K\le A_0^KT^K<T^L\le(T+1)^L.
\]

This contradicts injectivity and(1). ∎

The chosen T,N give an explicit finite falsifier for every proposed cap K<a+b; they are proof bounds, not an enumerative definition of a map. The Lean proof uses the looser coefficient4(a+b)² in place of D, which proves the same sector theorem. The sharper displayed cutoff has a separately reviewed ordinary proof.

A very small example already shows the mechanism. In sector(1,1), C=(1,1,(3),(0)) and C′=(1,1,(0),(1)) both have weight10. A nonempty one-support U must repeat a height in{1,2,3,4}, so its single encoded value is1,3,6 or8. Only1 divides10. The only such target is ten copies of1. Two distinct sources cannot both be assigned there.

**Corollary 2 (weight-bounded tradeoff).** In sector(0,b), choose all binary successive ν gaps. There are2ᵇ sources of weight at most

\[
N_b=3b^2+3b(b+1)/2.
\]

Any weight-preserving injection of these sources with support≤K satisfies2ᵇ≤(4Nᵦ+1)^K. For b≥1 its maximum image support is at least b/log₂(4Nᵦ+1), of order √Nᵦ/log Nᵦ along this family.

This rules out a global construction from a fixed finite collection of image languages with a common support cap. Variable support, growing contours, recursion, two-dimensional box placements and temporary axis reuse remain possible. Christopher Yamba’s geometric intuition is therefore narrowed, not refuted: the final intrinsic readout must accommodate increasing support somewhere.

### 3. Preserving accepted assignments without designing around their markers

**Theorem 3 (finite-path preservation).** Let X,Y have natural weights and finite weight fibers. Let D⊆X be decidable, and M:D→Y an injective weight-preserving accepted map. Suppose its partial inverse J terminates on all Y, returning the unique accepted owner exactly on M(D) and rejecting elsewhere. Suppose G:X↔Y is a **total** structural weight-preserving bijection with terminating inverse. Then the following algorithms give a weight-preserving bijection H:X↔Y, agreeing literally with M on D.

For x∈D return M(x). Otherwise set x₀=x and repeat: compute yᵢ=G(xᵢ); if J(yᵢ) rejects, return yᵢ; otherwise replace xᵢ by J(yᵢ). For inverse input y∈M(D), return J(y). Otherwise compute xᵢ=G⁻¹(yᵢ); if xᵢ∉D, return xᵢ; otherwise replace yᵢ by M(xᵢ).

**Proof.** Every intermediate object retains the starting weight N. On the forward path, x₀ lies outside D and every later source lies inside D. A repeated source at positive positions propagates backwards, using M(xᵢ)=G(xᵢ₋₁) and injectivity of G, until x₀ equals a later accepted source, a contradiction. There are at most|D_N| successful owner steps and|D_N|+1 seed calls. The reverse path has the symmetric argument, using injectivity of M and G⁻¹. Both terminate.

At a forward exit y=G(xₖ), the inverse first recovers xₖ. Its successive M edges undo the previous owner steps and stop at x₀ outside D. A reverse exit gives the other identity by the same argument. On accepted endpoints J(M(d))=d and M(J(y))=y. Accepted outputs lie inside M(D), and every other output lies outside it, so the two branches are disjoint. Both inverse identities, weight preservation and exact coverage follow. ∎

This is standard finite alternating-path/involution-principle reasoning, proved explicitly here; no novelty claim is made. The algorithm uses only the supplied maps and membership tests, with one current object. It does not enumerate a weight fiber, save a visited set or attach a transcript to the final target. Cardinalities appear in the proof of termination.

Finiteness matters. If X=Y=ℕ, all weights are zero, G=id, D={1,2,…} and M(d)=d−1, then J(y)=y+1 and the new path from0 never exits. This example violates the finite-fiber hypothesis and explains why it cannot be omitted.

For KR1, Q≥a+b and every arm entry in a weightN object is≤N. Recording a,b and both arms padded to lengthN gives at most(N+1)^(2N+2) source objects. Hence the required fibers are finite, including the unique empty object atN=0. These codes are only a proof device. Conditional on the inherited exact accepted map and a future full structural seed G:C↔U, Theorem3 preserves every accepted assignment. A partial G or incomplete owner recognizer does not meet its hypotheses.

The practical consequence is precise: a future seed need not reproduce any of the accepted marker languages. Compatibility can be handled afterward by a certified finite-path correction. **The missing seed remains a substantive premise.**

### 4. A uniform endpoint for all cluster parameters

We separately construct C↔A by matching positive three-state source recurrences to actual gap tails. This is the same endpoint scope addressed by the attributed cluster construction; it is not a new U↔C bridge. The recurrences and gap-state aggregation have prior-work provenance. [Xia, §3](https://arxiv.org/html/2609.08816v1), [Chern–Li, §4](https://arxiv.org/html/1809.08655v3).

At level n≥0 and state r∈{0,1,2}, give C charged weight

\[
W_{n,r}=Q+|\mu|+3|\nu|+(3n+r)a+(6n+3[r>0])b.
\]

Let Aₙ,ᵣ be actual gap partitions with smallest part≥3n+r+1. Put x=3n+1,y=3n+2,z=3n+3. A level emits the exact tail of parts≤z and advances to n+1. Allowed tails and next states are

| State | Tails | Next state |
|---|---|---|
|0|empty,x,y,xy,z,xz,zz|0,0,0,0,1,1,2|
|1|empty,y,z,zz|0,0,1,2|
|2|empty,z,zz|0,1,2|

The source guard formulas and all literal inverse arm formulas are in `endpoint-proof-v1.md`; none is selected by enumeration. For example, state2 removes initial ν₁=0 and emits zz if available; otherwise subtracts one from every ν entry, then removes μ₁=0 and emits z if available; otherwise subtracts one from every μ entry and emits the empty tail. The three inverse formulas prepend the removed zero or add back the uniform shifts. State1 first removes μ₁=0 and emits y; otherwise it subtracts one from μ and uses state2. State0 splits on ν₁=0, then the first μ values0,1,2, with the complete disjoint seven-branch table in the proof.

The gap-tail lemma is intrinsic. Three parts inside an interval of length two violate the distance-two condition. The adjacent rule leaves exactly the displayed tails. A tail containing no z permits residual minimum3n+4; one z requires3n+5; two z require3n+6. These minima are also sufficient for every cross-boundary pair and triple. Thus extraction and reinsertion are exhaustive inverses on actual gap partitions.

Every arm branch has the same charged weight as its literal tail plus the destination at level n+1. Its inverse recovers its guard for arbitrary valid destination arms, including empty arms. Global extraction stops at empty C. A nonempty C at level n has charged weight≥3n+1, while residual weight never increases; therefore levels cannot grow forever at fixed total weight. Inverse extraction advances beyond every fixed target part after finitely many levels. Reversing the exact local joins proves both global inverse identities and weight preservation. Public validation terminates and rejects malformed or inadmissible finite inputs.

This gives a universal ordinary proof candidate with independent review recorded at checkpoint. Its initial implementation passed all11,484 source/target objects through weight46,4,977 charged-state cases,22,974 local joins and rejection challenges. It agreed with the old endpoint on those11,484 objects. Those comparisons are empirical; universal equality of the two implementations and a Lean proof of this endpoint are not claimed. The accepted implementation was not replaced.

### 5. Positive auxiliary models at every level

A concrete failure in the product-side construction exposes the next issue. Xia's divided-difference formulas have nonnegative colored cut expansions but also finite numerator factors. Ordinary common-part deletion removes the factors whose part sizes are3 or6 modulo9. At level n=3 a factor1−q⁹ remains: the common partition has no literal9 to delete. The raw cut (0,0,1), with empty residual partition, has weight9, whereas the charged cluster class C(9,18) has no nonempty object of weight≤9. Treating that raw language as the full auxiliary family is therefore refuted. The divided-difference formula and finite prefactors are attributed to [Xia, Lemma2.2 and equations(3.5)–(3.7)](https://arxiv.org/html/2609.08816v1).

The following construction repairs all such factors simultaneously. It gives positive auxiliary objects, while leaving their recursive branch maps open.

**Theorem 4 (terminal-gap quotient).** For n≥1 put m=⌊n/3⌋. Consider weak cuts0≤k₁≤⋯≤kₙ, colored α/β tokens in the closed intervals [0,k₁],[k₁,k₂],…,[kₙ,∞), and a separate common partition. A color-i token at level j has encoded size rᵢ+9j or c−rᵢ+9j; each cut k adds9k to the weight. For the A-family take c=9n,rᵢ=3n−1+3i, forbid color0 α at level0, and allow common parts3,6 modulo9 except literal3t for1≤t≤n. Call this language Xₙ. There is an explicit weight-preserving bijection

\[
X_n\longleftrightarrow F_n\times\mathcal P(9,18,\ldots,9m),
\]

where Fₙ has the intrinsic normal-form condition defined below, and the second factor consists of ordinary partitions into the displayed sizes. Thus the remaining numerator ∏ₛ₌₁ᵐ(1−q⁹ˢ) has a positive quotient model for every n.

**Proof.** Within each segment sort tokens by (level,species), placing α before β at equal level. Insert one mandatory cut anchor after each segment except the last. The resulting event word has M≥n entries and weakly increasing levels j₁,…,j_M. Let εₜ=1 exactly for a within-segment β→α transition and0 elsewhere. Set j₀=0 and hₜ=jₜ−jₜ₋₁−εₜ. These coordinates are nonnegative, and conversely any such coordinates reconstruct exactly the sorted tokens and closed cut intervals for that fixed event word.

For1≤s≤m, raise the levels of the last s events by one. Each changed cut moves by one and each changed token gains nine literal boxes. The total increase is9s. In gap coordinates only h_{M−s+1} increases. These suffix moves commute, preserve validity, and have exact image h_{M−s+1}>0. The inverse lowers that suffix by one on precisely that image.

Extract gₛ=h_{M−s+1} for every s≤m, then set those coordinates to zero, retaining all other gaps, event labels and common parts. This defines Fₙ. The removed weight is9∑ₛs gₛ, represented by gₛ copies of9s. Conversely apply the corresponding suffix moves gₛ times to restore the input. This proves both inverse identities and exhaustive exact recognition. After every color0 token lie all n anchors; since m≤n, none of these operations moves a color0 token. The forbidden literal is therefore preserved. Finite validation, sorting and integer arithmetic terminate on both admitted and rejected inputs. No global weight-fiber enumeration or remembered path is used. ∎

For the earlier weight9 cut, the event levels (0,0,1) normalize to (0,0,0), extracting one9. It is excluded from F₃ by an intrinsic condition, rather than by a coefficient subtraction. Mandatory strict β→α transitions matter: the normal condition is zero terminal **gaps h**, not necessarily equal terminal levels j.

The complete definitions, literal forward/inverse implementation, proof, timestamp correction and frozen hashes are in `uniform-cut-repair-v1.md` and its receipts. Initial checks cover4,623 raw cuts through weight46 at n=1,…,12,1,080 longer parameter samples, both inverse identities, strict descents, commuting suffix moves and malformed-input rejection. These checks are empirical. The universal quotient claim rests on the argument above and its separately recorded review.

The same proof applies to the C-family with n≥0,c=9n+9,rᵢ=3n+4+3i, no color0 exclusion and the same common-part deletions. Denote the normal forms Fᴬₙ,Fᶜₙ; define Fᴬ₀ as the original residue family P₁. The literal tagged union Fᴮₙ=Fᶜₙ ⊔ ((3n+2)+Fᴬₙ₊₁) then provides positive objects for all three auxiliary series. At n=1,2 these retain the older K,L,X models because m=0. Identification with the charged sum-side generating functions uses Xia's analytic result, and is not an object map. The all-family check passed11,464 raw objects and10,536 normal forms through weight46,740 arbitrary samples and1,833 coefficient comparisons. These are finite evidence.

The first missing uniform transfer, with z=3n+3, is

\[
F^C_n\longleftrightarrow F^A_{n+1}\;\sqcup\;(z+F^B_{n+1})\;\sqcup\;(2z+F^C_{n+1}).
\]

A second reversible exchange must identify Fᴬₙ ⊔ ((9n+7)+Fᶜₙ₊₁) with the choice of an empty tail or3n+1, together with Fᴮₙ. Both require literal, recoverable branches. They are sufficient for the three-state recurrence, but neither follows as a set map from the scalar identity. Details are frozen in `cut-family-transfer-obligation-v2.md`.

This positive quotient is an intermediate colored construction. It does not add labels to final KR1 partitions and does not itself identify which recursive branch an auxiliary object belongs to. Equal generating functions cannot choose that branch.

### 6. What Lean verifies

All local certificates use the installed Lean4.34.0 toolchain and standard library, with no installation or external dependency. Successful receipts and source hashes are saved. Printed dependencies are limited to `propext`, `Classical.choice` and `Quot.sound`; no `sorryAx` or custom mathematical axiom occurs in the successful named theorems.

* `KR1Distinct-v1.lean`: `KR1_distinct_column_support_lower_bound` and `KR1_no_global_constant_support` certify the fixed-sector bound and global obstruction for actual columns. Source cube construction and inverse, token/padding injection, exact distinct-support recognition, encoded-column expansion/parsing, terminal validity, weight bounds and dimension contradiction are derived, not assumed.
* `SuffixNormalization-v3.lean`: the terminal-gap coordinate bijection, both inverse identities, exact weight extraction, concrete cumulative-level parser/readout identities and unchanged prefix. The identification with colored cut/anchor syntax and the all-family specialization use the ordinary argument; they are not claimed as additional kernel-checked definitions.
* `CompletionBijection-v3.lean`: the generic accepted-preserving theorem, including two-sided inverse identities, weight, literal agreement on D and exact intrinsic relation. The total seed and its inverse laws are explicit premises. Classical choice in the theorem selects a proved unique terminal endpoint; the separately supplied Python walk specifies the local execution. This is not a Lean certificate of a full KR1 map.
* The sharper triangular cutoff, the binary-family logarithmic phrasing, the uniform endpoint and the preservation algorithm’s Python/Lean implementation correspondence have ordinary arguments and empirical checks as explicitly recorded. Do not promote them to additional kernel-checked statements.

The early syntax/elaboration failures are preserved, including the reserved identifier `universe`, an unavailable core tactic, section-variable omissions, a documentation-placement error, local support proof elaboration and the column-bridge repairs. A malformed checker path was also recorded with a conservative four-second charge. A failed attempt is not counted as a successful proof. The critic’s two transport disconnections are recorded separately from mathematical failures.

### 7. The exact remaining construction

C has a canonical positive word encoding in its successive arm gaps: peel positive μ entries and initial zeros, then do the same for ν. U has a canonical word in height increments d∈{1,2,3,4} and positive multiplicities. Both grammars have literal inverses individually. We have not produced a weight-preserving inverse matching between them.

A crystal/rigged-configuration construction is another possible route, but its extra string lengths, vacancy bounds, multiplicity arrays and energy must be identified with precisely these objects. A shared Lie type is insufficient. Tsuchioka proves a spanning result for gap-indexed vertex-operator monomials; it is not an inspected residue-indexed injection. Choosing pivots in a whole weight space would reintroduce the excluded global enumeration unless a separate structural leading-term rule were proved. [Tsuchioka, Theorem1.3](https://arxiv.org/html/2211.12351v3), [Scrimshaw](https://arxiv.org/html/1505.05910v3).

**One next mathematical obligation:** construct the displayed uniform C-state split on the positive auxiliary normal forms, with explicit branch recognition and inverse moves, including every n=3t−1→3t normalization threshold. This is the next concrete step toward a total C↔U seed; the second exchange must then close the same recurrence. Theorem3 can then restore every accepted assignment. Original endpoints and that concrete completed implementation must receive their own full formal certification before claiming a complete structural KR1 proof.

### Evidence and reproducibility

The local evidence bundle contains frozen contracts, inputs, statements and code; both distinct review rounds; all Lean and finite-check receipts; role-specific time ledgers; engineering checks; baseline/Claude integrity audit; exact assurance labels; and the final local commit receipt. The run starts at2026-10-25T21:23:07Z with a90-minute hard boundary. Mathematical subprocess limits are600 seconds aggregate,60 per check and2GiB sampled RSS. Artifact limit is16MiB. Counts and final measured totals belong to the checkpoint, not to an invented performance claim. No source publication or remote push is implied by this local draft.
