From 3fa1c93c8c66ada108336b99add7db927ea9fa1f Mon Sep 17 00:00:00 2001 From: commdata2338 <199849969+commdata2338@users.noreply.github.com> Date: Thu, 15 Oct 2026 02:12:25 -0500 Subject: [PATCH] Research: P112's nine-term COPY floor holds for every nonzero coefficient Extends PR #2321 from coefficient +1 to every nonzero complex lambda in K_lambda = G - (G e_0 - 4 e_0) e_0^T + lambda e_0 e_1^T at the fixed P112 ports (0,1). For every 0 < q <= 1 the sharp separate nine-term COPY-power minimum stays 7*8^q + 7^q + 1 (COPY sum 64), so changing only this coefficient cannot beat the eight-rank-eight benchmark 8*8^q. An invertible diagonal map carries the complete support catalogue to every nonzero lambda; the dual pairing 2 + 16/lambda vanishes at lambda = -8, where a separate compensation argument keeps the floor and an explicit exceptional attainer is checked. Negative result; no supplier or kappa change. Adds research/p112-coefficient-copy-floor/ only. Submitted by @commdata2338 with substantial AI assistance (OpenAI Codex research and implementation; packaged with Claude Code). Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01X86sCSXdoDd61SDFfC1PKG --- .../CERTIFICATE.json | 1703 +++++++++++++++++ .../p112-coefficient-copy-floor/README.md | 288 +++ .../p112-coefficient-copy-floor/SOURCES.json | 39 + .../p112-coefficient-copy-floor/TASK.json | 148 ++ .../p112-coefficient-copy-floor/VERIFY.json | 33 + .../test_controls.py | 101 + .../p112-coefficient-copy-floor/verify.py | 407 ++++ 7 files changed, 2719 insertions(+) create mode 100644 research/p112-coefficient-copy-floor/CERTIFICATE.json create mode 100644 research/p112-coefficient-copy-floor/README.md create mode 100644 research/p112-coefficient-copy-floor/SOURCES.json create mode 100644 research/p112-coefficient-copy-floor/TASK.json create mode 100644 research/p112-coefficient-copy-floor/VERIFY.json create mode 100644 research/p112-coefficient-copy-floor/test_controls.py create mode 100644 research/p112-coefficient-copy-floor/verify.py diff --git a/research/p112-coefficient-copy-floor/CERTIFICATE.json b/research/p112-coefficient-copy-floor/CERTIFICATE.json new file mode 100644 index 0000000000..f760374f07 --- /dev/null +++ b/research/p112-coefficient-copy-floor/CERTIFICATE.json @@ -0,0 +1,1703 @@ +{ + "case_lower_profiles": { + "left_pure": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 7, + 1 + ], + "nine_mixed": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 7, + 7 + ], + "right_pure_left_V_exceptional": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 7, + 1 + ], + "right_pure_left_V_generic": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 1 + ], + "right_pure_other": [ + 8, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 2 + ] + }, + "controls": [ + "zero_coefficient_outside_support_transport", + "wrong_anchor_in_symbolic_transport", + "left_kernel_in_right_space", + "missing_compensation_basis", + "omitted_pure_factor_breaks_endpoint", + "exact_nonreal_phase_rejects_Hermitian_transpose", + "exceptional_valid_basis_refutes_generic_U_exclusion", + "zero_cost_pair_fails_diagonal_duality" + ], + "exceptional_attainer": { + "M": [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "-1", + "0", + "-1", + "0", + "0", + "1", + "1" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-4" + ] + ], + "N": [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "1/2", + "1/4", + "0", + "1/4", + "0", + "0", + "1/4", + "-1/4" + ] + ], + "mixed_U_index": 1, + "pure_W_index": 8, + "ranks": [ + 8, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 1 + ] + }, + "exceptional_lambda": -8, + "kernel_histograms": { + "L": { + "0": 251, + "1": 256, + "2": 4 + }, + "R1": { + "0": 378, + "1": 129, + "2": 4 + } + }, + "pairing_table": { + "E0": { + "E0": 8, + "E1": 8, + "E2": 8, + "E3": 8, + "E4": 8, + "E5": 8, + "E6": 8, + "E7": 8, + "F": 8, + "U": 8, + "V": 8, + "W": 2 + }, + "E1": { + "E0": 8, + "E1": 8, + "E2": 8, + "E3": 8, + "E4": 8, + "E5": 8, + "E6": 8, + "E7": 8, + "F": 8, + "U": 7, + "V": 7, + "W": 2 + }, + "E2": { + "E0": 8, + "E1": 8, + "E2": 8, + "E3": 8, + "E4": 8, + "E5": 8, + "E6": 8, + "E7": 8, + "F": 8, + "U": 7, + "V": 7, + "W": 2 + }, + "E3": { + "E0": 8, + "E1": 8, + "E2": 8, + "E3": 8, + "E4": 8, + "E5": 8, + "E6": 8, + "E7": 8, + "F": 8, + "U": 8, + "V": 8, + "W": 2 + }, + "E4": { + "E0": 8, + "E1": 8, + "E2": 8, + "E3": 8, + "E4": 8, + "E5": 8, + "E6": 8, + "E7": 8, + "F": 8, + "U": 7, + "V": 7, + "W": 2 + }, + "E5": { + "E0": 8, + "E1": 8, + "E2": 8, + "E3": 8, + "E4": 8, + "E5": 8, + "E6": 8, + "E7": 8, + "F": 8, + "U": 8, + "V": 8, + "W": 2 + }, + "E6": { + "E0": 8, + "E1": 8, + "E2": 8, + "E3": 8, + "E4": 8, + "E5": 8, + "E6": 8, + "E7": 8, + "F": 8, + "U": 8, + "V": 8, + "W": 2 + }, + "E7": { + "E0": 8, + "E1": 8, + "E2": 8, + "E3": 8, + "E4": 8, + "E5": 8, + "E6": 8, + "E7": 8, + "F": 8, + "U": 7, + "V": 7, + "W": 2 + }, + "F": { + "E0": 8, + "E1": 8, + "E2": 8, + "E3": 8, + "E4": 8, + "E5": 8, + "E6": 8, + "E7": 8, + "F": 9, + "U": 8, + "V": 8, + "W": 2 + }, + "V": { + "E0": 8, + "E1": 7, + "E2": 7, + "E3": 8, + "E4": 7, + "E5": 8, + "E6": 8, + "E7": 7, + "F": 8, + "U": 7, + "V": 8, + "W": 1 + }, + "Z": { + "E0": 1, + "E1": 1, + "E2": 1, + "E3": 1, + "E4": 1, + "E5": 1, + "E6": 1, + "E7": 1, + "F": 1, + "U": 1, + "V": 0, + "W": 1 + } + }, + "polynomial_endpoint_entries": 25088, + "schema_version": 1, + "scope": "fixed P112 (0,1), lambda in C*, nine ordinary-transpose terms, separate COPY", + "sharp_power": "7*8^q+7^q+1 for every 08^q`. + +[Hanhong Zhao's PR2321](https://github.com/CrocSwap/integer-mult-bounds/pull/2321), +head `0665be26c2db1bd7f393d829e786698b34b626e4`, established the same optimum +at **λ=1**, including the support classification, duality method and attaining +basis. Those are credited predecessors, not new claims. The new result is the +whole nonzero coefficient family, with an exact support-preserving parameter +map and the previously excluded duality case at **λ=−8**. At that value a +legal basis contains both a left special compensation column and a right +special mixed column. The generic exclusion fails, but the optimum survives. +The certificate includes that exceptional basis explicitly. + +Evidence is author-checked. No independent human review or proof-assistant +verification is claimed. The claim is in +[Discussion #2006](https://github.com/CrocSwap/integer-mult-bounds/discussions/2006#discussioncomment-18942817). + +## Fixed matrix family and scope + +Let `X=root_lines[8:]` in the pinned +[PROTOTYPE.json](../direct-delivery504-global/inputs/hamming/PROTOTYPE.json), +with its original order. It has 112 integer rows of squared norm four. +Put `G=XXᵀ`, `e=e_0`, `f=e_1`, `s=X[0,:]ᵀ`, and `t=X[1,:]ᵀ`. Define + +\[ +K_\lambda=G-(Ge-4e)e^T+\lambda ef^T, +\quad L=[X,e],\quad +R_\lambda=[(I-ee^T)X,4e+\lambda f]. +\] + +Then `K_λ=L R_λᵀ`. Its correction changes 53 rows in columns 0 and 1, +has rank two for `λ≠0`, and vanishes on every constrained binary-pairing-one +entry. In particular the diagonal is unchanged. These completion facts are +from [this account's PR2021](../p112-two-column-completion/README.md); +the checker also verifies the mask and the source geometry directly. + +An allowed factorization is `K_λ=D Tᵀ`, with `D,T` each `112×9` over C. +For term i, let A_i and B_i be its two nonzero supports. Its charge is +`ρ_i=rank_F2(P[A_i,B_i])`, where +`P_ab=(G_ab/2+1) mod 2`. The root labels realize this pairing by ordinary +binary dot product. Complex coefficients themselves are never reduced mod 2. + +The theorem fixes the ports, term count, labels and separate billing. It says +nothing about more terms, another completion, physical sharing between terms, +frame costs, or native execution. The card's positive five-percent supplier +construction gate is not met: this is an explicitly changed algebraic cost +screen. A COPY floor alone is not a complete recursive moment bound, and no +ordinary matrix rank is fed to the packing-ceiling calculator. + +## Proof + +### 1. Transport the entire support catalogue, not just sampled factors + +Let `J_λ=diag(I_8,λ)` in coefficient space, and let `S_λ` scale physical row +0 by `1/λ` while fixing the other 111 rows. Direct inspection gives + +\[ +R_\lambda=S_\lambda R_1J_\lambda. \tag{1} +\] + +Both diagonal maps are invertible for every nonzero complex λ. Consequently +`R_λ n` and `R_1 J_λ n` have identical supports, for **every complex n**. +There is no specialization or generic-parameter assumption. The checker +verifies all coefficients of the denominator-cleared polynomial identity +`λR_λ=diag(1,λ,…,λ) R_1 J_λ`. + +The exact finite certificates below prove that L and R_1 have rank nine, so +(1) gives rank nine for R_λ and K_λ. Thus every nine-term factorization has +`D=LM`, `T=R_λN`, with `M,N∈GL(9,C)` and `MNᵀ=I`. Writing their columns +as `m_i=(a_i,c_i)` and `n_i=(b_i,d_i)` gives + +\[ +m_i^Tn_j=\delta_{ij},\qquad \sum_i a_i b_i^T=I_8. \tag{2} +\] + +Call a term *mixed* when both a_i and b_i are nonzero. At least eight terms +are mixed, by the rank of the last identity in (2). + +For completeness, the PR2321 support catalogue is re-established from the +root input here. For each nonzero binary character h, take the rows of L +or R_1 whose labels have `h·label=1`. The nullspace consists exactly of +coefficients producing support inside `h^⊥`. Each of the 1,022 recorded +kernels has an exact annihilating basis and a nonzero **integer determinant** +minor of complementary rank. This proves equality over C. Modular +elimination is only a way to select the minor; Bareiss integer arithmetic +certifies its determinant. + +Set `z=(0,…,0,1)`, `l=(s,−4)`, `v=(s,0)`, and `u_λ=(t,−4/λ)`. +The source has `sᵀs=4`, `sᵀt=2`, and both s,t have nonzero coordinate set +`{1,2,4,7}`. The complete classes are: + +| Side / class | Coefficient vectors | Binary span of physical support | +| --- | --- | --- | +| Left Z | nonzero multiples of z | line at port 0 | +| Left E_r | `(a e_r,c)`, `a≠0`; arbitrary c if `s_r≠0`, else `c=0` | hyperplane at removed-frame label r | +| Left V | nonzero multiples of l | hyperplane at live port 0 | +| Left F | all remaining nonzero vectors | full dimension 9 | +| Right W | nonzero multiples of z | span of live labels 0 and 1, dimension 2 | +| Right E_r | `(b e_r,d)`, `b≠0`; arbitrary d if `t_r≠0`, else `d=0` | hyperplane at removed-frame label r | +| Right V | nonzero multiples of v | hyperplane at live port 0 | +| Right U | nonzero multiples of u_λ | hyperplane at live port 1 | +| Right F | all remaining nonzero vectors | full dimension 9 | + +The nonzero character kernels at λ=1 have nullity histograms +`L:{0:251,1:256,2:4}` and `R_1:{0:378,1:129,2:4}`. +Distinct nonzero kernels intersect only in zero or the pure z line; this is +also checked exactly. Therefore each non-pure proper support has exactly +one nonzero annihilating character and hence dimension eight. This justifies +the catalogue for every coefficient, including cancellations and nonreal +choices. Equation (1) transports it to all nonzero λ: only the right U line +changes its displayed coefficient vector. + +Bilinearity means that the support-pairing rank depends only on the two binary +spans. The recorded 11-by-12 table of actual support ranks proves: + +1. Every mixed term costs at least seven. Cost seven requires left V or + right V/U. The V/V pair costs eight. +2. The only zero-cost class pair is left Z/right V. +3. Left Z costs one against every right class except V. +4. Right W costs one against left Z or V, and two against left E/F. + +These are the same finite support facts as PR2321; the parameter transfer is +what permits their use for this larger family. + +### 2. The exceptional dual pairing + +The relevant coefficient pairings, under ordinary transpose, are + +\[ +z^Tv=0,\qquad l^Tv=4,\qquad +l^Tu_\lambda=2+16/\lambda,\qquad z^Tu_\lambda=-4/\lambda. \tag{3} +\] + +The unique zero-cost class pair cannot occur at a diagonal factor index, +because its coefficient pairing is zero, contrary to (2). Every term has +positive COPY rank. + +The third pairing in (3) vanishes precisely at **λ=−8**. PR2321's exclusion +of an off-diagonal right U when a left V occurs is therefore unavailable at +this value. We handle it explicitly below. No other pairing used in the +argument acquires a new zero on C\{0}. + +There are nevertheless at most **two cost-seven mixed terms**, uniformly +in λ. Without a left V, only the fixed right V and U lines can provide them, +and an invertible basis uses each line at most once. If a left V occurs at +index i, any right V must also have index i, since `lᵀv=4`. If it does, that +term costs eight and only right U can provide a cost seven elsewhere. If it +does not, only the left V term itself and the one right U term can cost seven. +This argument does not assume `lᵀu_λ≠0`. + +### 3. Complete compensation cases + +If all nine terms are mixed, their sorted ranks dominate seven eights and +two sevens. Otherwise exactly eight are mixed and one term is not: + +- **Left pure Z.** Off-diagonal duality forces `d_j=0` for all other indices. + Right U cannot occur among the mixed terms. Only left V and right V can + supply cost seven; `lᵀv=4` and the V/V cost of eight permit at most one. + The complete profile dominates seven eights, a seven and a one. +- **Right pure W, left V at that same index.** All other left columns have + `c_j=0`, so none is V. Right V cannot occur elsewhere. If `λ≠−8`, neither + can right U: the profile dominates eight eights and a one. If `λ=−8`, + right U is allowed once: the profile still dominates seven eights, a seven + and a one. This is the additional case missing from a verbatim transfer + of the fixed-coefficient proof. +- **Right pure W, left E/F at that index.** The pure-right term costs two, + and among the other eight at most two terms cost seven. The complete + profile dominates six eights, two sevens and a two. + +The left-pure case includes a term that is pure on both sides. These cases +exhaust the possibilities by (2), so no compensation term is omitted. + +Let `P=(8,8,8,8,8,8,8,7,1)`. All these lower profiles dominate P componentwise +when sorted, except `Q=(8,8,8,8,8,8,7,7,2)`. The latter has the same mass 64 +and is majorized by P (all nine integer partial sums are checked). More +directly, its power-sum difference from P is +`7^q+2^q−8^q−1≥0`: concavity makes the increment from 1 to 2 at least the +increment from 7 to 8. Thus every case costs at least `7·8^q+7^q+1` for +`0= 7, 'mixed rank floor') + require(table[a][b] != 7 or a == 'V' or b in ('V', 'U'), 'rank-seven classes') + require(table['V']['V'] == 8, 'V/V costs eight') + require(all(table['Z'][b] == 1 for b in rs if b != 'V'), 'left pure cost') + require(all(table[a]['W'] == (1 if a in ('Z', 'V') else 2) for a in ls), 'right pure cost') + + # N is independent of lambda. Only its pure last physical factor changes. + p = next(i for i, v in enumerate(s) if v) + n = identity(9) + for i in range(9): + n[i][p] = rv[i] + m, d, tout, ranks = witness(x, pairing, n, Q(1)) + require(sorted(ranks) == [1, 7]+[8]*7, 'uniform attainer profile') + r0 = [([0]*8 if i == 0 else row[:])+[4*int(i == 0)] for i, row in enumerate(x)] + r1 = [[0]*8+[int(i == 1)] for i in range(112)] + t0, t1 = product(r0, n), product(r1, n) + require(product(d, transpose(t0)) == endpoint(x, 0), 'constant endpoint coefficient') + require(product(d, transpose(t1)) == [[int(i == 0 and j == 1) for j in range(112)] + for i in range(112)], 'linear endpoint coefficient') + require(all(t1[i][k] == 0 for i in range(112) for k in range(8)), 'fixed mixed attainer supports') + require([t0[i][8] for i in range(112)] == [4]+[0]*111 + and [t1[i][8] for i in range(112)] == [0, 1]+[0]*110, 'uniform pure attainer support') + + # A valid exceptional dual basis refutes the stale generic exclusion. + ep = next(i for i, v in enumerate(t) if v) + en = [[Q(v) for v in row] for row in identity(9)] + for i in range(8): + en[i][ep] = Q(t[i]) + for k in range(8): + en[8][k] = dot(s, [en[i][k] for i in range(8)])/4 + en[8][8] = Q(-1, 4) + em, ed, et, eranks = witness(x, pairing, en, Q(-8)) + require([em[i][8] for i in range(9)] == lv, 'exceptional left V compensation') + require([en[i][ep] for i in range(9)] == t+[Q(1, 2)], 'exceptional right U mixed column') + require(dot(lv, t+[Q(1, 2)]) == 0, 'exceptional orthogonality') + require(sorted(eranks) == [1, 7]+[8]*7, 'exceptional attainer profile') + require(dot(s, t) == 2 and lv[8]*(-4) == 16 and dot(lv, rv) == 4 + and dot(z, rv) == 0, 'symbolic duality coefficients') + profiles = {'nine_mixed': [8]*7+[7, 7], 'left_pure': [8]*7+[7, 1], + 'right_pure_left_V_generic': [8]*8+[1], + 'right_pure_left_V_exceptional': [8]*7+[7, 1], + 'right_pure_other': [8]*6+[7, 7, 2]} + sharp = [8]*7+[7, 1] + for name, profile in profiles.items(): + if name == 'right_pure_other': + require(sum(profile) == sum(sharp) == 64, 'majorization equal mass') + require(all(sum(sorted(profile, reverse=True)[:k]) <= sum(sharp[:k]) + for k in range(1, 10)), 'concave-power majorization') + else: + require(all(a >= b for a, b in zip(sorted(profile), sorted(sharp))), 'case profile dominance') + + controls = [] + rejection(lambda: factor_data(x, 0), 'coefficient must be nonzero') + controls.append('zero_coefficient_outside_support_transport') + rejection(lambda: coefficient_transport(x, 5), 'symbolic coefficient transport') + controls.append('wrong_anchor_in_symbolic_transport') + ids = [i for i, v in enumerate(labels) if (labels[0] & v).bit_count() % 2] + rejection(lambda: kernel_check([right[i] for i in ids], [lv]), + 'kernel vector does not annihilate character rows') + controls.append('left_kernel_in_right_space') + bad = [row[:] for row in n]; bad[8][8] = 0 + rejection(lambda: inverse(bad), 'singular coefficient basis') + controls.append('missing_compensation_basis') + require(dot(d[0][:8], tout[0][:8]) != endpoint(x, 1)[0][0], 'omission control') + controls.append('omitted_pure_factor_breaks_endpoint') + # Multiplying a D column by i and its T column by -i preserves ordinary + # products. Hermitian transpose instead negates that nonzero rank-one term. + column = next(k for k in range(9) if any(row[k] for row in d) and any(row[k] for row in tout)) + oi = next(i for i in range(112) if d[i][column]) + oj = next(i for i in range(112) if tout[i][column]) + require(-2*d[oi][column]*tout[oj][column] != 0, 'ordinary/Hermitian distinction') + controls.append('exact_nonreal_phase_rejects_Hermitian_transpose') + require(dot(lv, t+[-4]) != 0 and dot(lv, t+[Q(1, 2)]) == 0, 'stale generic exclusion control') + controls.append('exceptional_valid_basis_refutes_generic_U_exclusion') + require(dot(z, rv) == 0, 'zero-cost pair cannot be dual') + controls.append('zero_cost_pair_fails_diagonal_duality') + return {'schema_version': 1, 'source_sha256': SOURCE_SHA, + 'scope': 'fixed P112 (0,1), lambda in C*, nine ordinary-transpose terms, separate COPY', + 'sharp_power': '7*8^q+7^q+1 for every 0