From 28fa096cb212eb8355b4afe355a409e8c984c4e6 Mon Sep 17 00:00:00 2001 From: Jose Manuel <118126596+jmbarrancoml@users.noreply.github.com> Date: Sun, 18 Oct 2026 07:05:18 +0200 Subject: [PATCH 1/3] Strengthen odd-unit rank bounds with balanced symplectic flags --- research/odd-unit-triangular-rank/EVIDENCE.md | 39 +++- research/odd-unit-triangular-rank/NOTICE.md | 3 +- research/odd-unit-triangular-rank/PROOF.md | 168 ++++++++++++++-- research/odd-unit-triangular-rank/README.md | 50 +++-- research/odd-unit-triangular-rank/TASK.json | 8 +- research/odd-unit-triangular-rank/VERIFY.json | 18 +- research/odd-unit-triangular-rank/general.py | 4 +- .../odd-unit-triangular-rank/odd_flags.py | 186 ++++++++++++++++++ .../odd_flags_independent.py | 177 +++++++++++++++++ .../odd-unit-triangular-rank/test_controls.py | 43 +++- 10 files changed, 634 insertions(+), 62 deletions(-) create mode 100644 research/odd-unit-triangular-rank/odd_flags.py create mode 100644 research/odd-unit-triangular-rank/odd_flags_independent.py diff --git a/research/odd-unit-triangular-rank/EVIDENCE.md b/research/odd-unit-triangular-rank/EVIDENCE.md index 224cc4e74b..c3c91cf777 100644 --- a/research/odd-unit-triangular-rank/EVIDENCE.md +++ b/research/odd-unit-triangular-rank/EVIDENCE.md @@ -2,12 +2,12 @@ I used CPython 3.12.13 and its standard library. I passed the primary replay under `-I -O -Werror -B`, the independent vector-coordinate replay -under `-I -Werror -B`, and the nine-control replay under optimized Python. +under `-I -Werror -B`, and the fourteen-control replay under optimized Python. I also passed the registered replay and metadata/source-pin validation. I record committed-byte/history and hosted status in the PR. -The primary and independent engines reconstruct 136 and 512 admissible -types, and selectors of 21 and 48 types. They agree on these canonical +The retained baseline engines reconstruct 136 and 512 admissible +types, and hyperplane selectors of 21 and 48 types. They agree on these canonical selector SHA256 values: ```text @@ -28,25 +28,50 @@ Its scalar factor fails the complete fitting condition, as expected. I did not execute the original FLINT search or claim that a single projector completes a unit. -The controls reject zero fitting diagonals, collapsed duplicate ports, +The baseline controls reject zero fitting diagonals, collapsed duplicate ports, invalid multiplicities/types and a broken triangular selector. They also exhibit the missing h5 special orbit, the failure of idempotency after normalizing a nonidentity diagonal, correct removal of a zero-charge term, and rejection of an altered archive by the actual optimized CLI. +For the stronger odd theorem, I checked both flags in dimensions three, +five and seven: 624 selected type occurrences across six flag cases and +2,226 admissible types. I checked 68,216 triangular seed positions and +their transposed reverse-order controls. The ambient Gram-Schmidt engine +and the separate abstract symplectic engine agree on all six digests. +The dimension-five digests are: + +```text +low 0cf9d4433f4388d5d03aa7954b23f547d70fa5c64ea4586377c1a4287c7e5e54 +high 9003b127e3ea12b62271165f4038c65c8b1eab99d084b1998fb85425d9a2bbc3 +``` + +I checked nonuniform populations where either flag improves the balanced +bound, exact high weights 3/7 and 9/31, and the d3 coincident-flag case. +I reject equal weights and a mislabeled flag. An unreversed source/sink +exchange fails the checker's upper-one mask convention; reversing its +order restores that convention. I also distinguish the lifted binary bit +from the wrong integer expression. Singular-core +fixtures establish the exact special-port rank addition over Q/F2/F3/F5/F7, +including repeated special ports and nonidentity diagonal values. A +separate full d3 fitting matrix attains the weighted rank-eight bound. +Both actual optimized baseline and flag CLIs reject changed source bytes. + The arbitrary-multiplicity and field quantifiers follow from PROOF.md. Finite replays do not exhaust those domains. Source-analysis agents checked the proof and its scope separately during this AI-assisted session; I claim no independent human or formal-kernel review. -For the general-dimensional extension, I checked every admissible type, +For the retained general baseline, I checked every admissible type, selector entry and generated orbit for dimensions two through eight: 10,964 types and 451 selected types across those seven fixtures. The uniform fractions are 1/2, 1/3, 1/4, 1/9, 3/32, 11/270 and 1/32. I also checked exact odd-fraction comparisons through dimension 49. These are finite corroboration; the affine-flag and symplectic arguments prove the -general formulas. The original h5/h6 checker implementations remain -separate from this extension checker. +baseline formulas. The stronger odd coefficients are 1/3, 17/105 and +43/651 at d3/d5/d7. Their all-dimension statement follows from the written +flag radical counts and orbit mixture. The old baseline and the new flag +implementations remain separate checks. I ran the card's existing ceiling control separately and obtained `PASS_COMPLEX_LOCAL_WORD_CEILING`. It only orients the selected-word diff --git a/research/odd-unit-triangular-rank/NOTICE.md b/research/odd-unit-triangular-rank/NOTICE.md index 2b4ced352d..45643d168e 100644 --- a/research/odd-unit-triangular-rank/NOTICE.md +++ b/research/odd-unit-triangular-rank/NOTICE.md @@ -28,7 +28,8 @@ I also distinguish DreamingOfClouds/PR2244, at `8ef6fa81403973d3cacaf865bdabe9797a6c34a0`, whose [line-system saturation theorem](https://github.com/CrocSwap/integer-mult-bounds/blob/8ef6fa81403973d3cacaf865bdabe9797a6c34a0/research/line-system-saturation/README.md#L94-L104) permits nonsymmetric scalar decoders under a symmetric alternating support -majorant C and dense mask B=J+C. This package also allows independent odd +majorant C and dense mask B=J+C. I also retain its Lagrangian-averaging +method credit. This package also allows independent odd source and sink labels. The earlier bound may be stronger on its common-label subclass; I claim no priority for general fitting-rank methods. diff --git a/research/odd-unit-triangular-rank/PROOF.md b/research/odd-unit-triangular-rank/PROOF.md index f6ed16234c..123240e4e1 100644 --- a/research/odd-unit-triangular-rank/PROOF.md +++ b/research/odd-unit-triangular-rank/PROOF.md @@ -15,11 +15,12 @@ positive, integral, or has a prescribed factorization. I prove, over every coefficient field K, d=6: rank_K N >= ceil(3v/32), - d=5: rank_K N >= ceil(v/9). + d=5: rank_K N >= ceil(17v/105). These statements require the odd-type representation above. They are not bounds for arbitrary binary matrices of rank five or six. -Section 5 extends the selector argument to every ambient dimension d>=2. +Section 5 gives the general even-dimensional bound and an odd baseline. +Section 6 proves the stronger odd-dimensional theorem using two flags. ## 1. A triangular selector @@ -106,14 +107,15 @@ integer cardinalities as rational numbers, not matrices over K, so the argument also covers fields whose characteristic divides the group order. For d=6 both fractions equal 3/32. Hence rank N>=3v/32. -For d=5, write v_special, v_one, v_diagonal and v_cross for occurrence +For the baseline d=5 selector, write v_special, v_one, v_diagonal and v_cross for occurrence counts, including repetitions. I obtain the stronger inequality rank N >= v_special + (4/15)v_one + (2/15)v_diagonal + (1/9)v_cross. (2) -Every coefficient in (2) is at least 1/9, proving the stated uniform -bound. Taking ceilings is valid because rank is an integer. +Every coefficient in (2) is at least 1/9. This gives a baseline bound; +the two flags in section 6 improve it. Taking ceilings is valid because +rank is an integer. ## 3. Copy terms and linear rank slack @@ -128,14 +130,15 @@ zero. I may remove such terms and form a new fitting N from the remaining terms. The new N still has rank at most their number J. I apply the rank bound to this N; free terms cannot inflate the count needed below. -If every remaining beta_l is five, then in dimension six +If every remaining beta_l is at least five, then in dimension six J >= ceil(3v/32), C >= 5 ceil(3v/32) >= (15/32)v. The ratio 15/32=.46875 exceeds the source's .45 screen by 3/160. This is -a lower bound for the beta-five-only class. Lower-charge mixtures do not -inherit C=5J, and I make no claim that the complete small-unit lane is closed. +a lower bound under the declared additive support-rank tariff. Mixtures +with lower charges need their own invoice; I do not close the complete +small-unit lane. If each X_l has rational rank 16, the total rank satisfies @@ -162,10 +165,11 @@ the nonzero fitting diagonal. ## 4. Paired windows and remaining scope -For a bit twin whose actual window is h_b=rank_Q N, the bounds imply -v<=9h_b in dimension five and 3v<=32h_b in dimension six. In particular, -h_b<=5 permits at most 45 and 53 ports respectively; (2) can tighten the -first restriction. The previous source rows were v<=16h_b and v<=17h_b. +For a bit twin whose actual window is h_b=rank_Q N, section 6 gives +17v<=105h_b in dimension five, while 3v<=32h_b holds in dimension six. +In particular, h_b<=5 permits at most 30 and 53 ports respectively. +The weighted flag maximum can tighten the first restriction. The previous +source rows were v<=16h_b and v<=17h_b. I do not replace the bit twin's copy invoice by the complex invoice. The retained rank-16 projector remains valid as a local example. Its @@ -221,7 +225,7 @@ dimension d-1. Put t=2^(d-2) and n=2t-1. The four-orbit table becomes: I count the one-special entries by taking q=j for each of the t prefix sinks. At d=3 the cross orbit is empty and the other fractions give -rank N>=ceil(v/3). For odd d>=5 the cross fraction is +rank N>=ceil(v/3). For this baseline selector at odd d>=5 the cross fraction is rho_d = ((d-2)t-(d-1)) / (2n(t-2)). @@ -231,8 +235,8 @@ then gives rho_d <= (d-1)/(2n) <= t/(2n) <= 1. Thus d odd, d>=5: rank N >= ceil(rho_d v). (5) -The stronger weighted bound uses the four individual orbit fractions. -Equations (4) and (5) recover the source cases 3/32 and 1/9. They concern +Its weighted bound uses the four individual orbit fractions. +Equations (4) and (5) give 3/32 and the baseline 1/9. They concern the same odd-type fitting model; no new native-cost or supplier conclusion follows from changing the ambient dimension alone. `general.py` checks the finite geometry for d=2,...,8 and the formula's edge cases. The @@ -244,6 +248,134 @@ factorization argument gives J>=ceil(rho v). Constant-charge beta terms therefore cost at least beta*ceil(rho v). Constant-rank R masked totals need aggregate rank at least R*ceil(rho v). A literal identity sum of rank-R idempotents over characteristic zero can exist only if R*rho<=1. -For example, in dimension five the charge-five-only floor is 5/9, and -rank-15 idempotents alone cannot resolve I_v. These are necessary tests -under the fitting model, not constructions or complete supplier prices. +Section 6 strengthens the odd-dimensional coefficient. These remain +necessary tests under the fitting model, not constructions or complete +supplier prices. + +## 6. Stronger odd-dimensional flags + +Let d=2k+1>=3, j=(1,...,1), and H=j-perp. The binary form on H is +nondegenerate and alternating, with dimension 2k. Write q=j+x and w=j+y +for x,y in H. Admissible types satisfy x dot y=0. For port positions s,t, + + B_st = 1 + y_s dot x_t in F2. + +I lift the resulting bit, not the integer expression 1+y_s dot x_t, +into the coefficient field. This distinction matters when the binary +pairing is one. + +Put t=2^(d-2), n=2t-1, and L=(d-3)t+1. There are four type orbits under +symplectic isometries of H and source/sink exchange: the special type +(x,y)=(0,0); 2n one-special types; n other diagonal types; and n(t-2) +cross types. The last orbit is empty at d=3. + +### Exact removal of special ports + +A port with w=j has an isolated nonzero row in N. A port with q=j has +an isolated nonzero column. Let p count all occurrences of such ports, +including repetitions, counting each occurrence once. The row-special +class has w=j and q!=j; the column-special class has q=j and w!=j; +the special class has q=w=j. Order these as row-special, regular, +column-special, and special. The fitting matrix has block form + + [ D_B 0 0 0 ] + [ E M 0 0 ] + [ F G D_A 0 ] + [ 0 0 0 D_S ], + +where the D blocks are invertible diagonal matrices. Row and column +elimination remove E,F,G without changing M. Therefore, over any field, + + rank N = p + rank M. (6) + +Thus these ports contribute one rank each, rather than a fractional +contribution. The regular port counts below are v_D for other diagonal +types and v_C for cross types; v=p+v_D+v_C. + +### Two complete flags + +Choose a symplectic basis e_1,f_1,...,e_k,f_k of H. I use two orders: + + low: e_1,f_1,e_2,f_2,...,e_k,f_k, + high: e_1,...,e_k,f_1,...,f_k. + +For either order, enumerate all y in binary subset order, starting at +zero. At y_i, include every x orthogonal to the span of y_0,...,y_i. +Every selected mask entry from an earlier row to a later column is one, +so this again gives a triangular fitting principal matrix. Each flag +contains every special and one-special type. + +Let P_r be the span of the first r basis vectors. Binary subset order +has 2^(r-1) new sinks in P_r outside P_(r-1). Each allows 2^(2k-r) +labels. The rank-zero block contributes 2^(2k)=2t, and each rank +r=1,...,2k contributes t. Thus each selector has (d+1)t types, of which +4t-1 are special or one-special. Its regular count is L. + +A regular diagonal selection at level r is a vector in +rad(P_r) outside P_(r-1). In low order the radical has one new vector +at each odd r and none at even r, giving k diagonal selections. In high +order the first k prefix spaces are isotropic and contribute +1+2+...+2^(k-1)=2^k-1. Later radicals lie inside the previous prefix, +so they contribute no new diagonal selection. Write + + D_low=k, D_high=2^k-1. + +For d>=5, average each flag over the finite symmetry group. The two +weighted rank bounds are + + R_D = p + (D/n) v_D + ((L-D)/(n(t-2))) v_C, + rank N >= ceil(max(R_low,R_high)). (7) + +Every type occurrence contributes separately. I average integer counts +over the rationals, so no group-order inverse is needed in the +coefficient field. + +### Balanced coefficient and scope + +Put D_star=L/(t-1). For k>=2, + + D_star = 2k-2 + (2k-1)/(t-1), + k < D_star < 2^k-1. + +The lower inequality follows from 2k-2>=k, with a positive remainder. +For the upper one, t>2k holds at k=2 and persists as k increases; it +implies D_star<2k-1<=2^k-1. Hence the high-flag +weight alpha=(D_star-k)/(2^k-1-k) lies strictly between zero and one. +This mixture equalizes the two regular orbit densities at + + rho_d = L/(n(t-1)). + +As an orbit density, rho_d lies in (0,1]. I obtain the conclusions + + rank N >= p + ceil(rho_d (v-p)) >= ceil(rho_d v). (8) + +At d=3 both flags coincide, the cross orbit is empty, and the same +conclusion holds with rho_3=1/3. I do not divide by the vanished mixing +denominator. The exact d=5 and d=7 coefficients are 17/105 and 43/651; +the high-flag weights are 3/7 and 9/31. + +Equation (7) retains more information than (8). In fact + + R_high-R_low = ((2^k-1-k)/n)(v_D-v_C/(t-2)). + +The weighted maximum improves the balanced expression unless +v_C=(t-2)v_D, although integer ceilings can erase that gain. I claim no +optimal fitting matrix or general optimality of the selector method. + +For an actual bit window h_b=rank_Q N, (8) gives + + v <= p + floor((h_b-p)/rho_d). + +At d=5, h_b<=5 permits at most 30 ports. After zero-charge terms are +removed, if every remaining copy charge is at least b, section 3 gives +C>=b ceil(max(R_low,R_high))>=b rho_d v. In particular, the d=5 floor +for charges at least five is 17/21, above the source's .7275 scouting +screen. That comparison does not certify a supplier or its bit-copy bill. + +The rank-slack and literal-idempotent conclusions also use the stronger +rho_d. For constant masked-total rank r, aggregate rank is at least +r ceil(rho_d v). A rank-additive assembly, or a literal identity sum of +rank-r idempotents over characteristic zero, is impossible if r rho_d>1. +The identity qualification from section 3 remains necessary. Lower-charge +mixtures, lower-rank totals, sufficiently non-additive assemblies and +changed fitting masks remain open. diff --git a/research/odd-unit-triangular-rank/README.md b/research/odd-unit-triangular-rank/README.md index ba31731840..fbade6aa45 100644 --- a/research/odd-unit-triangular-rank/README.md +++ b/research/odd-unit-triangular-rank/README.md @@ -5,45 +5,56 @@ search. For any finite port multiset and any fitting scalar matrix N over any field, I obtain h=6: rank N >= ceil(3v/32), - h=5: rank N >= ceil(v/9). + h=5: rank N >= ceil(17v/105). I require both binary labels of each port to have odd norm and pair to one in the standard five- or six-dimensional binary space. I allow repeated types, nonsymmetric N and arbitrary nonzero diagonal entries. [PROOF.md](PROOF.md) states the complete hypotheses and the stronger -four-orbit weighted inequality in dimension five. +maximum of two weighted flag inequalities. For the proposed h=6 orbit-77 completion, I derive two consequences: -- A unit using only charge-five scalar terms has C/v>=15/32=.46875, +- A unit whose nonzero copy charges are at least five has C/v>=15/32=.46875, above the source's .45 screen. - Rank-16 totals need aggregate rank at least 3v/2. In particular, full rank-16 idempotents cannot sum to I_v over characteristic zero, even with independent gauges and arbitrary port multiplicities. I retain the author's individual rank-16 projector. The new obstruction -concerns its completion to a unit. I do not exclude mixed-charge, -lower-rank or sufficiently non-additive constructions. +concerns its completion to a unit. Mixtures containing lower-charge +terms, lower-rank totals and sufficiently non-additive constructions +remain open. ## Evidence and reproduction I construct a 48-type triangular minor in dimension six. It occupies 3/32 of each of the two type orbits, so averaging gives the bound for -arbitrary multiplicities. A 21-type selector gives the dimension-five -bound. One checker uses integer bitsets and a small generator family; -another uses Boolean coordinate tuples, all even transvections and -adjacent coordinate swaps. They share only source authentication. +arbitrary multiplicities. In odd dimensions I balance a hyperbolic-pair +flag and a Lagrangian-first flag. Both include every special port; I also +prove exact rank addition when removing those ports. At h=5 each flag +has 48 types, and their high-flag weight is 3/7. + +One flag checker uses symplectic Gram-Schmidt in the ambient binary +space. The other uses abstract symplectic coordinates and an explicit +ambient isometry. They share only source authentication. I retain the +earlier hyperplane selectors as baseline checks. I also extend the same proof to general ambient dimensions. For even -d>=2 I obtain `rank N>=ceil(d v/2^d)`; section 5 of PROOF.md gives the -odd-dimensional weighted formula, including the d=3 edge case. A bounded -general checker verifies the finite geometry through dimension eight. -The general corollary also gives a charge-five-only floor of 5/9 in -dimension five and excludes an identity sum of rank-15 idempotents there. +d>=2 I obtain `rank N>=ceil(d v/2^d)`. For odd d>=3, put +`t=2^(d-2)`, `n=2t-1`, and `rho=((d-3)t+1)/(n(t-1))`. If p port +occurrences have either label equal to the all-ones vector, I prove + + rank N >= p + ceil(rho (v-p)). + +The weighted maximum of the two flag bounds can be stronger. Section 6 +handles the coincident flags at d=3. The dimension-five copy-cost floor +for charges at least five is 17/21, above the source's .7275 scouting +screen; this comparison does not price a complete supplier. The checkers verify the complete finite selectors and type orbits, nonuniform multiplicities, repeated-port minors over Q/F2/F3/F5, the -retained projector's exact factor identity, and nine failure controls. +retained projector's exact factor identity, and fourteen failure controls. The controls distinguish a local projector from a complete unit and retain the identity hypothesis in the idempotent trace corollary. @@ -54,7 +65,8 @@ python3.12 -B scripts/research_package.py --package research/odd-unit-triangular python3.12 -B scripts/check_research_commit.py --package research/odd-unit-triangular-rank --check-source-history ``` -Direct commands use `verify.py`, `independent.py`, `test_controls.py` and `general.py`. +The six registered commands include `odd_flags.py` and +`odd_flags_independent.py` alongside the baseline and boundary checks. They read immutable source bytes and use exceptions that remain active under optimized Python. The source archive includes its license and requires no unmerged foreign Git objects. I do not execute the @@ -67,12 +79,12 @@ I answer the explicit reopening question in Philippe Van Velzen's The author already used Hadamard and acyclic rank bounds. I use those standard methods with new selectors and multiplicity averaging to strengthen the recorded v<=17h_b and v<=16h_b pair rows. For h_b<=5, -the respective limits become 53 and 45 ports. A fitting unit still +the respective limits become 53 and 30 ports. A fitting unit still needs its actual bit-copy factorization and complete physical costs. I retain Philippe's existing acyclic-minor method and distinguish -DreamingOfClouds/PR2244, which allows nonsymmetric decoders under a -symmetric support majorant. Independent odd source/sink labels here can +DreamingOfClouds/PR2244's Lagrangian averaging, which allows nonsymmetric +decoders under a symmetric support majorant. Independent odd source/sink labels here can give directed masks. [NOTICE.md](NOTICE.md) links those exact comparisons; the earlier bound can be stronger on its restricted mask class. diff --git a/research/odd-unit-triangular-rank/TASK.json b/research/odd-unit-triangular-rank/TASK.json index 20a743b004..13ac872941 100644 --- a/research/odd-unit-triangular-rank/TASK.json +++ b/research/odd-unit-triangular-rank/TASK.json @@ -39,7 +39,7 @@ }, "scope_status": "changed", "actual_scope": "Prove general-dimensional odd-type fitting-rank bounds, with h5/h6 copy-cost, rank-slack and orbit77 identity-assembly consequences for arbitrary finite multiplicities.", - "scope_change_reason": "The live small-unit note explicitly requests an orbit77 assembly test. A triangular selector and symmetry averaging give a scoped obstruction before native construction. The same affine-flag argument extends to general ambient dimensions; this is a theorem extension within the same fitting model, not a new helper inventory or current-word packing refinement.", + "scope_change_reason": "The live small-unit note explicitly requests an orbit77 assembly test. Triangular selectors and symmetry averaging give a scoped obstruction before native construction. The general theorem now uses two symplectic flags in odd dimensions and exact special-port rank elimination. This strengthens the same fitting model and paired-window gate, without changing the selected frontier or starting another helper search.", "bottleneck_link": "A new unit could change both supplier budgets, but its local projectors must complete a fitting identity and satisfy the actual bit-window rank. The new bounds reject the beta-five-only low-cost/rank-additive route and tighten paired-window admissibility.", "selection_seed": "1b4438d3977da328e68b771eb359f443", "selection_note": "Explicit handoff-first override to the orbit77 reopening question; retrieved the named new-helper card after checking current priorities and live overlap.", @@ -47,11 +47,11 @@ "budget_minutes": 60, "stop_rule": "Prove the finite selectors, arbitrary-multiplicity averaging and exact factorization consequences; reject any unsupported scope extension. Stop this assembly route at the lower bound, without launching a larger search or claiming mixed dictionaries are impossible.", "outcome": "negative-result", - "evidence": "Written arbitrary-field/multiplicity and general-dimension proof; separate h5/h6 implementations; finite general geometry through dimension eight; repeated-port rank fixtures; retained projector positive control; nine semantic/source controls. Validation status is recorded in EVIDENCE.md.", + "evidence": "Written arbitrary-field/multiplicity proof and general-dimensional flag theorem; separate ambient and abstract symplectic implementations; both flags at d3/d5/d7; exact special-port rank addition; baseline geometry through dimension eight; retained projector positive control; fourteen semantic/source controls. Validation status is recorded in EVIDENCE.md.", "author": "Jose Manuel (jmbarrancoml)", "ai_assistance": "Substantial OpenAI Codex assistance in proof, implementation, verification, prose and source-analysis agents. No independent human or formal-kernel review claimed.", - "overlap": "Complete cached coverage of 402 open PRs and 2326 Discussion records, plus live relevant threads, fork history and nine newer PR updates through 2026-10-18T04:06:23Z. No exact published duplicate found; arbitrary diffs, unpublished LP drivers and private work were not inspected.", - "expansion_decision": "Stop beta-five-only designs below x=.45 and rank-additive rank16 identity assemblies under the stated odd-type mask. Keep mixed charges, lower-rank totals, sufficiently non-additive assemblies and changed masks open. Require a complete paired invoice before further construction.", + "overlap": "Complete cached coverage of 424 open PRs and 2350 Discussion records, public fork and main source searches, and relevant live updates through 2026-10-18T04:45:00Z. No exact two-flag formula duplicate or competing claim found. Arbitrary diffs, unpublished LP drivers and private work were not inspected.", + "expansion_decision": "Require the stronger odd flag rows and actual paired-window rank before construction. Charges at least five imply C/v>=17/21 at h5 and C/v>=15/32 at h6. Mixtures containing lower charges, lower-rank totals, sufficiently non-additive assemblies and changed masks remain open. A complete paired physical invoice is still required.", "open_questions": [ { "question": "Can a mixed-charge or lower-rank unit satisfy the stronger fitting-rank rows and a favorable complete paired budget?", diff --git a/research/odd-unit-triangular-rank/VERIFY.json b/research/odd-unit-triangular-rank/VERIFY.json index a368368c31..1d53b0e8ac 100644 --- a/research/odd-unit-triangular-rank/VERIFY.json +++ b/research/odd-unit-triangular-rank/VERIFY.json @@ -10,22 +10,32 @@ { "argv": ["{python}", "-I", "-O", "-Werror", "-B", "{package}/verify.py"], "timeout_seconds": 120, - "checks": "Source bytes, both complete selectors and type orbits, all triangular constraints, nonuniform multiplicities, repeated-port minors over Q/F2/F3/F5, paired-window/copy inequalities and retained rank16 projector control." + "checks": "Retained h5/h6 hyperplane baseline, source bytes, complete selectors/orbits, repeated-port minors over Q/F2/F3/F5 and retained rank16 projector control. The stronger odd theorem has separate flag checks." }, { "argv": ["{python}", "-I", "-Werror", "-B", "{package}/independent.py"], "timeout_seconds": 120, - "checks": "Separate Boolean-vector implementation with all even transvections and adjacent swaps; complete orbit incidences, selector digests and nonuniform weighted bounds; no primary geometry imports." + "checks": "Separate Boolean-vector replay of the retained hyperplane baseline; complete orbit incidences, selector digests and nonuniform weighted bounds; no primary geometry imports." }, { "argv": ["{python}", "-I", "-O", "-Werror", "-B", "{package}/test_controls.py"], "timeout_seconds": 120, - "checks": "Nine boundary controls: fitting diagonal, repeated-port collapse, invalid multiplicity/type, broken triangular selector, omitted special orbit, nonidentity trace normalization, zero-charge removal and actual optimized CLI source corruption." + "checks": "Fourteen controls covering the baseline hypotheses, exact flag weights/counts/orientation, binary mask lifting, singular-core special-port elimination, and actual optimized baseline/flag CLI source corruption." }, { "argv": ["{python}", "-I", "-O", "-Werror", "-B", "{package}/general.py", "--max-dimension", "8"], "timeout_seconds": 120, - "checks": "General selector size, diagonal counts, triangular property and full symmetry-orbit formulas for dimensions two through eight; edge cases and exact odd-fraction ordering checks. The all-dimension proof is written." + "checks": "Retained baseline hyperplane selector geometry through dimension eight, including the even theorem and earlier odd control. The stronger odd theorem has separate flag replays." + }, + { + "argv": ["{python}", "-I", "-O", "-Werror", "-B", "{package}/odd_flags.py"], + "timeout_seconds": 120, + "checks": "Both symplectic flags at dimensions three/five/seven, exact type incidences, mixture weights, repeated/nonuniform orbit populations and weighted-maximum controls; current odd coefficients and charge/window consequences." + }, + { + "argv": ["{python}", "-I", "-O", "-Werror", "-B", "{package}/odd_flags_independent.py"], + "timeout_seconds": 120, + "checks": "Separate abstract symplectic-coordinate construction, explicit ambient isometry, complete transvection/swap orbits, six flag digests, exact singular-core peeling over F2/F3/F5/F7 and the d3 rank-eight attainment fixture; no primary geometry imports." } ] } diff --git a/research/odd-unit-triangular-rank/general.py b/research/odd-unit-triangular-rank/general.py index 3e746f0b11..c01178070c 100644 --- a/research/odd-unit-triangular-rank/general.py +++ b/research/odd-unit-triangular-rank/general.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -"""Bounded finite checks of the general-dimensional selector proof.""" +"""Baseline hyperplane selectors; odd_flags.py checks the stronger odd bound.""" import argparse from collections import deque @@ -116,7 +116,7 @@ def run(maximum): "dimension-five charge/rank consequences") need(2*coefficient(2) == 1, "equal-rank obstruction must be strict") return {"status": "PASS_GENERAL_ODD_TYPE_SELECTOR", "dimensions": results, - "scope": "Finite geometry through dimension eight; PROOF.md supplies all-dimension quantifiers."} + "scope": "Baseline hyperplane geometry through dimension eight; odd_flags.py verifies the stronger odd selectors."} if __name__ == "__main__": diff --git a/research/odd-unit-triangular-rank/odd_flags.py b/research/odd-unit-triangular-rank/odd_flags.py new file mode 100644 index 0000000000..2890784aac --- /dev/null +++ b/research/odd-unit-triangular-rank/odd_flags.py @@ -0,0 +1,186 @@ +#!/usr/bin/env python3 +"""Stronger odd-dimensional rank certificates from two symplectic flags.""" + +import argparse +from collections import Counter +from fractions import Fraction as F +from functools import reduce +import hashlib +import json +from operator import xor +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from source import authenticate + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def dot(a, b): + return (a & b).bit_count() % 2 + + +def parameters(d): + need(type(d) is int and d >= 3 and d % 2 == 1, "odd dimension at least three") + k, t = (d - 1)//2, 2**(d - 2) + n, regular = 2*t - 1, (d - 3)*t + 1 + low, high = k, 2**k - 1 + alpha = F(0) if k == 1 else (F(regular, t - 1) - low)/(high - low) + rho = F(regular, n*(t - 1)) + need(k == 1 or 0 < alpha < 1, "valid flag mixture") + return {"k": k, "t": t, "n": n, "regular": regular, + "low": low, "high": high, "alpha": alpha, "rho": rho} + + +def symplectic_pairs(d): + need(d in (3, 5, 7), "bounded odd flag geometry") + work = [1 ^ (1 << i) for i in range(1, d)] + pairs = [] + while work: + e = work[0] + f = next((v for v in work[1:] if dot(e, v)), None) + need(f is not None, "nondegenerate alternating complement") + work = [v ^ (e if dot(v, f) else 0) ^ (f if dot(v, e) else 0) + for v in work if v not in (e, f)] + pairs.append((e, f)) + need(len(pairs) == (d - 1)//2, "symplectic pair count") + for i, (e, f) in enumerate(pairs): + need(not e.bit_count() % 2 and not f.bit_count() % 2 and dot(e, f), + "symplectic pair") + for j, (u, v) in enumerate(pairs): + need(dot(e, u) == dot(f, v) == 0 and dot(e, v) == (i == j), + "symplectic basis Gram matrix") + return tuple(pairs) + + +def universe(d): + need(d in (3, 5, 7), "bounded odd flag geometry") + odd = [v for v in range(2**d) if v.bit_count() % 2] + return tuple((q, w) for q in odd for w in odd if dot(q, w)) + + +def orbit(d, port): + q, w = port + j = 2**d - 1 + if q == w == j: + return "special" + if q == j or w == j: + return "one-special" + return "diagonal" if q == w else "cross" + + +def selector(d, flag): + need(flag in ("low", "high"), "known flag") + pairs = symplectic_pairs(d) + basis = ([x for pair in pairs for x in pair] if flag == "low" else + [e for e, _ in pairs] + [f for _, f in pairs]) + sinks = [reduce(xor, (b for i, b in enumerate(basis) if mask >> i & 1), 0) + for mask in range(2**len(basis))] + h = [x for x in range(2**d) if not x.bit_count() % 2] + need(set(sinks) == set(h), "flag enumerates the complete alternating space") + j, chosen, sizes = 2**d - 1, [], [] + for stop, y in enumerate(sinks): + block = sorted((j ^ x, j ^ y) for x in h if all(not dot(x, z) for z in sinks[:stop + 1])) + chosen.extend(block) + sizes.append(len(block)) + return tuple(chosen), tuple(basis), tuple(sizes) + + +def check_selector(d, flag, chosen): + need(flag in ("low", "high"), "known flag") + need(len(chosen) == len(set(chosen)), "flag repeats a type") + need(set(chosen) <= set(universe(d)), "flag contains an inadmissible type") + need(all(dot(w, q) for i, (_, w) in enumerate(chosen) for q, _ in chosen[i:]), + "flag is not triangular") + p = parameters(d) + counts = Counter(orbit(d, x) for x in chosen) + expected = {"special": 1, "one-special": 2*p["n"], "diagonal": p[flag], + "cross": p["regular"] - p[flag]} + need(all(counts[name] == count for name, count in expected.items()), "wrong flag orbit counts") + need(len(chosen) == (d + 1)*p["t"], "flag size") + return expected + + +def weights(d, flag): + p = parameters(d) + return {"special": F(1), "one-special": F(1), "diagonal": F(p[flag], p["n"]), + "cross": F(0) if d == 3 else F(p["regular"] - p[flag], p["n"]*(p["t"] - 2))} + + +def check_mixture(d, alpha): + p = parameters(d) + need(0 <= alpha <= 1, "convex flag mixture") + low, high = weights(d, "low"), weights(d, "high") + regular_orbits = ("diagonal",) if d == 3 else ("diagonal", "cross") + need(all((1 - alpha)*low[name] + alpha*high[name] == p["rho"] for name in regular_orbits), + "mixture does not balance regular orbits") + + +def weighted_bounds(d, multiplicities): + need(set(multiplicities) <= set(universe(d)), "weighted ports are inadmissible") + need(all(type(x) is int and x >= 0 for x in multiplicities.values()), "nonnegative integer multiplicities") + counts = Counter() + for port, count in multiplicities.items(): + counts[orbit(d, port)] += count + p = parameters(d) + low = sum(weights(d, "low")[name]*count for name, count in counts.items()) + high = sum(weights(d, "high")[name]*count for name, count in counts.items()) + peeled = counts["special"] + counts["one-special"] + balanced = peeled + p["rho"]*(counts["diagonal"] + counts["cross"]) + need(max(low, high) >= balanced, "weighted maximum dominates the balanced row") + return {"low": low, "high": high, "maximum": max(low, high), + "balanced": balanced, "peeled": peeled} + + +def run(archive=None): + authenticate(archive) + reports = [] + for d in (3, 5, 7): + p = parameters(d) + allowed = universe(d) + orbit_sizes = Counter(orbit(d, x) for x in allowed) + expected_sizes = {"special": 1, "one-special": 2*p["n"], "diagonal": p["n"], + "cross": p["n"]*(p["t"] - 2)} + need(all(orbit_sizes[name] == size for name, size in expected_sizes.items()), "odd type orbits") + flags = [] + for flag in ("low", "high"): + chosen, basis, sizes = selector(d, flag) + counts = check_selector(d, flag, chosen) + check_selector(d, flag, tuple((w, q) for q, w in reversed(chosen))) + flags.append({"flag": flag, "types": len(chosen), "counts": counts, + "basis": basis, "blocks": sizes, + "selector_sha256": hashlib.sha256(json.dumps(chosen, separators=(",", ":")).encode()).hexdigest()}) + check_mixture(d, p["alpha"]) + uniform = weighted_bounds(d, {x: 1 for x in allowed}) + need(uniform["low"] == uniform["high"] == (d + 1)*p["t"], "uniform orbit calibration") + irregular = weighted_bounds(d, {x: (7*i + 2) % 5 for i, x in enumerate(allowed)}) + if d > 3: + diagonal_only = weighted_bounds(d, {x: 7 for x in allowed if orbit(d, x) == "diagonal"}) + cross_only = weighted_bounds(d, {x: 7 for x in allowed if orbit(d, x) == "cross"}) + need(diagonal_only["high"] > diagonal_only["balanced"] > diagonal_only["low"], + "high flag improves a diagonal-heavy population") + need(cross_only["low"] > cross_only["balanced"] > cross_only["high"], + "low flag improves a cross-heavy population") + reports.append({"dimension": d, "universe": len(allowed), "flags": flags, + "rho": str(p["rho"]), "high_weight": str(p["alpha"]), + "weighted_fixture": {key: str(value) for key, value in irregular.items()}}) + for d in range(5, 50, 2): + p = parameters(d) + check_mixture(d, p["alpha"]) + need(p["low"] < F(p["regular"], p["t"] - 1) < p["high"], "strict mixing interval") + need(parameters(5)["rho"] == F(17, 105) and parameters(7)["rho"] == F(43, 651), "new source instances") + need(int(5/parameters(5)["rho"]) == 30, "five-dimensional bit-window limit") + need(5*parameters(5)["rho"] == F(17, 21) > F(291, 400), "declared charge-five screen") + return {"status": "PASS_ODD_FLAG_RANK", "certificates": reports, + "scope": "Two finite flags corroborate the arbitrary-field/multiplicity proof; no supplier or kappa claim."} + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--source-archive", type=Path) + args = parser.parse_args() + print(json.dumps(run(args.source_archive), sort_keys=True)) diff --git a/research/odd-unit-triangular-rank/odd_flags_independent.py b/research/odd-unit-triangular-rank/odd_flags_independent.py new file mode 100644 index 0000000000..c1ce78a9f6 --- /dev/null +++ b/research/odd-unit-triangular-rank/odd_flags_independent.py @@ -0,0 +1,177 @@ +#!/usr/bin/env python3 +"""Independent flag replay in abstract symplectic coordinates.""" + +from collections import deque +from fractions import Fraction as F +import hashlib +import itertools +import json +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from source import authenticate + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def add(a, b): + return tuple((x + y) % 2 for x, y in zip(a, b)) + + +def form(a, b): + return sum(a[i]*b[i + 1] + a[i + 1]*b[i] for i in range(0, len(a), 2)) % 2 + + +def number(a): + return sum(x*2**i for i, x in enumerate(a)) + + +def rank_mod(matrix, prime): + rows = [[x % prime for x in row] for row in matrix] + r = 0 + for c in range(len(rows[0])): + pivot = next((i for i in range(r, len(rows)) if rows[i][c]), None) + if pivot is None: + continue + rows[r], rows[pivot] = rows[pivot], rows[r] + inverse = pow(rows[r][c], -1, prime) + rows[r] = [x*inverse % prime for x in rows[r]] + for i in range(r + 1, len(rows)): + coefficient = rows[i][c] + rows[i] = [(x - coefficient*y) % prime for x, y in zip(rows[i], rows[r])] + r += 1 + return r + + +def run_dimension(d): + k, width = (d - 1)//2, d - 1 + vectors = sorted(itertools.product((0, 1), repeat=width), key=number) + zero = (0,)*width + basis = [tuple(int(i == j) for i in range(width)) for j in range(width)] + # Closed-form symplectic basis in j-perp, independent of the primary + # Gram-Schmidt construction. Coordinates are interleaved e_i,f_i. + lift_basis = [] + for i in range(1, k + 1): + lift_basis.extend((2**(2*i) - 1, 2**(2*i - 1) - 1 + 2**(2*i))) + + def lift(x): + value = 2**d - 1 + for bit, image in zip(x, lift_basis): + if bit: + value ^= image + return value + + def ambient_dot(x, y): + return sum(((x >> i) & 1)*((y >> i) & 1) for i in range(d)) % 2 + + require(len({lift(x) for x in vectors}) == 2**width, "injective odd lift") + require(all(ambient_dot(lift(x), lift(y)) == (1 + form(x, y)) % 2 + for x in vectors for y in vectors), "independent mask/lift equation") + universe = {(x, y) for x in vectors for y in vectors if form(x, y) == 0} + maps = [] + for a in vectors[1:]: + mapping = {x: add(x, a) if form(a, x) else x for x in vectors} + require(all(mapping[mapping[x]] == x for x in vectors), "symplectic involution") + require(all(form(mapping[x], mapping[y]) == form(x, y) for x in basis for y in basis), + "symplectic generator") + maps.append(mapping) + unseen, orbits = set(universe), [] + while unseen: + start = min(unseen) + orbit, pending = {start}, deque([start]) + while pending: + x, y = pending.popleft() + for candidate in [(m[x], m[y]) for m in maps] + [(y, x)]: + require(candidate in universe, "independent type orbit") + if candidate not in orbit: + orbit.add(candidate) + pending.append(candidate) + unseen -= orbit + orbits.append(orbit) + t, n, regular = 2**(d - 2), 2**(d - 1) - 1, (d - 3)*2**(d - 2) + 1 + expected_sizes = sorted(x for x in (1, 2*n, n, n*(t - 2)) if x) + require(sorted(map(len, orbits)) == expected_sizes, "independent orbit sizes") + flags, orbit_weights = [], [] + expected_digests = { + (3, "low"): "7c13e839533ba611fd9160c7907ac4bed3e90556c16ede6862ab32543387ff63", + (3, "high"): "7c13e839533ba611fd9160c7907ac4bed3e90556c16ede6862ab32543387ff63", + (5, "low"): "0cf9d4433f4388d5d03aa7954b23f547d70fa5c64ea4586377c1a4287c7e5e54", + (5, "high"): "9003b127e3ea12b62271165f4038c65c8b1eab99d084b1998fb85425d9a2bbc3", + (7, "low"): "c72aa3bd2bf9e37c6489b253bcc95703abdc1a08540b0480d313008f8533f4cc", + (7, "high"): "e9d4b6909890c800b601eabef1a3ffb807388b610d381e5a850b87f7333464e5", + } + for label, ordered in (("low", basis), ("high", basis[::2] + basis[1::2])): + sinks = [] + for coordinates in vectors: + value = zero + for bit, direction in zip(coordinates, ordered): + if bit: + value = add(value, direction) + sinks.append(value) + selected, encoded = [], [] + for stop, y in enumerate(sinks): + xs = sorted((x for x in vectors if all(form(x, z) == 0 for z in sinks[:stop + 1])), key=lift) + selected.extend((x, y) for x in xs) + encoded.extend((lift(x), lift(y)) for x in xs) + require(len(selected) == (d + 1)*t, "independent flag size") + require(all(form(y, x) == 0 for i, (_, y) in enumerate(selected) for x, _ in selected[i:]), + "independent triangular selector") + digest = hashlib.sha256(json.dumps(encoded, separators=(",", ":")).encode()).hexdigest() + require(digest == expected_digests[(d, label)], "independent flag digest") + incidences = sorted((len(o), len(o.intersection(selected))) for o in orbits) + diagonal = k if label == "low" else 2**k - 1 + expected = [(1, 1), (2*n, 2*n), (n, diagonal)] + if t > 2: + expected.append((n*(t - 2), regular - diagonal)) + require(incidences == sorted(expected), "independent flag orbit counts") + orbit_weights.append([F(len(o.intersection(selected)), len(o)) for o in orbits]) + flags.append({"flag": label, "selector_sha256": digest, "incidences": incidences}) + rho = F(regular, n*(t - 1)) + alpha = F(0) if k == 1 else (F(regular, t - 1) - k)/(2**k - 1 - k) + for i, o in enumerate(orbits): + x, y = next(iter(o)) + target = F(1) if x == zero or y == zero else rho + require((1 - alpha)*orbit_weights[0][i] + alpha*orbit_weights[1][i] == target, + "independent rational mixture") + # The core has rank one. Arbitrary permitted cross blocks and repeated + # special types must add exactly six, not merely preserve full rank. + e, f = basis[:2] + ports = [(zero, zero)]*2 + [(e, zero)]*2 + [(zero, f)]*2 + [(e, e), (f, f)] + matrix = [[int(i == j) if form(y, x) == 0 else 1 + (i + j) % 3 + for j, (x, _) in enumerate(ports)] for i, (_, y) in enumerate(ports)] + for i in (6, 7): + for j in (6, 7): + matrix[i][j] = 1 + require(all(i == j or form(y, x) or matrix[i][j] == 0 + for i, (_, y) in enumerate(ports) for j, (x, _) in enumerate(ports)), + "independent peeling fixture fits") + for prime in (2, 3, 5, 7): + require(rank_mod(matrix, prime) == 7, "exact special-port rank addition") + if d == 3: + # All seven special/one-special ports are isolated. The three regular + # diagonal types admit an all-ones rank-one core, attaining rank eight. + full = sorted(universe) + endpoint = [[int(i == j) for j in range(len(full))] for i in range(len(full))] + regular_indices = [i for i, (x, y) in enumerate(full) if x != zero and y != zero] + require(len(regular_indices) == 3, "dimension-three regular core") + for i in regular_indices: + for j in regular_indices: + endpoint[i][j] = 1 + require(all(i == j or form(y, x) or endpoint[i][j] == 0 + for i, (_, y) in enumerate(full) for j, (x, _) in enumerate(full)), + "dimension-three attainment fits") + require(all(rank_mod(endpoint, p) == 8 for p in (2, 3, 5, 7)), + "dimension-three weighted-bound attainment") + return {"dimension": d, "universe": len(universe), "rho": str(rho), + "high_weight": str(alpha), "flags": flags, "peeling_fields": [2, 3, 5, 7]} + + +if __name__ == "__main__": + require(len(sys.argv) == 1, "unknown independent flag arguments") + authenticate() + print(json.dumps({"status": "PASS_INDEPENDENT_ODD_FLAGS", + "certificates": [run_dimension(d) for d in (3, 5, 7)]}, sort_keys=True)) diff --git a/research/odd-unit-triangular-rank/test_controls.py b/research/odd-unit-triangular-rank/test_controls.py index f819c19223..4a067f722d 100644 --- a/research/odd-unit-triangular-rank/test_controls.py +++ b/research/odd-unit-triangular-rank/test_controls.py @@ -10,7 +10,9 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) import model +import odd_flags from source import authenticate +from verify import rank HERE = Path(__file__).resolve().parent @@ -61,19 +63,46 @@ def run(): model.need(all(model.dot(ports[i][1], ports[j][0]) * with_free[i][j] == without_free[i][j] for i in range(2) for j in range(2)), "zero-charge removal changed the endpoint") + # The two valid flags need their exact rational mixture, not equal weights. + rejected(lambda: odd_flags.check_mixture(5, F(1, 2)), "does not balance") + low, _, _ = odd_flags.selector(5, "low") + rejected(lambda: odd_flags.check_selector(5, "high", low), "wrong flag orbit counts") + rejected(lambda: odd_flags.check_selector(5, "low", tuple((w, q) for q, w in low)), + "not triangular") + # Lift the binary bit 1+, not the integer expression 1+. + j = 31 + (e, f), _ = odd_flags.symplectic_pairs(5) + mask_ports = [(j ^ e, j), (j, j ^ f)] + model.check_fitting(5, mask_ports, [[1, 0], [1, 1]]) + model.need(model.dot(e, f) == 1 and model.dot(mask_ports[1][1], mask_ports[0][0]) == 0, + "symplectic-to-binary mask fixture") + model.need(1 + model.dot(e, f) == 2, "integer-lift mutant differs from the binary bit") + # Exact rank addition must work even when the remaining core is singular. + peel_ports = [(j, j)]*2 + [(j ^ e, j)]*2 + [(j, j ^ f)]*2 + [(j ^ e, j ^ e), (j ^ f, j ^ f)] + peel_matrix = [[int(i == h) if model.dot(w, q) else (2*i + 3*h) % 5 - 2 + for h, (q, _) in enumerate(peel_ports)] for i, (_, w) in enumerate(peel_ports)] + for i in (6, 7): + for h in (6, 7): + peel_matrix[i][h] = 1 + for i in range(6): + peel_matrix[i][i] = -1 if i % 2 else 1 + model.check_fitting(5, peel_ports, peel_matrix) + for prime in (None, 2, 3, 5, 7): + model.need(rank(peel_matrix, prime) == 7, "exact peeling rank with a singular core") # Exercise the real optimized CLI's source gate, not just an in-memory predicate. with tempfile.TemporaryDirectory(prefix="odd-unit-controls-") as folder: corrupt = Path(folder) / "source.tar" raw = bytearray((HERE / "inputs/small-unit-source.tar").read_bytes()) raw[len(raw)//2] ^= 1 corrupt.write_bytes(raw) - proc = subprocess.run([sys.executable, "-I", "-O", "-Werror", "-B", - str(HERE / "verify.py"), "--source-archive", str(corrupt)], - capture_output=True, text=True, timeout=30) - model.need(proc.returncode != 0 and "comparison archive SHA256 mismatch" in proc.stderr, - "optimized CLI accepted changed comparison source") - return {"status": "PASS_ODD_UNIT_RANK_CONTROLS", "controls": 9, - "scope": "Mask, multiplicity, selector, exceptional orbit, trace and source boundaries."} + for script in ("verify.py", "odd_flags.py"): + proc = subprocess.run([sys.executable, "-I", "-O", "-Werror", "-B", + str(HERE / script), "--source-archive", str(corrupt)], + capture_output=True, text=True, timeout=30) + model.need(proc.returncode != 0 and "comparison archive SHA256 mismatch" in proc.stderr, + "optimized CLI accepted changed comparison source: " + script) + return {"status": "PASS_ODD_UNIT_RANK_CONTROLS", "controls": 14, + "scope": "Baseline plus flag-mixture, orientation, binary-lift and exact special-port rank boundaries."} if __name__ == "__main__": From 2a6f0c360f6ef779d7be094b16a1ee16812a710a Mon Sep 17 00:00:00 2001 From: Jose Manuel <118126596+jmbarrancoml@users.noreply.github.com> Date: Sun, 18 Oct 2026 07:16:28 +0200 Subject: [PATCH 2/3] Record current-main continuation and mixed-rank count bound --- research/odd-unit-triangular-rank/EVIDENCE.md | 3 +++ research/odd-unit-triangular-rank/PROOF.md | 18 +++++++++++++++--- research/odd-unit-triangular-rank/README.md | 12 ++++++++++-- research/odd-unit-triangular-rank/TASK.json | 9 ++++++++- research/odd-unit-triangular-rank/odd_flags.py | 5 +++++ 5 files changed, 41 insertions(+), 6 deletions(-) diff --git a/research/odd-unit-triangular-rank/EVIDENCE.md b/research/odd-unit-triangular-rank/EVIDENCE.md index c3c91cf777..9ddc0f7caa 100644 --- a/research/odd-unit-triangular-rank/EVIDENCE.md +++ b/research/odd-unit-triangular-rank/EVIDENCE.md @@ -48,6 +48,9 @@ high 9003b127e3ea12b62271165f4038c65c8b1eab99d084b1998fb85425d9a2bbc3 I checked nonuniform populations where either flag improves the balanced bound, exact high weights 3/7 and 9/31, and the d3 coincident-flag case. +For 44 rank-15 terms, I checked the necessary mixed-rank count at +74, 75 and 76 rank-1 terms. The first fails; 75 attains the arithmetic +boundary. I claim no construction attaining that boundary. I reject equal weights and a mislabeled flag. An unreversed source/sink exchange fails the checker's upper-one mask convention; reversing its order restores that convention. I also distinguish the lifted binary bit diff --git a/research/odd-unit-triangular-rank/PROOF.md b/research/odd-unit-triangular-rank/PROOF.md index 123240e4e1..ac1d835c6a 100644 --- a/research/odd-unit-triangular-rank/PROOF.md +++ b/research/odd-unit-triangular-rank/PROOF.md @@ -376,6 +376,18 @@ The rank-slack and literal-idempotent conclusions also use the stronger rho_d. For constant masked-total rank r, aggregate rank is at least r ceil(rho_d v). A rank-additive assembly, or a literal identity sum of rank-r idempotents over characteristic zero, is impossible if r rho_d>1. -The identity qualification from section 3 remains necessary. Lower-charge -mixtures, lower-rank totals, sufficiently non-additive assemblies and -changed fitting masks remain open. +For mixed ranks in a rank-additive unit, I combine J>=rho_d v with +sum_l rank X_l=v to obtain mean masked-total rank v/J<=1/rho_d. +For a literal identity sum of idempotents over characteristic zero, +I obtain the same equality by taking traces, without a commutativity +assumption. At d=5, if J_15 terms have rank 15 and J_1 have rank one, + + 17(15 J_15+J_1) <= 105(J_15+J_1), + 44 J_1 >= 75 J_15. (9) + +I obtain equality in this integer count condition only at +(J_15,J_1)=(44m,75m). I do not construct an attaining assembly or +derive its native copy invoice. I retain the literal identity and +characteristic-zero hypotheses for the trace argument from section 3. +I leave lower-charge mixtures, lower-rank totals, sufficiently +non-additive assemblies and changed fitting masks open. diff --git a/research/odd-unit-triangular-rank/README.md b/research/odd-unit-triangular-rank/README.md index fbade6aa45..fdb269b4ac 100644 --- a/research/odd-unit-triangular-rank/README.md +++ b/research/odd-unit-triangular-rank/README.md @@ -52,6 +52,11 @@ handles the coincident flags at d=3. The dimension-five copy-cost floor for charges at least five is 17/21, above the source's .7275 scouting screen; this comparison does not price a complete supplier. +For a dimension-five literal identity sum of rank-15 and rank-1 +idempotents over characteristic zero, I also derive the necessary count +`44 J_1>=75 J_15`. I use the trace and the bound above; I do not +construct such a mixture or price its native copies. + The checkers verify the complete finite selectors and type orbits, nonuniform multiplicities, repeated-port minors over Q/F2/F3/F5, the retained projector's exact factor identity, and fourteen failure controls. @@ -88,8 +93,11 @@ decoders under a symmetric support majorant. Independent odd source/sink labels give directed masks. [NOTICE.md](NOTICE.md) links those exact comparisons; the earlier bound can be stronger on its restricted mask class. -I started from canonical main -`6f100d4bb5083f8c35d96fd95a539811c62f245c`, priority revision 6. I coordinate +I retain the original scientific pins at +`6f100d4bb5083f8c35d96fd95a539811c62f245c`. I prepared this strengthening +from canonical main `20ecf2891d80b5acf18d980b2164fb44ea7faa90`, priority +revision 6, after archival intake of PR3512. The intake ledger still +marks that predecessor partially reviewed. I coordinate in [Discussion2278](https://github.com/CrocSwap/integer-mult-bounds/discussions/2278#discussioncomment-19010715). I preserve the selected frontier and supply no new integer exponent. I claim no independent human review, formal-kernel proof or complete diff --git a/research/odd-unit-triangular-rank/TASK.json b/research/odd-unit-triangular-rank/TASK.json index 13ac872941..a7ae32fefe 100644 --- a/research/odd-unit-triangular-rank/TASK.json +++ b/research/odd-unit-triangular-rank/TASK.json @@ -3,6 +3,13 @@ "task_id": "complex-new-helper-inventory", "priority_revision": 6, "base_commit": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "continuation": { + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "predecessor_pr": 3512, + "predecessor_head": "f2703dc67c5e4982a21f41724eed1edc30892873", + "predecessor_status": "partially reviewed after archival intake", + "reason": "PR3512 merged during this proof extension. The focused follow-up starts from refreshed main and retains the original scientific source pins." + }, "original_card": { "id": "complex-new-helper-inventory", "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", @@ -50,7 +57,7 @@ "evidence": "Written arbitrary-field/multiplicity proof and general-dimensional flag theorem; separate ambient and abstract symplectic implementations; both flags at d3/d5/d7; exact special-port rank addition; baseline geometry through dimension eight; retained projector positive control; fourteen semantic/source controls. Validation status is recorded in EVIDENCE.md.", "author": "Jose Manuel (jmbarrancoml)", "ai_assistance": "Substantial OpenAI Codex assistance in proof, implementation, verification, prose and source-analysis agents. No independent human or formal-kernel review claimed.", - "overlap": "Complete cached coverage of 424 open PRs and 2350 Discussion records, public fork and main source searches, and relevant live updates through 2026-10-18T04:45:00Z. No exact two-flag formula duplicate or competing claim found. Arbitrary diffs, unpublished LP drivers and private work were not inspected.", + "overlap": "Complete refreshed coverage of 250 open PRs and 2375 Discussion records at 2026-10-18T05:01-05:02Z, plus public fork/main source searches and live PR3512 state. The current-main local search found no exact two-flag formula duplicate. Arbitrary diffs, unpublished LP drivers and private work were not inspected.", "expansion_decision": "Require the stronger odd flag rows and actual paired-window rank before construction. Charges at least five imply C/v>=17/21 at h5 and C/v>=15/32 at h6. Mixtures containing lower charges, lower-rank totals, sufficiently non-additive assemblies and changed masks remain open. A complete paired physical invoice is still required.", "open_questions": [ { diff --git a/research/odd-unit-triangular-rank/odd_flags.py b/research/odd-unit-triangular-rank/odd_flags.py index 2890784aac..07c7328882 100644 --- a/research/odd-unit-triangular-rank/odd_flags.py +++ b/research/odd-unit-triangular-rank/odd_flags.py @@ -175,6 +175,11 @@ def run(archive=None): need(parameters(5)["rho"] == F(17, 105) and parameters(7)["rho"] == F(43, 651), "new source instances") need(int(5/parameters(5)["rho"]) == 30, "five-dimensional bit-window limit") need(5*parameters(5)["rho"] == F(17, 21) > F(291, 400), "declared charge-five screen") + for rank_one, expected in ((74, False), (75, True), (76, True)): + terms = 44 + rank_one + ports = 15*44 + rank_one + need((parameters(5)["rho"]*ports <= terms) == expected, + "mixed-rank count boundary") return {"status": "PASS_ODD_FLAG_RANK", "certificates": reports, "scope": "Two finite flags corroborate the arbitrary-field/multiplicity proof; no supplier or kappa claim."} From 6cfa4333a2e593ea092fe4bda686bb172b5b6d22 Mon Sep 17 00:00:00 2001 From: Jose Manuel <118126596+jmbarrancoml@users.noreply.github.com> Date: Sun, 18 Oct 2026 07:22:38 +0200 Subject: [PATCH 3/3] Prove the triangular-selector limit with an exhaustive sink-order check --- research/odd-unit-triangular-rank/EVIDENCE.md | 8 ++++ research/odd-unit-triangular-rank/PROOF.md | 39 ++++++++++++++++- research/odd-unit-triangular-rank/README.md | 7 ++++ research/odd-unit-triangular-rank/TASK.json | 2 +- research/odd-unit-triangular-rank/VERIFY.json | 2 +- .../odd_flags_independent.py | 42 ++++++++++++++++++- 6 files changed, 96 insertions(+), 4 deletions(-) diff --git a/research/odd-unit-triangular-rank/EVIDENCE.md b/research/odd-unit-triangular-rank/EVIDENCE.md index 9ddc0f7caa..c470103554 100644 --- a/research/odd-unit-triangular-rank/EVIDENCE.md +++ b/research/odd-unit-triangular-rank/EVIDENCE.md @@ -60,6 +60,14 @@ including repeated special ports and nonidentity diagonal values. A separate full d3 fitting matrix attains the weighted rank-eight bound. Both actual optimized baseline and flag CLIs reject changed source bytes. +For the triangular-selector limit, I ran a subset dynamic program over +explicit annihilators, without using the written prefix-rank upper bound. +At dimensions three and five, I checked 8 and 32,768 sink subsets, with +12 and 245,760 transitions, respectively. These states cover all 3! +and 15! orders of the nonzero sinks. I obtained maximum regular selector +sizes 1 and 17 and reconstructed triangular witnesses. I prove the +all-dimensional limit in PROOF.md; I claim no optimal fitting matrix. + The arbitrary-multiplicity and field quantifiers follow from PROOF.md. Finite replays do not exhaust those domains. Source-analysis agents checked the proof and its scope separately during this AI-assisted diff --git a/research/odd-unit-triangular-rank/PROOF.md b/research/odd-unit-triangular-rank/PROOF.md index ac1d835c6a..31e5419f60 100644 --- a/research/odd-unit-triangular-rank/PROOF.md +++ b/research/odd-unit-triangular-rank/PROOF.md @@ -360,7 +360,8 @@ Equation (7) retains more information than (8). In fact The weighted maximum improves the balanced expression unless v_C=(t-2)v_D, although integer ceilings can erase that gain. I claim no -optimal fitting matrix or general optimality of the selector method. +optimal fitting matrix. Below I prove the precise limit of convex +averaging of triangular principal-minor bounds on the regular types. For an actual bit window h_b=rank_Q N, (8) gives @@ -391,3 +392,39 @@ derive its native copy invoice. I retain the literal identity and characteristic-zero hypotheses for the trace argument from section 3. I leave lower-charge mixtures, lower-rank totals, sufficiently non-additive assemblies and changed fitting masks open. + +### Optimal uniform coefficient from triangular selectors + +Take one occurrence of each regular type (x,y), with x,y nonzero and +x dot y=0, in H of dimension m=2k. Consider any ordered triangular +selector, including selectors outside the two flag families. Order its +distinct sinks y_i by first occurrence and let r_i be their prefix rank. +Every selected source at sink y_i is orthogonal to y_1,...,y_i: its +position follows their first occurrences, and its own type is admissible. +There are at most f(r_i)=2^(m-r_i)-1 such nonzero sources. Distinct types +with this sink have distinct sources, so the selector has size at most +sum_i f(r_i). + +Let A_r count the distinct sinks whose prefix rank is at most r. They +lie in a subspace of dimension at most r, so A_r<=2^r-1. Since f(m)=0, +I sum by parts to obtain + + sum_i f(r_i) + = sum_(r=1)^(m-1) A_r (f(r)-f(r+1)) + <= sum_(r=1)^(m-1) (2^r-1) 2^(m-r-1) + = (m-2) 2^(m-1)+1 = L. (10) + +Either complete flag attains L regular types. Thus I obtain the exact +maximum over triangular selectors for this uniform, distinct-type +population. I use that population as a test of any proposed universal +linear coefficient from convex averages of these minor-size bounds. +It has n(t-1) regular types, while each minor and each convex average +has value at most L. No such average gives a coefficient greater than +rho_d=L/(n(t-1)); the balanced flags attain rho_d for arbitrary +multiplicities. Repeated occurrences do not invalidate this limitation, +because the distinct-type population is one allowed multiset. + +I restrict this optimality claim to convex averages of triangular +principal-minor size bounds. I leave stronger fitting-rank inequalities, +nontriangular minors and more general combinations of rank information +open. I do not infer that a fitting matrix of rank L exists at d>=5. diff --git a/research/odd-unit-triangular-rank/README.md b/research/odd-unit-triangular-rank/README.md index fdb269b4ac..e8afb54b11 100644 --- a/research/odd-unit-triangular-rank/README.md +++ b/research/odd-unit-triangular-rank/README.md @@ -57,6 +57,13 @@ idempotents over characteristic zero, I also derive the necessary count `44 J_1>=75 J_15`. I use the trace and the bound above; I do not construct such a mixture or price its native copies. +I also prove that no convex average of triangular principal-minor size +bounds can improve the uniform regular-type coefficient rho. I bound +the size of an arbitrary triangular selector by its successive sink +spans; either flag attains that limit. I leave the optimal fitting rank +open. A subset dynamic program checks all sink orders at dimensions +three and five, including orders outside the flag families. + The checkers verify the complete finite selectors and type orbits, nonuniform multiplicities, repeated-port minors over Q/F2/F3/F5, the retained projector's exact factor identity, and fourteen failure controls. diff --git a/research/odd-unit-triangular-rank/TASK.json b/research/odd-unit-triangular-rank/TASK.json index a7ae32fefe..9ab8ef2905 100644 --- a/research/odd-unit-triangular-rank/TASK.json +++ b/research/odd-unit-triangular-rank/TASK.json @@ -54,7 +54,7 @@ "budget_minutes": 60, "stop_rule": "Prove the finite selectors, arbitrary-multiplicity averaging and exact factorization consequences; reject any unsupported scope extension. Stop this assembly route at the lower bound, without launching a larger search or claiming mixed dictionaries are impossible.", "outcome": "negative-result", - "evidence": "Written arbitrary-field/multiplicity proof and general-dimensional flag theorem; separate ambient and abstract symplectic implementations; both flags at d3/d5/d7; exact special-port rank addition; baseline geometry through dimension eight; retained projector positive control; fourteen semantic/source controls. Validation status is recorded in EVIDENCE.md.", + "evidence": "Written arbitrary-field/multiplicity proof, general-dimensional flag theorem and exact uniform-coefficient limit for convex averages of triangular-minor size bounds; separate ambient and abstract symplectic implementations; both flags at d3/d5/d7; all-sink-order subset DP at d3/d5; exact special-port rank addition; baseline geometry through dimension eight; retained projector positive control; fourteen semantic/source controls. Validation status is recorded in EVIDENCE.md.", "author": "Jose Manuel (jmbarrancoml)", "ai_assistance": "Substantial OpenAI Codex assistance in proof, implementation, verification, prose and source-analysis agents. No independent human or formal-kernel review claimed.", "overlap": "Complete refreshed coverage of 250 open PRs and 2375 Discussion records at 2026-10-18T05:01-05:02Z, plus public fork/main source searches and live PR3512 state. The current-main local search found no exact two-flag formula duplicate. Arbitrary diffs, unpublished LP drivers and private work were not inspected.", diff --git a/research/odd-unit-triangular-rank/VERIFY.json b/research/odd-unit-triangular-rank/VERIFY.json index 1d53b0e8ac..dcf1010e9a 100644 --- a/research/odd-unit-triangular-rank/VERIFY.json +++ b/research/odd-unit-triangular-rank/VERIFY.json @@ -35,7 +35,7 @@ { "argv": ["{python}", "-I", "-O", "-Werror", "-B", "{package}/odd_flags_independent.py"], "timeout_seconds": 120, - "checks": "Separate abstract symplectic-coordinate construction, explicit ambient isometry, complete transvection/swap orbits, six flag digests, exact singular-core peeling over F2/F3/F5/F7 and the d3 rank-eight attainment fixture; no primary geometry imports." + "checks": "Separate abstract symplectic-coordinate construction, explicit ambient isometry, complete transvection/swap orbits, six flag digests, exact singular-core peeling over F2/F3/F5/F7, the d3 rank-eight attainment fixture and a subset DP over all sink orders at d3/d5; no primary geometry imports." } ] } diff --git a/research/odd-unit-triangular-rank/odd_flags_independent.py b/research/odd-unit-triangular-rank/odd_flags_independent.py index c1ce78a9f6..3d351079a6 100644 --- a/research/odd-unit-triangular-rank/odd_flags_independent.py +++ b/research/odd-unit-triangular-rank/odd_flags_independent.py @@ -47,6 +47,45 @@ def rank_mod(matrix, prime): return r +def all_sink_orders(width, expected): + """Optimize over sink orders by subset DP using explicit annihilators.""" + require(width in (2, 4), "bounded sink-order dynamic program") + vectors = list(itertools.product((0, 1), repeat=width))[1:] + n = len(vectors) + single = [sum(1 << i for i, x in enumerate(vectors) if form(x, y) == 0) + for y in vectors] + annihilators = [0]*(1 << n) + annihilators[0] = (1 << n) - 1 + optimum, previous = [0]*(1 << n), [0]*(1 << n) + transitions = 0 + for subset in range(1, 1 << n): + first = subset & -subset + annihilators[subset] = annihilators[subset ^ first] & single[first.bit_length() - 1] + remaining, best = subset, -1 + while remaining: + bit = remaining & -remaining + score = optimum[subset ^ bit] + if score > best: + best, previous[subset] = score, bit + remaining ^= bit + transitions += 1 + optimum[subset] = best + annihilators[subset].bit_count() + require(optimum[-1] == expected, "optimal regular selector over all sink orders") + subset, order = (1 << n) - 1, [] + while subset: + bit = previous[subset] + order.append(vectors[bit.bit_length() - 1]) + subset ^= bit + order.reverse() + witness = [(x, y) for stop, y in enumerate(order) for x in vectors + if all(form(x, z) == 0 for z in order[:stop + 1])] + require(len(witness) == len(set(witness)) == expected, "sink-order optimum witness") + require(all(form(y, x) == 0 for i, (_, y) in enumerate(witness) for x, _ in witness[i:]), + "sink-order witness is triangular") + return {"dimension": width + 1, "sink_subsets": 1 << n, + "transitions": transitions, "regular_selector_maximum": expected} + + def run_dimension(d): k, width = (d - 1)//2, d - 1 vectors = sorted(itertools.product((0, 1), repeat=width), key=number) @@ -174,4 +213,5 @@ def ambient_dot(x, y): require(len(sys.argv) == 1, "unknown independent flag arguments") authenticate() print(json.dumps({"status": "PASS_INDEPENDENT_ODD_FLAGS", - "certificates": [run_dimension(d) for d in (3, 5, 7)]}, sort_keys=True)) + "certificates": [run_dimension(d) for d in (3, 5, 7)], + "all_sink_orders": [all_sink_orders(2, 1), all_sink_orders(4, 17)]}, sort_keys=True))