From b61b33794c53316a8e8d1fdb9efcc6ee651ac515 Mon Sep 17 00:00:00 2001 From: SHIN09-git Date: Wed, 4 Nov 2026 13:07:36 +0800 Subject: [PATCH 1/3] Pin common-image full-guard sources and predecessor notices --- .../common-image-guard-pencils/.gitattributes | 2 + .../source/4807-PROOF.md | 139 ++++++++++++ .../source/6701-NOTICE | 25 +++ .../source/6701-PROOF.md | 179 ++++++++++++++++ .../source/6701-TASK.json | 111 ++++++++++ .../source/6703-NOTICE | 19 ++ .../source/6703-PROOF.md | 112 ++++++++++ .../common-image-guard-pencils/source/LICENSE | 201 ++++++++++++++++++ 8 files changed, 788 insertions(+) create mode 100644 research/common-image-guard-pencils/.gitattributes create mode 100644 research/common-image-guard-pencils/source/4807-PROOF.md create mode 100644 research/common-image-guard-pencils/source/6701-NOTICE create mode 100644 research/common-image-guard-pencils/source/6701-PROOF.md create mode 100644 research/common-image-guard-pencils/source/6701-TASK.json create mode 100644 research/common-image-guard-pencils/source/6703-NOTICE create mode 100644 research/common-image-guard-pencils/source/6703-PROOF.md create mode 100644 research/common-image-guard-pencils/source/LICENSE diff --git a/research/common-image-guard-pencils/.gitattributes b/research/common-image-guard-pencils/.gitattributes new file mode 100644 index 0000000000..20cd7d6852 --- /dev/null +++ b/research/common-image-guard-pencils/.gitattributes @@ -0,0 +1,2 @@ +* text eol=lf +source/** -text diff --git a/research/common-image-guard-pencils/source/4807-PROOF.md b/research/common-image-guard-pencils/source/4807-PROOF.md new file mode 100644 index 0000000000..8c0baf7570 --- /dev/null +++ b/research/common-image-guard-pencils/source/4807-PROOF.md @@ -0,0 +1,139 @@ +# A common-covector pair has a different dependence law + +This contribution was produced by Nick Petalas. Apache-2.0. + +## Statement + +Let K=F_q be any finite field, m>=2, and let a,c be independent columns +in K^m. Let b be a row with ba=bc=1. Put U=ab, V=cb, P=I-U, Q=I-V. +Thus U,V are distinct rank-one idempotents with UV=U and VU=V. Both +products are nonzero. Their complementary projectors P,Q have a common +image ker(b). This is outside the orthogonal and one-way coupling hypotheses. + +For a complete header G chosen uniformly from GL_m(K), let E_P mean that +every leading principal minor of GPG^-1 of orders 1 through m-1 is +nonzero. Define E_Q in the same way. Write n=m-1 and + +```text +alpha = q^2-q+1, +delta = q^2+(q-1)^3. +``` + +Then the exact joint passing probability is + +```text + (q-1)(delta^n-alpha^n) +J(q,m) = ----------------------------------------- . (1) + (q^m-1)(q^m-q) q^(m-2) +``` + +In particular, over F_2 the events are strictly positively correlated for +every m>=2. At m=2 the joint probability is 1/3 and each marginal is 1/2. +This refutes extension of the known negative-correlation statements to +arbitrary two-way coupled rank-one kernels. It does not contradict their +stated hypotheses. + +Claim type: scoped counting proof with finite corroboration. + +## Header orbit and the guard + +Conjugation takes the triple to (Ga,Gc,bG^-1). GL_m(K) acts transitively +on all triples (a,c,b) satisfying independence and ba=bc=1. To see this, +take a,c-a as the first two basis vectors. The second lies in ker(b). +Extend it to a basis of ker(b), and b has coordinates (1,0,...,0). +The same construction for any other triple gives the required change of +basis. Every triple therefore has the same number of complete-header +preimages, by the stabilizer coset bijection. + +There are (q^m-1)(q^m-q) ordered independent pairs a,c. For each pair, +the two independent linear equations ba=bc=1 have q^(m-2) solutions b. +Consequently the denominator in (1) is the number of triples in this orbit. + +The rank-one determinant identity gives + +```text +det(P[1:k,1:k]) = 1 - sum_(i=1)^k b_i a_i, +det(Q[1:k,1:k]) = 1 - sum_(i=1)^k b_i c_i. +``` + +This is the marginal guard identity of Nick Petalas #4227. We use its +partial-sum method, also used in #4261, and count the new common-covector +orbit directly. For every proper prefix, both partial sums must avoid 1; +at the final coordinate both sums equal 1. + +## Count first, subtract dependent pairs + +Temporarily allow all a,c, retaining ba=bc=1. At one coordinate the +increment is (b_i a_i,b_i c_i). A zero increment has q^2+q-1 preimages: +q^2 choices with b_i=0, and q-1 with b_i nonzero and a_i=c_i=0. +Every nonzero increment has q-1 preimages, one for each nonzero b_i. +Thus the increment weight is q^2 times the zero indicator plus the +constant q-1 on K^2. + +The safe state set S=(K minus {1})^2 has N=(q-1)^2 elements. Its weighted +transition matrix is q^2 I+(q-1)11^T. Every row sum is +q^2+(q-1)N=delta. Start at (0,0) in S. After n safe transitions the +total path weight is delta^n. The terminal state (1,1) is outside S, +so the last increment is nonzero from every safe state and has weight +q-1. The number of all passing triples before enforcing independence is +(q-1)delta^n. + +If a,c are dependent, the endpoint conditions force c=a. Indeed a is +nonzero, write c=t a, and 1=bc=t ba=t. Conversely every diagonal pair +c=a with ba=1 is a dependent triple. There are no other dependent cases. + +For these diagonal triples the scalar increment b_i a_i has 2q-1 +preimages at zero and q-1 at every nonzero element. On K minus {1}, +the safe transition matrix is q I+(q-1)11^T, with row sum +q+(q-1)^2=alpha. The last step again has weight q-1. Therefore exactly +(q-1)alpha^n of the passing triples have dependent columns. Subtracting +them gives the numerator of (1). Dividing by the independent-triple orbit +count proves (1), in every characteristic and every finite field. + +## Binary positive correlation in every dimension + +The cited single-request law #4227 gives + +```text +p(q,m) = (q-1)alpha^n / ((q^m-1)q^(m-1)). +``` + +At q=2, alpha=3 and delta=5, and direct cancellation yields + +```text +J(2,m) / p(2,m)^2 + = [2^(n+1)(2^(n+1)-1)/(2^(n+1)-2)] (5^n-3^n)/9^n. (2) +``` + +Since 5>9/2, replacing 5^n by (9/2)^n strictly decreases (2). The +resulting lower bound is + +```text +2(2^(n+1)-1)/(2^(n+1)-2) * (1-(2/3)^n). +``` + +This is at least 1 exactly when 3^n>=2^(n+1)-1. The latter inequality +holds for every n>=1. It is equality at n=1; if it holds at n then +3^(n+1)>=3*2^(n+1)-3>=2^(n+2)-1, since 2^(n+1)>=2. +The replacement of 5^n was strict even at n=1, so J(2,m)>p(2,m)^2 +for every m>=2. This is a written dimension-uniform proof, rather than +an inference from a finite census. + +## Credit and limits + +The two-way-coupling question is Open next question 1 of Nick Petalas +[#4778](https://github.com/CrocSwap/integer-mult-bounds/pull/4778), following +#4769/#4274's one-way law. The marginal identity and probability are from +#4227; #4261 supplies the predecessor partial-sum/header counting method. +The common-covector orbit, its dependent-pair subtraction, formula (1), +and the binary positive-correlation proof are the new contribution here. +Cinna Davis supplied the BIT request context. source527, commdata2338 and +Jose Manuel retain the normalizer and recursive-closure lineage credit. + +Only this common-covector pair and complete uniformly weighted headers are +covered. The proof does not classify arbitrary two-way pairs, larger +families, restricted header catalogues, or odd-field correlation signs. +Selection, emission, dispatch, dirty restoration, stock, precision and the +physical caller bill remain unknown. No supplier admission, new kappa, +selected-frontier change or complete multiplication theorem follows. +Independent human and formal proof-kernel review are unclaimed. diff --git a/research/common-image-guard-pencils/source/6701-NOTICE b/research/common-image-guard-pencils/source/6701-NOTICE new file mode 100644 index 0000000000..210b6e6762 --- /dev/null +++ b/research/common-image-guard-pencils/source/6701-NOTICE @@ -0,0 +1,25 @@ +Common-image full-guard family +Prepared for ToikY with substantial OpenAI Codex assistance; Apache-2.0. +Separate AI primary, independent oracle and static reviewer are not independent +human or formal proof-kernel acceptance. + +Eight exact predecessor prose/metadata objects retain their original headers, +credit and disclosures in inputs/; SOURCE-PINS.json records source repository, +head, path, Git blob and SHA256. No predecessor executable is copied or run. + +Nick Petalas: PR6694 released shared-direction question; PR4807 pair law, +PR4275 binary full-guard context, PR4227 marginal, PR4261 partial-sum lineage, +and PR4778 question. The k2 transpose-dual law is prior coverage. +unpaidmoon: PR6515 six-event orthogonal theorem and nonorthogonal motivation; +its substantial Cursor Grok assistance notice remains exact in the source. +Ryanson Jonathan: PR4607 five-event spectrum/theorem. PR4599, PR5146 and their +source attributions remain credited through the exact retained notices. +Cinna Davis BIT context, source527, commdata2338 and Jose Manuel/normalizer/ +recursive compiler lineage retain predecessor credit. No inherited physical +claim is independently admitted by the present probability count. + +Classical methods: rank-one determinant lemma, orbit-stabilizer and binary +finite-rank counting. Gzip payload equality follows the repository convention +credited to Maxime Fleury after Antoine Olivier's independent replay findings. +Douglas Colkitt and other repository contributors retain task/replay-framework +credit. Original upstream and predecessor packages remain unchanged. diff --git a/research/common-image-guard-pencils/source/6701-PROOF.md b/research/common-image-guard-pencils/source/6701-PROOF.md new file mode 100644 index 0000000000..87d6fa4854 --- /dev/null +++ b/research/common-image-guard-pencils/source/6701-PROOF.md @@ -0,0 +1,179 @@ +# Binary common-image full-guard family + +This is a counting theorem for complete, equally weighted headers. The proof +covers all dimensions below; the executable domains are finite corroboration. +The complements guarded here are corank one. They are not rank-one first-pivot +requests. No physical header producer or paid caller is supplied. + +## Statement + +Work over F_2. Fix m >= 2 and 1 <= k <= m. Let u be a nonzero column and +v_1,...,v_k independent ordered covectors, with v_i u = 1. Put +U_i = u v_i and P_i = I - U_i. For G uniform in GL_m(F_2), let E_i mean +that every leading principal minor of G P_i G^{-1} of orders 1,...,m-1 +is nonzero. Define + + A_j = 0 if j < k-1, + A_j = 2^j product_{r=0}^{k-2}(2^j-2^r) otherwise, + +where an empty product is one. Then + + Pr(E_1 and ... and E_k) + = [sum_{j=0}^{m-1} binom(m-1,j) A_j] / [(2^m-1) A_{m-1}]. (1) + +The summand indexed by j counts passing orbit tuples with exactly j zero +coordinates of the transformed u among its first m-1 coordinates. Every +orbit tuple has exactly + + 2^{(k-1)(m-k)} |GL_{m-k}(F_2)| (2) + +complete headers above it, with |GL_0|=1. + +The new larger-family case is k >= 3. The k=1 marginal is predecessor +PR4227. The k=2 specialization is the transpose-dual of Nick Petalas's +PR4807 common-covector pair law; neither specialization is claimed as new. + +## The tuple orbit and constant header fibers + +Write V for the k by m matrix with rows v_i and t for the all-ones column +in F_2^k. Conjugation acts as (u,V) -> (G u,V G^{-1}). It preserves + + u != 0, rank(V)=k, V u=t. (3) + +Conversely this action is transitive. The columns t,e_2,...,e_k form a +basis of F_2^k. Choose preimages b_2,...,b_k under V of e_2,...,e_k; +take b_1=u; then extend these columns by a basis of ker(V). Their images +are independent, so the resulting m by m matrix B is invertible and + + B^{-1}u=e_1, V B=[Q 0], Q=[t e_2 ... e_k]. + +For a second tuple use B' in the same way. G=B' B^{-1} sends the first +tuple to the second. Thus every tuple satisfying (3) is reached and +uniform complete headers give a uniform distribution on these tuples. +This conclusion does not apply to a restricted or weighted header set. + +In these adapted coordinates a stabilizing matrix has block form + + [ I_k 0 ] + [ T H ], + +where H is any element of GL_{m-k} and the first column of T is zero +because the matrix fixes e_1. Its other (k-1)(m-k) entries are free. +This proves (2) and the equality of every header fiber by orbit-stabilizer. +At k=m the empty blocks give the same formula with fiber one. + +For fixed nonzero u, choose coordinates in which u is the last unit +vector. The condition V u=t fixes the final column of V to t. Let B_0 +be its other m-1 columns. Choose an invertible row operation taking t +to the first unit vector. The first row of B_0 is arbitrary, while the +remaining k-1 rows must be independent. There are A_{m-1} possibilities. +Consequently the orbit has size D=(2^m-1)A_{m-1}. Equivalently its +constant fiber is |GL_m|/D, agreeing with (2). Over F_2 a common image +line has a unique nonzero vector u, so no scalar gauge has been counted. + +## From all proper minors to coordinate support + +For a transformed tuple write u'=G u and V'=V G^{-1}. The rank-one +determinant lemma gives, for each proper order l, + + det((I-u'v'_i)_{1:l,1:l}) + = 1 + sum_{a=1}^l u'_a v'_{i,a}. + +In F_2 this determinant is nonzero precisely when the partial sum is +zero. Every proper prefix must vanish. Subtract consecutive prefixes +(the first prefix is already a single product) to obtain + + u'_a v'_{i,a}=0 for every a (729/8128)^6 = s_7^6. + +For a simple exact inequality, 22/2667>1/128, while 729/8128<1/8, +so s_7^6<1/8^6<1/128. Each individual event still has the same +marginal s_7. Sharing changes the joint distribution, not the single +uniform-GL corank-one full-guard marginal. + +This exhibits all six common-image kernels. It does not settle a narrower +reading of PR6515 Q2 involving exactly one coupled pair and four otherwise +orthogonal kernels. Nor does it identify PR4240's rank-one first-pivot +predicate with the complementary full-guard predicate used here. + +## Evidence and scope + +The primary literally conjugates the complements and checks every proper +minor for every GL_2, GL_3 and GL_4 header. Its 20,334 complete actual +header-code/passing-mask records include orbit coverage and constant-fiber +checks for every k in those dimensions. A separate engine uses column-rank +and zero-support dynamic programming for the 135 frozen (m,k) pairs through +m=16, plus literal quotient-span states at (7,6). After both blind firsts, +its separately written literal-matrix census compares every submitted small +header record as data. These finite checks corroborate, and do not replace, +the all-dimension argument above. There is no GL_7 or predecessor spectrum +run. AI static review is recorded separately from execution and from human +or proof-kernel acceptance. + +The direct released request is Nick Petalas's PR6694 README question 3. +The binary prefix criterion and orthogonal-family context are predecessors +PR4275 and PR6515; their orthogonal spectra are not reused or contradicted. +PR4807 explicitly excludes larger families, rather than requesting this law. +Arbitrary nonorthogonal mixtures, odd fields, restricted headers and physical +selection/emission/dispatch/restoration/stock/precision/caller costs remain +outside this theorem. No supplier, recursive invoice, kappa or selected +frontier change follows from a complete-header counting probability. diff --git a/research/common-image-guard-pencils/source/6701-TASK.json b/research/common-image-guard-pencils/source/6701-TASK.json new file mode 100644 index 0000000000..095961be05 --- /dev/null +++ b/research/common-image-guard-pencils/source/6701-TASK.json @@ -0,0 +1,111 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "independent-moment", + "question": "Does a changed construction's serialized target/paid invoice independently support its claimed improvement?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "docs/research/recursive-invoice-preflight.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Independently recount one changed emitted word and its complete caller, importing no constructor or pricing engine. Include target losses, owned lifetimes, native orientation and extra charges. Check existing #5633/#5708/#5717/#5719 coverage to avoid duplicate audits and preserve its exact head. Stop after the chosen missing implication; a correct root alone is not supplier admission.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "invoice", + "signed moment", + "productive target", + "independent recount" + ], + "existing_checks": [ + { + "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Prove the complete binary uniform-header full-guard count for all m>=2,1<=k<=m with independent normalized covectors and one common image, and independently validate bounded finite domains.", + "scope_change_reason": "Take6694READMEQ3 shared-direction continuation; k>=3 is new scope, k1/k2 retain prior credit. This is a mathematical header-count side result, not the original changed paid/target-invoice acceptance gate.", + "bottleneck_link": "Quantifies dependence of a precise nonorthogonal complement full-guard family before any producer/caller applicability or pricing can be asserted.", + "budget_minutes": 60, + "stop_rule": "One common-image binary full-guard family only; preserve frozen inputs/first failures; science cutoff23:27:03UTC, final15minutes verification/handoff; stop if orbit/fiber proof or complete small census disagrees.", + "outcome": "completed", + "evidence": "Scoped all-dimension proof;135 rows,20334 complete small headers, actual retained record comparisons,374-span oracle and exact22/2667 m7k6 example. Original paid/target invoice gate remains unmet. Transport/publication tracked separately.", + "author": "ToikY", + "ai_assistance": "Substantial OpenAI Codex assistance with separate AI primary, independent oracle and static review; no independent human or formal-kernel acceptance.", + "open_questions": [ + { + "question": "What is the full-guard law for one coupled pair plus four otherwise orthogonal kernels?", + "why_it_matters": "That narrower reading of6515Q2 is a different partial-Gram orbit from all six sharing one image.", + "first_step": "Write one normalized binary partial-Gram tuple and prove its precise complement/full-minor predicate.", + "blocked_by": "The present common-image orbit does not cover this mixed family." + }, + { + "question": "Can a named physical caller supply and use these complete headers?", + "why_it_matters": "A counting probability does not price selection or produce a compatible supplier.", + "first_step": "Pin one producer/header domain and complete selection, emission, dispatch, restoration, stock and precision costs.", + "blocked_by": "No physical producer, actual caller or complete paid/target invoice is supplied." + }, + { + "question": "What remains true for odd fields or restricted header distributions?", + "why_it_matters": "The binary prefix equivalence and complete uniform orbit are essential assumptions.", + "first_step": "Derive the changed prefix constraints and actual orbit weights before transferring the count.", + "blocked_by": "No nonbinary or restricted-header law/sign theorem is proved." + } + ] +} diff --git a/research/common-image-guard-pencils/source/6703-NOTICE b/research/common-image-guard-pencils/source/6703-NOTICE new file mode 100644 index 0000000000..417fc4e09b --- /dev/null +++ b/research/common-image-guard-pencils/source/6703-NOTICE @@ -0,0 +1,19 @@ +Common-covector all-field positive sign corollary +Prepared for ToikY with substantial OpenAI Codex assistance; Apache-2.0. +Separate AI primary, independent oracle and static review are not independent +human acceptance or formal proof-kernel checking. + +Nick Petalas, PR4807: exact all-field common-covector count, orbit and dependent- +pair subtraction; binary strict-positive theorem; explicit odd-field sign +question and suggested q*delta-alpha^2=q-1 identity. This package adds only the +quantified remaining sign proof, not a new count or generic correlation principle. +Nick Petalas PR4227: marginal law; PR4261: partial-sum/header counting method; +PR4778: two-way-coupling question; PR4769/4274: one-way comparison context. +Cinna Davis: BIT request context. source527, commdata2338, Jose Manuel and all +retained normalizer/recursive-closure lineage retain predecessor credit. +Two exact source prose objects and their original notices remain in inputs/. +No predecessor program is copied, imported or executed. + +Classical elementary polynomial identities and rational inequalities are used. +Douglas Colkitt and other repository contributors retain task/replay-framework +credit. No supplier, physical caller, kappa or selected-frontier change follows. diff --git a/research/common-image-guard-pencils/source/6703-PROOF.md b/research/common-image-guard-pencils/source/6703-PROOF.md new file mode 100644 index 0000000000..9d39a64ba2 --- /dev/null +++ b/research/common-image-guard-pencils/source/6703-PROOF.md @@ -0,0 +1,112 @@ +# Strict positive correlation over every finite field + +This is a modest sign corollary of Nick Petalas's credited PR4807 formula, +closing its README Open next question2. It supplies no new counting law. +PR4807 already proves the binary sign and explicitly suggests the identity +q*delta-alpha^2=q-1 used below. Its marginal is predecessor PR4227. + +## Source model and claim + +Let K=F_q, q>=2 a prime power, m>=2. Let a,c be independent columns in +K^m and b a covector satisfying ba=bc=1. Write U=ab,V=cb and the corank-one +complements P=I-U,Q=I-V. Complete equally weighted headers G range over +GL_m(K). Event E_P (respectively E_Q) requires every leading principal +minor of GPG^{-1} (respectively GQG^{-1}) of orders1,...,m-1 to be nonzero. +These are full proper-minor events on the complements, not first-pivot +requests on U,V. Other two-way pairs and restricted headers are outside scope. + +We prove + + Pr(E_P and E_Q) > Pr(E_P) Pr(E_Q) = p(q,m)^2. (1) + +The source law and uniform conjugation make both marginals equal to p. +The algebra below holds for all integer parameters q>=2,n>=1; a field/count +interpretation is asserted only for finite-field prime-power q. + +## Credited formulas and exact cancellation + +Put n=m-1, A=q^2-q+1, D=q^2+(q-1)^3 and x=q^{n+1}. PR4807 proves + + p = (q-1) A^n / [(x-1) q^n], + J = (q-1)(D^n-A^n) / [(x-1)(x-q) q^{n-1}]. (2) + +Those formulas, their common-covector orbit count, dependent-pair subtraction +and finite source censuses are cited premises, not independently recounted +here. In particular the binary sign was already a theorem in that source. +All denominators in (2) and below are positive: q>=2,n>=1 imply x>q>1, +A>0 and p>0. Cancellation gives the exact ratio + + R = J/p^2 + = x(x-1)/[(q-1)(x-q)] * [D^n/A^{2n} - 1/A^n]. (3) + +The identity qD-A^2=q-1>0 shows D>A^2/q. Since n>=1 and all bases +are positive, replacing D^n by (A^2/q)^n strictly decreases (3). Therefore + + R > L = q(x-1)/[(q-1)(x-q)] * [1-(q/A)^n]. (4) + +It remains to prove L>=1. Strictness in (1) is already supplied by (4), +including any boundary equality for L. + +## Nonnegative coefficient certificates + +Set t=q-2>=0. Direct polynomial expansion gives + + qD-A^2 = q-1, + A-q = t^2+2t+1 > 0, + 2A-q(q+1) = t^2+t >= 0, + A^2-q^3 = t^4+5t^3+9t^2+6t+1 > 0. (5) + +The coefficient lists in RESULT.json are in increasing order: [-1,1] in q +for the first identity, and [1,2,1], [0,1,1], [1,6,9,5,1] in t for +the other three. Nonnegative coefficients and the positive constant terms +prove the strict signs stated in (5) throughout the quantified domain. +The written expansions establish identities; finite coefficient calculations +corroborate them and are not an inference from a numerical sign grid. + +If n=1, simplify (4) to + + L = (q^2-1)/A, + L-1 = (q-2)/A >= 0. + +Equivalently, clearing positive denominators before simplification gives +2A>=q(q+1), whose certificate is the third identity in (5). At q=2 this +lower bound is exactly one. The strict replacement in (4) still gives R>1. + +If n>=2, the second and fourth identities in (5) give A>q and A^2>q^3. +Consequently + + A^n = A^2 A^{n-2} > q^3 q^{n-2} = q^{n+1} = x. + +This step is strict also at n=2. It follows that (q/A)^n<1/q. Substituting +this strict bound in (4)'s expression for L gives + + L > q(x-1)/[(q-1)(x-q)] * (1-1/q) + = (x-1)/(x-q) > 1, + +because q>1. Thus R>L>=1 for all q>=2,n>=1. Since p>0, multiplying +by p^2 proves (1), in particular for every finite field and every m>=2. +No correlation-sign statement for a different pair orbit follows. + +## What is new and what remains + +PR4807 supplies both probabilities, their all-field validity, the binary +strict-positive theorem and the suggested qD-A^2 identity. PR4227 supplies +the marginal and PR4261 the partial-sum/header method. The increment here +is the short quantified sign proof for the remaining field sizes, using +these existing formulas. It is not a new orbit count, full audit of4807, +generic positive-correlation principle, larger-family law or physical saving. + +The program evaluates205 fixed parameter pairs exactly and obtains the four +actual coefficient arrays by degree-bounded rational interpolation. A separate +engine uses polynomial convolution and integer recurrences with Euclidean +rational normalization. Neither imports a predecessor or peer program. These +checks corroborate the algebra; no GL census or predecessor scientific checker +is run. Non-prime-power rows are explicitly parameter algebra, not field counts. + +The original hypotheses remain: independent a,c, ba=bc=1, one common covector, +corank-one full guards and a complete uniform header distribution. Independent +covectors/general two-way pairs, larger families and restricted headers remain +open here. Header production, selection, emission, dispatch, dirty restoration, +stock, precision, producer compatibility and the full physical caller bill are +unpriced. No supplier admission, selected-frontier change, kappa improvement, +complete multiplication theorem or human/formal-kernel acceptance is claimed. diff --git a/research/common-image-guard-pencils/source/LICENSE b/research/common-image-guard-pencils/source/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/common-image-guard-pencils/source/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. From 89645297ca5f39b2153603b3d0df42a96e9deb89 Mon Sep 17 00:00:00 2001 From: SHIN09-git Date: Wed, 4 Nov 2026 13:30:26 +0800 Subject: [PATCH 2/3] Classify the field orders admitting below-product common-image guard families --- .../AFFINE-PLANES.json | 463 +++++ .../ASYMPTOTICS.json | 230 +++ .../FULL-FLATS.json | 73 + .../GL4-ORDER3.json | 42 + .../LITERAL-GL.json | 511 ++++++ research/common-image-guard-pencils/NOTICE | 10 + .../common-image-guard-pencils/OVERLAP.json | 194 ++ research/common-image-guard-pencils/PROOF.md | 95 + research/common-image-guard-pencils/README.md | 43 + .../common-image-guard-pencils/RESULT.json | 957 ++++++++++ .../SIGN-WINDOWS.json | 1574 +++++++++++++++++ research/common-image-guard-pencils/SIGN.md | 84 + .../SMALL-FIELDS.md | 28 + .../common-image-guard-pencils/SOURCES.json | 116 ++ research/common-image-guard-pencils/TASK.json | 107 ++ .../TERNARY-FOUR.json | 152 ++ .../TRIPLE-CERTIFICATES.json | 155 ++ .../common-image-guard-pencils/TRIPLES.md | 43 + .../common-image-guard-pencils/VALIDATION.md | 36 + .../common-image-guard-pencils/VERIFY.json | 96 + .../audit_mutations.py | 69 + research/common-image-guard-pencils/checks.py | 135 ++ .../common-image-guard-pencils/dependency.py | 83 + research/common-image-guard-pencils/finite.py | 68 + .../common-image-guard-pencils/flat_check.py | 34 + .../common-image-guard-pencils/headers.py | 80 + research/common-image-guard-pencils/laws.py | 92 + .../literal_check.py | 62 + .../common-image-guard-pencils/plane_check.py | 96 + .../common-image-guard-pencils/scaling.py | 35 + .../common-image-guard-pencils/ternary.py | 30 + .../common-image-guard-pencils/triples.py | 44 + research/common-image-guard-pencils/verify.py | 85 + .../common-image-guard-pencils/windows.py | 43 + 34 files changed, 5965 insertions(+) create mode 100644 research/common-image-guard-pencils/AFFINE-PLANES.json create mode 100644 research/common-image-guard-pencils/ASYMPTOTICS.json create mode 100644 research/common-image-guard-pencils/FULL-FLATS.json create mode 100644 research/common-image-guard-pencils/GL4-ORDER3.json create mode 100644 research/common-image-guard-pencils/LITERAL-GL.json create mode 100644 research/common-image-guard-pencils/NOTICE create mode 100644 research/common-image-guard-pencils/OVERLAP.json create mode 100644 research/common-image-guard-pencils/PROOF.md create mode 100644 research/common-image-guard-pencils/README.md create mode 100644 research/common-image-guard-pencils/RESULT.json create mode 100644 research/common-image-guard-pencils/SIGN-WINDOWS.json create mode 100644 research/common-image-guard-pencils/SIGN.md create mode 100644 research/common-image-guard-pencils/SMALL-FIELDS.md create mode 100644 research/common-image-guard-pencils/SOURCES.json create mode 100644 research/common-image-guard-pencils/TASK.json create mode 100644 research/common-image-guard-pencils/TERNARY-FOUR.json create mode 100644 research/common-image-guard-pencils/TRIPLE-CERTIFICATES.json create mode 100644 research/common-image-guard-pencils/TRIPLES.md create mode 100644 research/common-image-guard-pencils/VALIDATION.md create mode 100644 research/common-image-guard-pencils/VERIFY.json create mode 100644 research/common-image-guard-pencils/audit_mutations.py create mode 100644 research/common-image-guard-pencils/checks.py create mode 100644 research/common-image-guard-pencils/dependency.py create mode 100644 research/common-image-guard-pencils/finite.py create mode 100644 research/common-image-guard-pencils/flat_check.py create mode 100644 research/common-image-guard-pencils/headers.py create mode 100644 research/common-image-guard-pencils/laws.py create mode 100644 research/common-image-guard-pencils/literal_check.py create mode 100644 research/common-image-guard-pencils/plane_check.py create mode 100644 research/common-image-guard-pencils/scaling.py create mode 100644 research/common-image-guard-pencils/ternary.py create mode 100644 research/common-image-guard-pencils/triples.py create mode 100644 research/common-image-guard-pencils/verify.py create mode 100644 research/common-image-guard-pencils/windows.py diff --git a/research/common-image-guard-pencils/AFFINE-PLANES.json b/research/common-image-guard-pencils/AFFINE-PLANES.json new file mode 100644 index 0000000000..3a197c8acf --- /dev/null +++ b/research/common-image-guard-pencils/AFFINE-PLANES.json @@ -0,0 +1,463 @@ +[ + { + "q": 2, + "named_directions": 4, + "headers": 168, + "subsets": 16, + "determinant_classes": 1, + "nonempty_mask_signs_by_size_rank": { + "1,1": [ + 0, + 4, + 0 + ], + "2,2": [ + 0, + 0, + 6 + ], + "3,3": [ + 0, + 0, + 4 + ], + "4,3": [ + 0, + 0, + 1 + ] + }, + "subset_count_sha256": "c0a1efe6d82ba9d66cfc8263b1c4b45b5731c8a4bf6b0af56615b7ae1080c446", + "word_det_mask_sha256": "a7baf51eb9c456922e273f098cd6348d985d02ec3436f18207942bc38af580f2", + "observed_exact_masks": { + "0": 72, + "1": 6, + "2": 6, + "3": 8, + "4": 6, + "5": 8, + "6": 8, + "8": 6, + "9": 8, + "10": 8, + "12": 8, + "15": 24 + } + }, + { + "q": 3, + "named_directions": 9, + "headers": 11232, + "subsets": 512, + "determinant_classes": 2, + "nonempty_mask_signs_by_size_rank": { + "1,1": [ + 0, + 9, + 0 + ], + "2,2": [ + 0, + 0, + 36 + ], + "3,2": [ + 0, + 0, + 12 + ], + "3,3": [ + 0, + 0, + 72 + ], + "4,3": [ + 0, + 0, + 126 + ], + "5,3": [ + 0, + 0, + 126 + ], + "6,3": [ + 0, + 0, + 84 + ], + "7,3": [ + 0, + 0, + 36 + ], + "8,3": [ + 0, + 0, + 9 + ], + "9,3": [ + 0, + 0, + 1 + ] + }, + "subset_count_sha256": "612923745f958e2b146700462a07c95c9e92ace889af46e652d44119f483c34c", + "word_det_mask_sha256": "3a5c745a574e0004335ccdd71500e5db62e612988147a612bfd220c907f54c59", + "observed_exact_masks": { + "0": 3456, + "27": 64, + "29": 64, + "30": 64, + "43": 64, + "45": 64, + "46": 64, + "51": 64, + "53": 64, + "54": 64, + "63": 288, + "78": 64, + "83": 64, + "90": 64, + "101": 64, + "108": 64, + "113": 64, + "139": 64, + "149": 64, + "153": 64, + "166": 64, + "170": 64, + "180": 64, + "195": 64, + "197": 64, + "198": 64, + "202": 64, + "209": 64, + "216": 64, + "219": 288, + "228": 64, + "232": 64, + "238": 288, + "240": 64, + "245": 288, + "269": 64, + "278": 64, + "284": 64, + "291": 64, + "297": 64, + "306": 64, + "323": 64, + "325": 64, + "326": 64, + "332": 64, + "338": 64, + "344": 64, + "350": 288, + "353": 64, + "360": 64, + "365": 288, + "368": 64, + "371": 288, + "387": 64, + "389": 64, + "390": 64, + "393": 64, + "404": 64, + "408": 64, + "413": 288, + "418": 64, + "424": 64, + "427": 288, + "432": 64, + "438": 288, + "455": 288, + "504": 288, + "511": 864 + } + }, + { + "q": 4, + "named_directions": 16, + "headers": 181440, + "subsets": 65536, + "determinant_classes": 3, + "nonempty_mask_signs_by_size_rank": { + "1,1": [ + 0, + 16, + 0 + ], + "2,2": [ + 0, + 0, + 120 + ], + "3,2": [ + 0, + 0, + 80 + ], + "3,3": [ + 0, + 0, + 480 + ], + "4,2": [ + 0, + 0, + 20 + ], + "4,3": [ + 0, + 0, + 1800 + ], + "5,3": [ + 0, + 0, + 4368 + ], + "6,3": [ + 0, + 0, + 8008 + ], + "7,3": [ + 0, + 0, + 11440 + ], + "8,3": [ + 0, + 0, + 12870 + ], + "9,3": [ + 0, + 0, + 11440 + ], + "10,3": [ + 0, + 0, + 8008 + ], + "11,3": [ + 0, + 0, + 4368 + ], + "12,3": [ + 0, + 0, + 1820 + ], + "13,3": [ + 0, + 0, + 560 + ], + "14,3": [ + 0, + 0, + 120 + ], + "15,3": [ + 0, + 0, + 16 + ], + "16,3": [ + 0, + 0, + 1 + ] + }, + "subset_count_sha256": "912ad96329edc8c3b963c2a1809cbb460bdc3ad1bd30c22ee8fd8db6a615c65a", + "word_det_mask_sha256": "756f5180c952b343162aad2a23cbb41e136e7d93f85274a37c6c32dedf0e9f5b", + "observed_exact_masks": { + "0": 43200, + "1911": 486, + "1982": 486, + "2011": 486, + "2029": 486, + "2941": 486, + "3003": 486, + "3038": 486, + "3047": 486, + "3454": 486, + "3511": 486, + "3549": 486, + "3563": 486, + "3707": 486, + "3773": 486, + "3799": 486, + "3822": 486, + "4095": 2592, + "13686": 486, + "13801": 486, + "13911": 486, + "13997": 486, + "14181": 486, + "14686": 486, + "14763": 486, + "15033": 486, + "15062": 486, + "15258": 486, + "15722": 486, + "16021": 486, + "21351": 486, + "21406": 486, + "22131": 486, + "22204": 486, + "22326": 486, + "23004": 486, + "23011": 486, + "23494": 486, + "23659": 486, + "23709": 486, + "24009": 486, + "24121": 486, + "25461": 486, + "25562": 486, + "25911": 486, + "26059": 486, + "26451": 486, + "27197": 486, + "27342": 486, + "27484": 486, + "27829": 486, + "27882": 486, + "28067": 486, + "28332": 486, + "28791": 486, + "28861": 486, + "28894": 486, + "28907": 486, + "29526": 486, + "30051": 486, + "30261": 486, + "30471": 486, + "30576": 486, + "30583": 2592, + "31178": 486, + "31388": 486, + "31502": 486, + "31696": 486, + "31710": 2592, + "31913": 486, + "32011": 486, + "32224": 486, + "32235": 2592, + "32269": 486, + "32432": 486, + "32445": 2592, + "37818": 486, + "37861": 486, + "38206": 486, + "38349": 486, + "38828": 486, + "39483": 486, + "39623": 486, + "39843": 486, + "40058": 486, + "40149": 486, + "40284": 486, + "40531": 486, + "41837": 486, + "41883": 486, + "42707": 486, + "42732": 486, + "42953": 486, + "43388": 486, + "43443": 486, + "43833": 486, + "44142": 486, + "44183": 486, + "44342": 486, + "44742": 486, + "45182": 486, + "45243": 486, + "45271": 486, + "45293": 486, + "45993": 486, + "46444": 486, + "46789": 486, + "46861": 486, + "47072": 486, + "47085": 2592, + "47418": 486, + "47763": 486, + "47883": 486, + "48048": 486, + "48059": 2592, + "48214": 486, + "48398": 486, + "48496": 486, + "48510": 2592, + "48647": 486, + "48848": 486, + "48855": 2592, + "50614": 486, + "50649": 486, + "50779": 486, + "50862": 486, + "51098": 486, + "51549": 486, + "51623": 486, + "51833": 486, + "51942": 486, + "52069": 486, + "52629": 486, + "52842": 486, + "53371": 486, + "53438": 486, + "53469": 486, + "53479": 486, + "54182": 486, + "54684": 486, + "54842": 486, + "55054": 486, + "55216": 486, + "55230": 2592, + "55749": 486, + "55907": 486, + "56071": 486, + "56288": 486, + "56295": 2592, + "56409": 486, + "56589": 486, + "56784": 486, + "56797": 2592, + "56843": 486, + "56944": 486, + "56955": 2592, + "57469": 486, + "57527": 486, + "57563": 486, + "57582": 486, + "58201": 486, + "58771": 486, + "59082": 486, + "59147": 486, + "59344": 486, + "59355": 2592, + "59701": 486, + "60012": 486, + "60173": 486, + "60272": 486, + "60285": 2592, + "60582": 486, + "60679": 486, + "60848": 486, + "60855": 2592, + "60942": 486, + "61152": 486, + "61166": 2592, + "61695": 2592, + "65295": 2592, + "65520": 2592, + "65535": 8640 + } + } +] diff --git a/research/common-image-guard-pencils/ASYMPTOTICS.json b/research/common-image-guard-pencils/ASYMPTOTICS.json new file mode 100644 index 0000000000..531d2b1089 --- /dev/null +++ b/research/common-image-guard-pencils/ASYMPTOTICS.json @@ -0,0 +1,230 @@ +{ + "fixed_dimension": [ + { + "q": 16, + "m": 2, + "last_k": 13, + "k_over_q": "13/16" + }, + { + "q": 16, + "m": 3, + "last_k": 11, + "k_over_q": "11/16" + }, + { + "q": 16, + "m": 6, + "last_k": 7, + "k_over_q": "7/16" + }, + { + "q": 16, + "m": 11, + "last_k": 5, + "k_over_q": "5/16" + }, + { + "q": 64, + "m": 2, + "last_k": 51, + "k_over_q": "51/64" + }, + { + "q": 64, + "m": 3, + "last_k": 39, + "k_over_q": "39/64" + }, + { + "q": 64, + "m": 6, + "last_k": 22, + "k_over_q": "11/32" + }, + { + "q": 64, + "m": 11, + "last_k": 13, + "k_over_q": "13/64" + }, + { + "q": 256, + "m": 2, + "last_k": 204, + "k_over_q": "51/64" + }, + { + "q": 256, + "m": 3, + "last_k": 151, + "k_over_q": "151/256" + }, + { + "q": 256, + "m": 6, + "last_k": 82, + "k_over_q": "41/128" + }, + { + "q": 256, + "m": 11, + "last_k": 47, + "k_over_q": "47/256" + }, + { + "q": 1024, + "m": 2, + "last_k": 816, + "k_over_q": "51/64" + }, + { + "q": 1024, + "m": 3, + "last_k": 599, + "k_over_q": "599/1024" + }, + { + "q": 1024, + "m": 6, + "last_k": 323, + "k_over_q": "323/1024" + }, + { + "q": 1024, + "m": 11, + "last_k": 182, + "k_over_q": "91/512" + }, + { + "q": 4096, + "m": 2, + "last_k": 3264, + "k_over_q": "51/64" + }, + { + "q": 4096, + "m": 3, + "last_k": 2389, + "k_over_q": "2389/4096" + }, + { + "q": 4096, + "m": 6, + "last_k": 1287, + "k_over_q": "1287/4096" + }, + { + "q": 4096, + "m": 11, + "last_k": 723, + "k_over_q": "723/4096" + } + ], + "fixed_size": [ + { + "q": 16, + "k": 3, + "last_m": 39, + "m_over_q": "39/16" + }, + { + "q": 16, + "k": 4, + "last_m": 18, + "m_over_q": "9/8" + }, + { + "q": 16, + "k": 7, + "last_m": 6, + "m_over_q": "3/8" + }, + { + "q": 64, + "k": 3, + "last_m": 134, + "m_over_q": "67/32" + }, + { + "q": 64, + "k": 4, + "last_m": 65, + "m_over_q": "65/64" + }, + { + "q": 64, + "k": 7, + "last_m": 25, + "m_over_q": "25/64" + }, + { + "q": 256, + "k": 3, + "last_m": 518, + "m_over_q": "259/128" + }, + { + "q": 256, + "k": 4, + "last_m": 257, + "m_over_q": "257/256" + }, + { + "q": 256, + "k": 7, + "last_m": 102, + "m_over_q": "51/128" + }, + { + "q": 1024, + "k": 3, + "last_m": 2054, + "m_over_q": "1027/512" + }, + { + "q": 1024, + "k": 4, + "last_m": 1025, + "m_over_q": "1025/1024" + }, + { + "q": 1024, + "k": 7, + "last_m": 409, + "m_over_q": "409/1024" + } + ], + "growing_size_and_dimension": [ + { + "q": 16, + "k": 4, + "last_m": 18, + "d_k_over_q": "17/4" + }, + { + "q": 64, + "k": 8, + "last_m": 21, + "d_k_over_q": "5/2" + }, + { + "q": 256, + "k": 16, + "last_m": 36, + "d_k_over_q": "35/16" + }, + { + "q": 1024, + "k": 32, + "last_m": 68, + "d_k_over_q": "67/32" + }, + { + "q": 4096, + "k": 64, + "last_m": 131, + "d_k_over_q": "65/32" + } + ] +} diff --git a/research/common-image-guard-pencils/FULL-FLATS.json b/research/common-image-guard-pencils/FULL-FLATS.json new file mode 100644 index 0000000000..6a7dde1542 --- /dev/null +++ b/research/common-image-guard-pencils/FULL-FLATS.json @@ -0,0 +1,73 @@ +{ + "full_flat_checks": 32, + "sufficient_sizes": [ + { + "q": 2, + "first_size_certified_by_last_axis": 3 + }, + { + "q": 3, + "first_size_certified_by_last_axis": 5 + }, + { + "q": 4, + "first_size_certified_by_last_axis": 7 + }, + { + "q": 5, + "first_size_certified_by_last_axis": 10 + }, + { + "q": 7, + "first_size_certified_by_last_axis": 15 + }, + { + "q": 8, + "first_size_certified_by_last_axis": 18 + }, + { + "q": 9, + "first_size_certified_by_last_axis": 22 + }, + { + "q": 11, + "first_size_certified_by_last_axis": 28 + }, + { + "q": 13, + "first_size_certified_by_last_axis": 35 + }, + { + "q": 16, + "first_size_certified_by_last_axis": 46 + }, + { + "q": 17, + "first_size_certified_by_last_axis": 50 + }, + { + "q": 19, + "first_size_certified_by_last_axis": 58 + }, + { + "q": 23, + "first_size_certified_by_last_axis": 74 + }, + { + "q": 25, + "first_size_certified_by_last_axis": 83 + }, + { + "q": 27, + "first_size_certified_by_last_axis": 91 + }, + { + "q": 29, + "first_size_certified_by_last_axis": 100 + }, + { + "q": 31, + "first_size_certified_by_last_axis": 109 + } + ] +} diff --git a/research/common-image-guard-pencils/GL4-ORDER3.json b/research/common-image-guard-pencils/GL4-ORDER3.json new file mode 100644 index 0000000000..b15eee6c10 --- /dev/null +++ b/research/common-image-guard-pencils/GL4-ORDER3.json @@ -0,0 +1,42 @@ +[ + { + "q": 4, + "m": 3, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "headers": 181440, + "determinant_classes": 3, + "masks": { + "0": 53568, + "3": 5832, + "5": 5832, + "6": 5832, + "7": 19116, + "9": 5832, + "10": 5832, + "11": 19116, + "12": 5832, + "13": 19116, + "14": 19116, + "15": 16416 + }, + "word_det_mask_sha256": "29d4f4e7b7513c36b2f3028d6a066c77eafb2f646128d7a0f9469a28d82ca1cc", + "family": "pencil" + } +] diff --git a/research/common-image-guard-pencils/LITERAL-GL.json b/research/common-image-guard-pencils/LITERAL-GL.json new file mode 100644 index 0000000000..34e8a83e33 --- /dev/null +++ b/research/common-image-guard-pencils/LITERAL-GL.json @@ -0,0 +1,511 @@ +[ + { + "q": 2, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "headers": 6, + "determinant_classes": 1, + "masks": { + "0": 2, + "1": 1, + "2": 1, + "3": 2 + }, + "word_det_mask_sha256": "99e09ac15df751654ec0b0012360df86cf509e9ec061b8a8434eecb1b21af080", + "family": "pencil" + }, + { + "q": 3, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ] + ], + "headers": 48, + "determinant_classes": 2, + "masks": { + "0": 12, + "3": 8, + "5": 8, + "6": 8, + "7": 12 + }, + "word_det_mask_sha256": "40874deb91bee8cee9294ee89ecbb8942a6105b3aa942ecc5dad81601a5d319a", + "family": "pencil" + }, + { + "q": 4, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "headers": 180, + "determinant_classes": 3, + "masks": { + "0": 36, + "7": 27, + "11": 27, + "13": 27, + "14": 27, + "15": 36 + }, + "word_det_mask_sha256": "ec509ee857b8190b6f0b54d2bec64c12243b1c9c9f7329682298f43ceca7a599", + "family": "pencil" + }, + { + "q": 5, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ] + ], + "headers": 480, + "determinant_classes": 4, + "masks": { + "0": 80, + "15": 64, + "23": 64, + "27": 64, + "29": 64, + "30": 64, + "31": 80 + }, + "word_det_mask_sha256": "af8bc35d9df3b0255514322295e9c54d58bdc8d86fcb0a34473abed23a8ebe99", + "family": "pencil" + }, + { + "q": 7, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ] + ], + "headers": 2016, + "determinant_classes": 6, + "masks": { + "0": 252, + "63": 216, + "95": 216, + "111": 216, + "119": 216, + "123": 216, + "125": 216, + "126": 216, + "127": 252 + }, + "word_det_mask_sha256": "750066c0ec78692e84510d15253a26eac60a31367be2b328dfdf3ea5a3daba44", + "family": "pencil" + }, + { + "q": 8, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ] + ], + "headers": 3528, + "determinant_classes": 7, + "masks": { + "0": 392, + "127": 343, + "191": 343, + "223": 343, + "239": 343, + "247": 343, + "251": 343, + "253": 343, + "254": 343, + "255": 392 + }, + "word_det_mask_sha256": "1dd9d2e1dcd3263c62ee404e3f01c0ead92cc16f043ec96b23e9bb2d907ef094", + "family": "pencil" + }, + { + "q": 9, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ] + ], + "headers": 5760, + "determinant_classes": 8, + "masks": { + "0": 576, + "255": 512, + "383": 512, + "447": 512, + "479": 512, + "495": 512, + "503": 512, + "507": 512, + "509": 512, + "510": 512, + "511": 576 + }, + "word_det_mask_sha256": "8dc7d7fe6ec46c2e7090579767f6de84690380e108359c9c52fe7cb5f55130ff", + "family": "pencil" + }, + { + "q": 2, + "m": 3, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "headers": 168, + "determinant_classes": 1, + "masks": { + "0": 78, + "1": 14, + "2": 14, + "3": 8, + "4": 14, + "5": 8, + "6": 8, + "7": 24 + }, + "word_det_mask_sha256": "60a0fc925e476b159bdd09ecef268e79c8f3c855f27a8fe61d9ba0373bde4462", + "family": "independent" + }, + { + "q": 3, + "m": 3, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ] + ], + "headers": 11232, + "determinant_classes": 2, + "masks": { + "0": 4320, + "1": 384, + "2": 384, + "3": 1440, + "4": 384, + "5": 1440, + "6": 1440, + "7": 1440 + }, + "word_det_mask_sha256": "3af23a7b3544ff9de17e594089b475ff4489e356126d5c7310874b4da2693e9f", + "family": "pencil" + }, + { + "q": 3, + "m": 3, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "headers": 11232, + "determinant_classes": 2, + "masks": { + "0": 3840, + "1": 864, + "2": 864, + "3": 960, + "4": 864, + "5": 960, + "6": 960, + "7": 1920 + }, + "word_det_mask_sha256": "10512a170390d1ca67f3e99324c1e54a29bdb609f40a9f0042625cd348b6e933", + "family": "independent" + }, + { + "q": 2, + "m": 4, + "forms": [ + [ + 1, + 0, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0 + ], + [ + 1, + 0, + 1, + 0 + ], + [ + 1, + 0, + 0, + 1 + ] + ], + "headers": 20160, + "determinant_classes": 1, + "masks": { + "0": 10944, + "1": 1032, + "2": 1032, + "3": 432, + "4": 1032, + "5": 432, + "6": 432, + "7": 288, + "8": 1032, + "9": 432, + "10": 432, + "11": 288, + "12": 432, + "13": 288, + "14": 288, + "15": 1344 + }, + "word_det_mask_sha256": "b5a31e275f6f055da971ae630560a9b97ef084a76adc3137f4c9d3478bb97ec2", + "family": "independent" + }, + { + "q": 3, + "m": 3, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 2, + 0 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ] + ], + "headers": 11232, + "determinant_classes": 2, + "masks": { + "0": 3456, + "1": 64, + "2": 64, + "3": 256, + "4": 64, + "5": 256, + "6": 256, + "7": 288, + "8": 192, + "9": 128, + "10": 128, + "11": 416, + "12": 128, + "13": 416, + "14": 416, + "16": 192, + "17": 128, + "18": 128, + "19": 416, + "20": 128, + "21": 416, + "22": 416, + "24": 480, + "25": 64, + "26": 64, + "27": 352, + "28": 64, + "29": 352, + "30": 352, + "31": 1152 + }, + "word_det_mask_sha256": "627d2ba668cfb0ddc8274eadbbcbed2521eae320ac4564ca93aaadd375244cf7", + "family": "mixed" + } +] diff --git a/research/common-image-guard-pencils/NOTICE b/research/common-image-guard-pencils/NOTICE new file mode 100644 index 0000000000..c799eae7d6 --- /dev/null +++ b/research/common-image-guard-pencils/NOTICE @@ -0,0 +1,10 @@ +Common-image guard pencils +New derivations, programs and finite evidence prepared by SHIN09-git with +substantial OpenAI Codex assistance. Licensed under Apache-2.0. + +ToikY authored the PR6701 binary independent-family extension and the PR6703 +all-field pair-sign corollary. Nick Petalas authored the credited predecessor +marginal, pair counting law and binary sign. Prior author-specific disclosures +appear in source/6701-NOTICE, source/6703-NOTICE and the retained proofs. +Exact original heads, Git objects, retained paths and SHA256 hashes appear in +SOURCES.json. The package includes a copy of the upstream Apache-2.0 license. diff --git a/research/common-image-guard-pencils/OVERLAP.json b/research/common-image-guard-pencils/OVERLAP.json new file mode 100644 index 0000000000..5b5fc6a5ea --- /dev/null +++ b/research/common-image-guard-pencils/OVERLAP.json @@ -0,0 +1,194 @@ +{ + "entry": { + "searched_at": "2026-11-04T05:03:41.995979+00:00", + "status": "POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE", + "terms": [ + "common-image-full-guard-family", + "common-covector-header-law", + "affine pencil", + "common-image guard", + "common image pencil", + "guard pencils", + "pencil correlation" + ], + "coverage": { + "local": { + "head": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "records": 8917, + "head_records": 8917, + "complete_head_inventory": true, + "unsearched_head_paths": [] + }, + "open_prs": { + "fetched_at": "2026-11-04T05:02:14.012718+00:00", + "complete_pagination": true, + "records": 660 + }, + "discussions": { + "fetched_at": "2026-11-04T04:03:29.550776+00:00", + "complete_pagination": true, + "records": 6788 + }, + "closed_prs": { + "fetched_at": "2026-11-03T20:11:09.333493+00:00", + "complete_pagination": true, + "records": 5528 + } + }, + "matches_total": 5, + "warnings": [ + "discussions: refresh failed; using old data if available: Post \"https://api.github.com/graphql\": EOF\n", + "closed_prs: refresh failed; using old data if available: Get \"https://api.github.com/repos/CrocSwap/integer-mult-bounds/pulls?state=closed&per_page=100&sort=updated&direction=desc\": net/http: TLS handshake timeout\n" + ], + "limits": "Remote PR scope includes open and closed/merged titles and bodies, with separate coverage and timestamps. State changes are deduplicated by latest PR update; snapshots are not atomic. Local coverage compares searched working-tree notes with regular note paths at coverage.local.head; it does not certify HEAD contents or historical coverage. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission." + }, + "nearest": [ + { + "pr": 6701, + "relationship": "Binary complete common-image family of independent rows. Its third open question explicitly asks about odd fields/restricted headers. The affine-pencil dependency orbit and multiway sign crossings are outside that proof." + }, + { + "pr": 6703, + "relationship": "Proves the all-field positive pair sign from PR4807. Every pair here is a transpose-dual control; its binary sign and higher-way extension are not attributed to this package." + }, + { + "pr": 4807, + "relationship": "Nick Petalas derived the all-field common-covector pair law and binary positive sign." + }, + { + "pr": 4227, + "relationship": "Corank-one marginal. The present single-guard formula reproduces that prior result." + }, + { + "pr": 4259, + "relationship": "Laminar projectors with nested or orthogonal children; a pencil of distinct common-image kernels does not satisfy those hypotheses." + }, + { + "pr": 4806, + "relationship": "Two commuting rank-two ternary requests and their first two minors, a different pair orbit." + }, + { + "pr": 4915, + "relationship": "General ordered-pair orbit weights; the present denominator fixes an entire common-image list and counts the passing prefixes." + }, + { + "pr": 6694, + "relationship": "Orthogonal family of full guards, a different multiplication/row dependency." + }, + { + "pr": 6515, + "relationship": "Opened coupled-versus-orthogonal questions. One coupled pair among four otherwise orthogonal kernels is distinct." + }, + { + "pr": 6708, + "relationship": "Previous contribution from this account classifies signatures of bases split into two port blocks. Neither its branch nor its result supplies this guard law." + } + ], + "targeted_queries": [ + "\"pencil\" \"full guard\"", + "\"affine pencil\" \"header\"", + "\"dependent\" \"common-image\"", + "\"common-covector\" \"negative\"", + "\"6701\" \"common-image\"", + "\"full guard\" \"rank two\"", + "\"subspace lattice\" \"guard\"", + "\"pencil\" \"leading principal\"", + "\"affine line\" \"common-image\"" + ], + "closed_delta": { + "sorted": "updated descending", + "rows": [ + { + "number": 6321, + "updated_at": "2026-11-04T04:38:50Z", + "title": "Archive H25 cache source components and hand off N22, P07 and P02" + }, + { + "number": 5546, + "updated_at": "2026-11-03T02:00:05Z", + "title": "Verify the L300/L301 fixed-cut shared-handoff obstruction (no new κ)" + }, + { + "number": 2444, + "updated_at": "2026-11-02T08:42:08Z", + "title": "Exact-search tooling for noncommuting words, and a complete six-distinct-value screen of the KB2 thirteen-call candidate" + }, + { + "number": 2717, + "updated_at": "2026-11-02T08:42:07Z", + "title": "F-star proof-level lemmas: structural certificates, named-instance L8 reproduction, and a beyond-census falsifier search (no kappa)" + }, + { + "number": 2747, + "updated_at": "2026-11-02T08:42:05Z", + "title": "F-star residue (i): mixed anchor-repair-pivot lemma MX, tied-instance certificates, and a tied-domain search (no kappa)" + }, + { + "number": 2774, + "updated_at": "2026-11-02T08:41:59Z", + "title": "F-star residue class (ii): non-3-dichromatic zero digraphs - matched-pivot floor, fixture dichromatic structure, smallest-first falsifier search (no kappa)" + }, + { + "number": 2890, + "updated_at": "2026-11-02T08:41:55Z", + "title": "F-star residue (ii): the chi(Z) >= 4 case - structural lemmas, exact anchors, and a smallest-first search with exact obstructions (no kappa)" + }, + { + "number": 2914, + "updated_at": "2026-11-02T08:41:53Z", + "title": "F-star family gap: the sub-anchor-box decomposition and a fixture-density sub-decoder census (no kappa)" + }, + { + "number": 2901, + "updated_at": "2026-11-02T08:41:53Z", + "title": "F-star residue (i-prime): cancellation lines - tie lemma, insertion-finite mixing, fixture settlement, and the corrected dyadic corollary (no kappa)" + }, + { + "number": 2936, + "updated_at": "2026-11-02T08:41:49Z", + "title": "F-star family gap: the v = 7..11 census, the first gap-2 instance below v = 12, and the box-completeness attack (no kappa)" + } + ] + }, + "limits": "Local inventory, PR/discussion metadata and selected predecessor sources. Closed-PR and discussion refreshes can reuse timestamped snapshots; a newest-first update check supplements them. Historical diffs, private work and global priority are not exhaustively searchable.", + "prepublication": { + "searched_at": "2026-11-04T05:27:08.275345+00:00", + "status": "POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE", + "terms": [ + "common-image-full-guard-family", + "common-covector-header-law", + "affine pencil", + "full guard pencil", + "common image pencil", + "guard pencils", + "pencil correlation" + ], + "coverage": { + "local": { + "head": "b61b33794c53316a8e8d1fdb9efcc6ee651ac515", + "records": 8919, + "head_records": 8917, + "complete_head_inventory": true, + "unsearched_head_paths": [] + }, + "open_prs": { + "fetched_at": "2026-11-04T05:22:29.727439+00:00", + "complete_pagination": true, + "records": 660 + }, + "discussions": { + "fetched_at": "2026-11-04T05:26:04.446772+00:00", + "complete_pagination": true, + "records": 6788 + }, + "closed_prs": { + "fetched_at": "2026-11-04T05:27:07.563013+00:00", + "complete_pagination": true, + "records": 5528 + } + }, + "matches_total": 6, + "warnings": [], + "limits": "Remote PR scope includes open and closed/merged titles and bodies, with separate coverage and timestamps. State changes are deduplicated by latest PR update; snapshots are not atomic. Local coverage compares searched working-tree notes with regular note paths at coverage.local.head; it does not certify HEAD contents or historical coverage. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission." + } +} diff --git a/research/common-image-guard-pencils/PROOF.md b/research/common-image-guard-pencils/PROOF.md new file mode 100644 index 0000000000..e67bc62fc5 --- /dev/null +++ b/research/common-image-guard-pencils/PROOF.md @@ -0,0 +1,95 @@ +# Counting common-image full guards with row dependencies + +Fix a finite field of order $q$, an integer $m\ge2$, a nonzero column $u$, and a nonempty list of rows $v_i$ with $v_i u=1$. Let $V$ be the matrix of these rows, $S=\operatorname{im}V\subseteq\mathbb F_q^k$, $r=\dim S$, and $t=(1,\ldots,1)\in S$. The rows can repeat, and $k$ can exceed $m$. Write $E_i$ for the event that every leading principal minor of orders 1 through $m-1$ of $G(I-u v_i)G^{-1}$ is nonzero. The header $G$ is uniform on the complete $GL_m(\mathbb F_q)$. The order-$m$ determinant vanishes identically. + +## The orbit and the denominator + +Under a header the pair becomes $(G u,V G^{-1})$. Its image is still $S$, and $V u=t$ still holds. Conversely, for any pair with these properties, fix the same basis of $S$ beginning with $t$, lift its first element by $u$, lift the remaining $r-1$ elements arbitrarily, and append a basis of the kernel. In these domain coordinates all such pairs are identical. Thus the action is transitive. The stabilizer in adapted coordinates has blocks $[I_r,0;T,H]$, with $H\in GL_{m-r}$ and the first column of $T$ zero. Each pair is reached by $q^{(r-1)(m-r)}|GL_{m-r}|$ headers, using $|GL_0|=1$. + +Put $d=m-1$. For each of the $q^m-1$ choices of $u'$, choose coordinates with $u'$ last. Its image fixes the final column of $V'$ to $t$. In coordinates on $S$ beginning with $t$, the first row of the other $d$ columns is arbitrary and the remaining $r-1$ rows must be independent. Hence the orbit size is + +```text +D_r = (q^m-1) q^d product_{i=0}^{r-2}(q^d-q^i). +``` + +This counts tuples with a fixed initial representative of the common image vector. Over larger fields there are several representatives of an image line. The constant-fiber argument applies before any quotient by rescaling that vector. + +## Which tuples pass? + +For the transformed pair write $c_a$ for column $a$ of $V'$, and $y_j=\sum_{a\le j}u'_a c_a$. The rank-one determinant identity gives the $i$-th minor at order $j$ as $1-(y_j)_i$. Indeed the leading block is the identity minus one column times one row, whose determinant is one minus their pairing. All proper prefixes must avoid value one in **every** coordinate. The final prefix equals $t$. Thus $u'_m\ne0$ on the joint event. + +For any subspace $\langle t\rangle\le L\le S$, first count tuples with columns contained in $L$, allowing their span to be smaller. Define + +```text +h(L) = number of vectors in L having every coordinate nonzero, +lambda(L) = q^dim(L) + (q-1) h(L). +``` + +At each proper position, a zero $u'_a$ keeps the prefix and allows any of the $q^{\dim L}$ columns. For a fixed nonzero $u'_a$, prescribing the next prefix prescribes exactly one column in $L$. The allowed prefixes in $L$ are counted by $h(L)$, since $y\mapsto t-y$ takes the forbidden-value-one condition to the full-support condition. This count is independent of the preceding allowed prefix. At the last position there are $q-1$ nonzero choices for $u'_m$ and the unique column $(t-y_d)/u'_m$. The number with span contained in $L$ is therefore $(q-1)\lambda(L)^d$. The actual span always contains $t$. + +Invert these counts on the interval of subspaces between $\langle t\rangle$ and $S$. The exact probability is + +```text +J_S = (q-1) sum_{ <= L <= S} mu(L,S) lambda(L)^d / D_r, +mu(L,S) = (-1)^c q^[c(c-1)/2], c = r-dim(L). +``` + +For completeness, the displayed Möbius coefficient has value one at $c=0$. In a quotient of dimension $n>0$, its required zero sum is the specialization at $z=1$ of +$\prod_{i=0}^{n-1}(1-q^i z)=\sum_{c=0}^n {n\brack c}_q (-1)^c q^{\binom c2}z^c$. +The polynomial identity follows inductively from multiplying by the next factor using the Gaussian binomial recurrence. The Gaussian coefficient counts the subspaces of each codimension by counting independent ordered bases. This is the classical subspace-lattice inversion. [G.-C. Rota, 1964](https://doi.org/10.1007/BF00531932) + +At $q=2$ every $L$ in the interval contains exactly one full-support vector, $t$. For independent rows, expand $(2^{\dim L}+1)^d$. The coefficient of $\binom dj$ after inversion counts $j$ arbitrary columns spanning $S$ together with $t$. The same row count as in the denominator is $2^j\prod_{i=0}^{k-2}(2^j-2^i)$ when $j\ge k-1$, and zero otherwise. This recovers ToikY's binary independent-family formula. [PR #6701](https://github.com/CrocSwap/integer-mult-bounds/pull/6701) + +## A pencil and its named pass patterns + +Let $v_a=b+a w$, where $bu=1$, $wu=0$, $w\ne0$. Choose $k$ distinct $a$ in the field, $2\le k\le q$. Here $S$ consists of evaluation vectors of the affine polynomials $z_0+az_1$. The constant nonzero evaluations give $q-1$ full-support vectors. For each of $q-1$ nonzero slopes, exactly $q-k$ intercepts avoid a zero at a selected direction. The only proper space containing $t$ is its line. Consequently, + +```text +A = q+(q-1)^2, B_k = q^2+(q-1)^2(q+1-k), +p = (q-1) A^d / D_1, J_k = (q-1)(B_k^d-A^d) / D_2 . +``` + +The marginal is the rank-one-image formula. The formula for $J_k$ also extends algebraically to $k=1$ since $B_1=qA$; set $J_0=1$. At $k=2$ transpose the matrices and replace $G$ by $G^{-T}$, a bijection of complete headers. The marginal and pair formula recover Nick Petalas's prior results. The strict pair sign for every finite field is credited to ToikY. [PR #4227](https://github.com/CrocSwap/integer-mult-bounds/pull/4227) · [PR #4807](https://github.com/CrocSwap/integer-mult-bounds/pull/4807) · [PR #6703](https://github.com/CrocSwap/integer-mult-bounds/pull/6703) + +The probability of any specified exact pass mask with $j$ ones is +$\sum_{i=0}^{k-j}(-1)^i\binom{k-j}{i}J_{j+i}$ by inclusion-exclusion. For $1\le j= 3. +``` + +At $q=4,m=61$, exact integer comparison gives $J_{\rm ind,3}>p^3>J_3$. All three marginal and pair laws agree across these two families. Their common complete-header distribution does not determine a triple from its pair marginals. The precise integer ratio bounds are in RESULT.json. + +More generally $\lambda(S)>\lambda(L)$ for every proper $L$ in the interval. For fixed $S,q$, as $m\to\infty$, +$J_S\sim (q-1)q^{-1}[\lambda(S)/q^{r+1}]^d$. +For $S=\mathbb F_q^k$, the base equals $q^{-1}+(1-q^{-1})^{k+1}$. This is $\mathbb E[X^k]$ when $X=1$ with probability $1/q$, $X=1-1/q$ otherwise. For $k\ge2$ strict convexity gives $\mathbb E[X^k]>(\mathbb E[X])^k$. Thus independent rows eventually give a joint probability above $p^k$ for each fixed field and $k$. + +## A dimension-uniform lower bound and complete affine flats + +There is a simple event that passes **every** member of any normalized common-image family. If $G u$ is a nonzero multiple of the last coordinate vector, all proper leading blocks are identity. Uniform $G u$ therefore gives +$J_S\ge b_m=(q-1)/(q^m-1)$. Set $t_1=1-1/q+1/q^2$ and $c_m=(1-1/q)/(1-q^{-m})<1$. The marginal and this lower bound can be written as $p=c_m t_1^d$ and $b_m=c_m q^{-d}$. Consequently + +~~~text +if k >= 2 and t_1^k <= 1/q, then J_S >= b_m > p^k, for every m. +~~~ + +This sufficient size condition applies to arbitrary row dependencies. For $q=2$ it holds already at $k=3$, since $(3/4)^3<1/2$. With the prior distinct-pair result (or $p>p^2$ for identical events), this proves strict positivity for every binary normalized family of at least two guards. The same last-coordinate event holds under each uniform determinant stratum. + +In particular, consider **all** $q^{r-1}$ affine directions $(1,a_1,\ldots,a_{r-1})$ in rank $r$. For $r\ge3$, the inequality $t_1^{q^2}\le \exp(-(q-1))<1/q$ proves strict positivity for every field and every $m\ge r$. This contrasts with the rank-two full pencil, which is strictly below its product everywhere for $q\ge7$. + +The full flat also has a closed count. For any $L$ in the subspace interval, the only coefficient vectors with nonzero evaluations at every point are the $q-1$ nonzero constants: every nonconstant affine linear function on the complete space attains zero. Hence $h(L)=q-1$ throughout. Expand $(q^{\dim L}+(q-1)^2)^d$ by the binomial theorem and invert termwise as in the binary specialization. For $A_{r,j}=q^j\prod_{i=0}^{r-2}(q^j-q^i)$ at $j\ge r-1$ and $A_{r,j}=0$ otherwise, + +~~~text +J_flat = (q-1) sum_{j=r-1}^d binom(d,j) (q-1)^[2(d-j)] A_{r,j} / D_r . +~~~ + +At $m=r$ only $j=d$ remains, so $J_{\rm flat}=b_m$ exactly. For $r\ge3$, the mass of headers that send $u$ to the last axis alone strictly exceeds the independence prediction. AFFINE-PLANES.json checks all subfamilies at rank three, including this equality for the full flat. + +## A restricted distribution covered by the count + +For any nonzero determinant $z$, left multiplication of a header by $H=\mathrm{diag}(z,1,\ldots,1)$ moves it bijectively to the corresponding determinant stratum. Each conjugated leading block is then diagonally similar to its original, so its determinant is identical. Hence **every named mask**, including for other projector families, has the same distribution in each uniform determinant stratum as under complete uniform $GL_m$. This covers uniform $SL_m$ and arbitrary mixtures of the uniform strata. Arbitrary restricted headers can behave differently. In the pencil with $u=e_1$, the identity fails every first minor, while a coordinate permutation sending $e_1$ last passes every proper minor. diff --git a/research/common-image-guard-pencils/README.md b/research/common-image-guard-pencils/README.md new file mode 100644 index 0000000000..b6dd8e688f --- /dev/null +++ b/research/common-image-guard-pencils/README.md @@ -0,0 +1,43 @@ +# When positive guard pairs give a below-product joint probability + +On one uniform invertible header, consider the full proper-minor tests for corank-one complements sharing an image direction in their rank-one kernels. Nick Petalas derived the marginal and pair laws. ToikY proved the binary independent-family law and the strict positive sign for every pair over any finite field. This package answers the nonbinary question left by PR #6701, including families of linearly dependent covectors. [PR #4227](https://github.com/CrocSwap/integer-mult-bounds/pull/4227) · [PR #4807](https://github.com/CrocSwap/integer-mult-bounds/pull/4807) · [PR #6701](https://github.com/CrocSwap/integer-mult-bounds/pull/6701) · [PR #6703](https://github.com/CrocSwap/integer-mult-bounds/pull/6703) + +In the smallest example here with five guards, take the rows `(1,a)` for all five field elements, common column `(1,0)^T`, and headers in `GL_2(F_5)`. Of the 480 headers, **336 pass each named guard, 272 pass each named pair, but only 80 pass all five**. Thus every pair beats independence, while all five pass with probability `1/6 < (7/10)^5`. Every proper subfamily of size two through four beats its product. The outcome depends on the header dimension too. For these five directions the joint probability beats the product exactly in dimensions three and four. + +| Result | Evidence | +| --- | --- | +| Exact joint law for any fixed space of row dependencies over a finite field, and its specialization to an affine pencil | [Counting proof](PROOF.md) | +| Four is the smallest field order allowing any below-product common-image family; every larger field has an eventual triple counterexample | [Sharp field-size boundary](SMALL-FIELDS.md) · [Ternary certificates](TERNARY-FOUR.json) | +| Full pencil over every field, all dimension windows, and size and dimension scaling | [Sign proof](SIGN.md) · [232 exact windows](SIGN-WINDOWS.json) · [Scaling examples](ASYMPTOTICS.json) | +| Same marginals and all pairs, opposite triple signs at field order four and dimension 61 | [Exact results](RESULT.json) | +| Independent triples beat the product over every field and dimension; a negative triple must be three distinct collinear directions | [Triple proof](TRIPLES.md) · [17 exceptions to the sufficient bound, checked exactly](TRIPLE-CERTIFICATES.json) | +| Every binary common-image family of at least two guards beats its product; complete affine flats of rank at least three do so over all fields | [Last-coordinate bound](PROOF.md) · [Full-flat checks](FULL-FLATS.json) | +| Every named mask has the same law in each uniform determinant class, including uniform special-linear headers | [Counting proof](PROOF.md) · [Literal checks](LITERAL-GL.json) | +| Complete matches for every subset of all normalized covectors in dimension three over the fields of orders two, three and four | [Affine-plane census](AFFINE-PLANES.json) | + +One practical consequence concerns estimates for a caller that batches several tests on the same header. Even knowing every pair exactly leaves room for the all-pass probability to fall on the opposite side of the independence prediction. A physical caller, its price, an improved multiplication bound and a formal proof-kernel check are outside this result. + +## Reproduce + +With Python 3.12 from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/common-image-guard-pencils +``` + +For the literal five-direction counterexample alone, run from the package directory: + +```sh +python3.12 -I -W error -B verify.py --controls +``` + +[Validation](VALIDATION.md) describes the finite domains and rejection controls. [Source provenance](SOURCES.json) pins the original and retained predecessor objects. [Overlap search](OVERLAP.json) identifies related work and the limits of the search. + +## Open next questions + +1. Do four or more independent normalized covectors beat independence in **every** dimension? The last-coordinate bound covers large families and the sampling argument resolves triples. Between these regimes the cost of conditioning on a full affine frame still needs control. +2. Under uniform monomial headers, how does the size cutoff depend on the initial tuple? Start with several nonzero coordinates in the common image vector and enumerate permutations. The determinant-stratum symmetry alone does not identify that distribution. + +## Credit + +Prepared by SHIN09-git with substantial OpenAI Codex assistance, including the different counting implementations. The retained source notices credit ToikY and Nick Petalas. New material is Apache-2.0. [Attribution](NOTICE) diff --git a/research/common-image-guard-pencils/RESULT.json b/research/common-image-guard-pencils/RESULT.json new file mode 100644 index 0000000000..422608157f --- /dev/null +++ b/research/common-image-guard-pencils/RESULT.json @@ -0,0 +1,957 @@ +{ + "five_direction_GL2_F5": [ + "7/10", + "17/30", + "13/30", + "3/10", + "1/6" + ], + "opposite_triples_q4_m61": { + "independent_floor_1e8": 4670390039, + "pencil_floor_1e8": 99909668 + }, + "finite_formula_checks": { + "pencils": 248, + "binary": 28, + "triples": 42, + "patterns": 668 + }, + "raw_prefix_cases": [ + { + "q": 2, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "rank": 2, + "passing_tuples": 2, + "orbit": 6 + }, + { + "q": 2, + "m": 3, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "rank": 2, + "passing_tuples": 16, + "orbit": 84 + }, + { + "q": 2, + "m": 6, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "rank": 2, + "passing_tuples": 2882, + "orbit": 62496 + }, + { + "q": 2, + "m": 3, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "rank": 3, + "passing_tuples": 24, + "orbit": 168 + }, + { + "q": 2, + "m": 4, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "rank": 3, + "passing_tuples": 408, + "orbit": 5040 + }, + { + "q": 2, + "m": 6, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "rank": 3, + "passing_tuples": 50160, + "orbit": 1874880 + }, + { + "q": 2, + "m": 3, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 0, + 0 + ] + ], + "rank": 3, + "passing_tuples": 24, + "orbit": 168 + }, + { + "q": 2, + "m": 4, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 0, + 0 + ] + ], + "rank": 3, + "passing_tuples": 408, + "orbit": 5040 + }, + { + "q": 2, + "m": 6, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 0, + 0 + ] + ], + "rank": 3, + "passing_tuples": 50160, + "orbit": 1874880 + }, + { + "q": 3, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ] + ], + "rank": 2, + "passing_tuples": 12, + "orbit": 48 + }, + { + "q": 3, + "m": 3, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ] + ], + "rank": 2, + "passing_tuples": 240, + "orbit": 1872 + }, + { + "q": 3, + "m": 6, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ] + ], + "rank": 2, + "passing_tuples": 708972, + "orbit": 42810768 + }, + { + "q": 3, + "m": 3, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "rank": 3, + "passing_tuples": 1920, + "orbit": 11232 + }, + { + "q": 3, + "m": 4, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "rank": 3, + "passing_tuples": 127200, + "orbit": 1347840 + }, + { + "q": 3, + "m": 6, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "rank": 3, + "passing_tuples": 284856000, + "orbit": 10274584320 + }, + { + "q": 3, + "m": 3, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 0, + 0 + ] + ], + "rank": 3, + "passing_tuples": 1504, + "orbit": 11232 + }, + { + "q": 3, + "m": 4, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 0, + 0 + ] + ], + "rank": 3, + "passing_tuples": 92256, + "orbit": 1347840 + }, + { + "q": 3, + "m": 6, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 0, + 0 + ] + ], + "rank": 3, + "passing_tuples": 173384640, + "orbit": 10274584320 + }, + { + "q": 4, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 36, + "orbit": 180 + }, + { + "q": 4, + "m": 3, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 1368, + "orbit": 15120 + }, + { + "q": 4, + "m": 6, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 28182996, + "orbit": 4289725440 + }, + { + "q": 4, + "m": 3, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "rank": 3, + "passing_tuples": 41526, + "orbit": 181440 + }, + { + "q": 4, + "m": 4, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "rank": 3, + "passing_tuples": 8220852, + "orbit": 61689600 + }, + { + "q": 4, + "m": 6, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "rank": 3, + "passing_tuples": 190700788860, + "orbit": 4375519948800 + }, + { + "q": 4, + "m": 3, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 0, + 0 + ] + ], + "rank": 3, + "passing_tuples": 30024, + "orbit": 181440 + }, + { + "q": 4, + "m": 4, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 0, + 0 + ] + ], + "rank": 3, + "passing_tuples": 5362200, + "orbit": 61689600 + }, + { + "q": 4, + "m": 6, + "forms": [ + [ + 1, + 0, + 0 + ], + [ + 1, + 1, + 0 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 0, + 0 + ] + ], + "rank": 3, + "passing_tuples": 97737894000, + "orbit": 4375519948800 + }, + { + "q": 5, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 144, + "orbit": 480 + }, + { + "q": 5, + "m": 3, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 11232, + "orbit": 74400 + }, + { + "q": 5, + "m": 6, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 2390431824, + "orbit": 152529300000 + }, + { + "q": 8, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 1764, + "orbit": 3528 + }, + { + "q": 8, + "m": 3, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 645624, + "orbit": 2060352 + }, + { + "q": 8, + "m": 6, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 19715040159444, + "orbit": 281465313067008 + }, + { + "q": 9, + "m": 2, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 3136, + "orbit": 5760 + }, + { + "q": 9, + "m": 3, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 1687168, + "orbit": 4717440 + }, + { + "q": 9, + "m": 6, + "forms": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "rank": 2, + "passing_tuples": 173905507752256, + "orbit": 1852985321066880 + } + ] +} diff --git a/research/common-image-guard-pencils/SIGN-WINDOWS.json b/research/common-image-guard-pencils/SIGN-WINDOWS.json new file mode 100644 index 0000000000..684e4bd97d --- /dev/null +++ b/research/common-image-guard-pencils/SIGN-WINDOWS.json @@ -0,0 +1,1574 @@ +{ + "windows": { + "2,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "3,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "3,3": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "4,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "4,3": { + "positive": [ + 2, + 60 + ], + "ties": [] + }, + "4,4": { + "positive": [ + 2, + 8 + ], + "ties": [] + }, + "5,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "5,3": { + "positive": [ + 2, + 31 + ], + "ties": [] + }, + "5,4": { + "positive": [ + 2, + 8 + ], + "ties": [] + }, + "5,5": { + "positive": [ + 3, + 4 + ], + "ties": [] + }, + "7,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "7,3": { + "positive": [ + 2, + 26 + ], + "ties": [] + }, + "7,4": { + "positive": [ + 2, + 9 + ], + "ties": [] + }, + "7,5": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "7,6": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "7,7": { + "positive": [], + "ties": [] + }, + "8,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "8,3": { + "positive": [ + 2, + 26 + ], + "ties": [] + }, + "8,4": { + "positive": [ + 2, + 10 + ], + "ties": [] + }, + "8,5": { + "positive": [ + 2, + 6 + ], + "ties": [] + }, + "8,6": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "8,7": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "8,8": { + "positive": [], + "ties": [] + }, + "9,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "9,3": { + "positive": [ + 2, + 28 + ], + "ties": [] + }, + "9,4": { + "positive": [ + 2, + 11 + ], + "ties": [] + }, + "9,5": { + "positive": [ + 2, + 7 + ], + "ties": [] + }, + "9,6": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "9,7": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "9,8": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "9,9": { + "positive": [], + "ties": [] + }, + "11,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "11,3": { + "positive": [ + 2, + 30 + ], + "ties": [] + }, + "11,4": { + "positive": [ + 2, + 13 + ], + "ties": [] + }, + "11,5": { + "positive": [ + 2, + 8 + ], + "ties": [] + }, + "11,6": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "11,7": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "11,8": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "11,9": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "11,10": { + "positive": [], + "ties": [] + }, + "11,11": { + "positive": [], + "ties": [] + }, + "13,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "13,3": { + "positive": [ + 2, + 34 + ], + "ties": [] + }, + "13,4": { + "positive": [ + 2, + 15 + ], + "ties": [] + }, + "13,5": { + "positive": [ + 2, + 9 + ], + "ties": [] + }, + "13,6": { + "positive": [ + 2, + 6 + ], + "ties": [] + }, + "13,7": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "13,8": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "13,9": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "13,10": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "13,11": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "13,12": { + "positive": [], + "ties": [] + }, + "13,13": { + "positive": [], + "ties": [] + }, + "16,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "16,3": { + "positive": [ + 2, + 39 + ], + "ties": [] + }, + "16,4": { + "positive": [ + 2, + 18 + ], + "ties": [] + }, + "16,5": { + "positive": [ + 2, + 11 + ], + "ties": [] + }, + "16,6": { + "positive": [ + 2, + 8 + ], + "ties": [] + }, + "16,7": { + "positive": [ + 2, + 6 + ], + "ties": [] + }, + "16,8": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "16,9": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "16,10": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "16,11": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "16,12": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "16,13": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "16,14": { + "positive": [], + "ties": [] + }, + "16,15": { + "positive": [], + "ties": [] + }, + "16,16": { + "positive": [], + "ties": [] + }, + "17,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "17,3": { + "positive": [ + 2, + 41 + ], + "ties": [] + }, + "17,4": { + "positive": [ + 2, + 19 + ], + "ties": [] + }, + "17,5": { + "positive": [ + 2, + 12 + ], + "ties": [] + }, + "17,6": { + "positive": [ + 2, + 8 + ], + "ties": [] + }, + "17,7": { + "positive": [ + 2, + 7 + ], + "ties": [] + }, + "17,8": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "17,9": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "17,10": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "17,11": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "17,12": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "17,13": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "17,14": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "17,15": { + "positive": [], + "ties": [] + }, + "17,16": { + "positive": [], + "ties": [] + }, + "17,17": { + "positive": [], + "ties": [] + }, + "19,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "19,3": { + "positive": [ + 2, + 45 + ], + "ties": [] + }, + "19,4": { + "positive": [ + 2, + 21 + ], + "ties": [] + }, + "19,5": { + "positive": [ + 2, + 13 + ], + "ties": [] + }, + "19,6": { + "positive": [ + 2, + 9 + ], + "ties": [] + }, + "19,7": { + "positive": [ + 2, + 7 + ], + "ties": [] + }, + "19,8": { + "positive": [ + 2, + 6 + ], + "ties": [] + }, + "19,9": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "19,10": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "19,11": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "19,12": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "19,13": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "19,14": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "19,15": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "19,16": { + "positive": [], + "ties": [] + }, + "19,17": { + "positive": [], + "ties": [] + }, + "19,18": { + "positive": [], + "ties": [] + }, + "19,19": { + "positive": [], + "ties": [] + }, + "23,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "23,3": { + "positive": [ + 2, + 53 + ], + "ties": [] + }, + "23,4": { + "positive": [ + 2, + 25 + ], + "ties": [] + }, + "23,5": { + "positive": [ + 2, + 16 + ], + "ties": [] + }, + "23,6": { + "positive": [ + 2, + 11 + ], + "ties": [] + }, + "23,7": { + "positive": [ + 2, + 9 + ], + "ties": [] + }, + "23,8": { + "positive": [ + 2, + 7 + ], + "ties": [] + }, + "23,9": { + "positive": [ + 2, + 6 + ], + "ties": [] + }, + "23,10": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "23,11": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "23,12": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "23,13": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "23,14": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "23,15": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "23,16": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "23,17": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "23,18": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "23,19": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "23,20": { + "positive": [], + "ties": [] + }, + "23,21": { + "positive": [], + "ties": [] + }, + "23,22": { + "positive": [], + "ties": [] + }, + "23,23": { + "positive": [], + "ties": [] + }, + "25,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "25,3": { + "positive": [ + 2, + 57 + ], + "ties": [] + }, + "25,4": { + "positive": [ + 2, + 27 + ], + "ties": [] + }, + "25,5": { + "positive": [ + 2, + 17 + ], + "ties": [] + }, + "25,6": { + "positive": [ + 2, + 12 + ], + "ties": [] + }, + "25,7": { + "positive": [ + 2, + 10 + ], + "ties": [] + }, + "25,8": { + "positive": [ + 2, + 8 + ], + "ties": [] + }, + "25,9": { + "positive": [ + 2, + 7 + ], + "ties": [] + }, + "25,10": { + "positive": [ + 2, + 6 + ], + "ties": [] + }, + "25,11": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "25,12": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "25,13": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "25,14": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "25,15": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "25,16": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "25,17": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "25,18": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "25,19": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "25,20": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "25,21": { + "positive": [], + "ties": [] + }, + "25,22": { + "positive": [], + "ties": [] + }, + "25,23": { + "positive": [], + "ties": [] + }, + "25,24": { + "positive": [], + "ties": [] + }, + "25,25": { + "positive": [], + "ties": [] + }, + "27,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "27,3": { + "positive": [ + 2, + 60 + ], + "ties": [] + }, + "27,4": { + "positive": [ + 2, + 29 + ], + "ties": [] + }, + "27,5": { + "positive": [ + 2, + 18 + ], + "ties": [] + }, + "27,6": { + "positive": [ + 2, + 13 + ], + "ties": [] + }, + "27,7": { + "positive": [ + 2, + 11 + ], + "ties": [] + }, + "27,8": { + "positive": [ + 2, + 9 + ], + "ties": [] + }, + "27,9": { + "positive": [ + 2, + 7 + ], + "ties": [] + }, + "27,10": { + "positive": [ + 2, + 6 + ], + "ties": [] + }, + "27,11": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "27,12": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "27,13": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "27,14": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "27,15": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "27,16": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "27,17": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "27,18": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "27,19": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "27,20": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "27,21": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "27,22": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "27,23": { + "positive": [], + "ties": [] + }, + "27,24": { + "positive": [], + "ties": [] + }, + "27,25": { + "positive": [], + "ties": [] + }, + "27,26": { + "positive": [], + "ties": [] + }, + "27,27": { + "positive": [], + "ties": [] + }, + "29,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "29,3": { + "positive": [ + 2, + 64 + ], + "ties": [] + }, + "29,4": { + "positive": [ + 2, + 30 + ], + "ties": [] + }, + "29,5": { + "positive": [ + 2, + 20 + ], + "ties": [] + }, + "29,6": { + "positive": [ + 2, + 14 + ], + "ties": [] + }, + "29,7": { + "positive": [ + 2, + 11 + ], + "ties": [] + }, + "29,8": { + "positive": [ + 2, + 9 + ], + "ties": [] + }, + "29,9": { + "positive": [ + 2, + 8 + ], + "ties": [] + }, + "29,10": { + "positive": [ + 2, + 7 + ], + "ties": [] + }, + "29,11": { + "positive": [ + 2, + 6 + ], + "ties": [] + }, + "29,12": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "29,13": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "29,14": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "29,15": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "29,16": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "29,17": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "29,18": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "29,19": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "29,20": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "29,21": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "29,22": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "29,23": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "29,24": { + "positive": [], + "ties": [] + }, + "29,25": { + "positive": [], + "ties": [] + }, + "29,26": { + "positive": [], + "ties": [] + }, + "29,27": { + "positive": [], + "ties": [] + }, + "29,28": { + "positive": [], + "ties": [] + }, + "29,29": { + "positive": [], + "ties": [] + }, + "31,2": { + "positive": [ + 2, + null + ], + "ties": [] + }, + "31,3": { + "positive": [ + 2, + 68 + ], + "ties": [] + }, + "31,4": { + "positive": [ + 2, + 32 + ], + "ties": [] + }, + "31,5": { + "positive": [ + 2, + 21 + ], + "ties": [] + }, + "31,6": { + "positive": [ + 2, + 15 + ], + "ties": [] + }, + "31,7": { + "positive": [ + 2, + 12 + ], + "ties": [] + }, + "31,8": { + "positive": [ + 2, + 10 + ], + "ties": [] + }, + "31,9": { + "positive": [ + 2, + 8 + ], + "ties": [] + }, + "31,10": { + "positive": [ + 2, + 7 + ], + "ties": [] + }, + "31,11": { + "positive": [ + 2, + 6 + ], + "ties": [] + }, + "31,12": { + "positive": [ + 2, + 6 + ], + "ties": [] + }, + "31,13": { + "positive": [ + 2, + 5 + ], + "ties": [] + }, + "31,14": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "31,15": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "31,16": { + "positive": [ + 2, + 4 + ], + "ties": [] + }, + "31,17": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "31,18": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "31,19": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "31,20": { + "positive": [ + 2, + 3 + ], + "ties": [] + }, + "31,21": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "31,22": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "31,23": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "31,24": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "31,25": { + "positive": [ + 2, + 2 + ], + "ties": [] + }, + "31,26": { + "positive": [], + "ties": [] + }, + "31,27": { + "positive": [], + "ties": [] + }, + "31,28": { + "positive": [], + "ties": [] + }, + "31,29": { + "positive": [], + "ties": [] + }, + "31,30": { + "positive": [], + "ties": [] + }, + "31,31": { + "positive": [], + "ties": [] + } + }, + "finite_comparisons": 18560, + "boundary_certificates": [ + { + "q": 4, + "k": 3, + "m": 2, + "floor_1e8_ratio": 127446517 + }, + { + "q": 4, + "k": 3, + "m": 60, + "floor_1e8_ratio": 100873870 + }, + { + "q": 4, + "k": 3, + "m": 61, + "floor_1e8_ratio": 99909668 + }, + { + "q": 4, + "k": 4, + "m": 2, + "floor_1e8_ratio": 112040894 + }, + { + "q": 4, + "k": 4, + "m": 8, + "floor_1e8_ratio": 109043745 + }, + { + "q": 4, + "k": 4, + "m": 9, + "floor_1e8_ratio": 98225073 + }, + { + "q": 5, + "k": 5, + "m": 2, + "floor_1e8_ratio": 99165030 + }, + { + "q": 5, + "k": 5, + "m": 3, + "floor_1e8_ratio": 111744023 + }, + { + "q": 5, + "k": 5, + "m": 4, + "floor_1e8_ratio": 102119948 + }, + { + "q": 5, + "k": 5, + "m": 5, + "floor_1e8_ratio": 86044038 + }, + { + "q": 7, + "k": 7, + "m": 2, + "floor_1e8_ratio": 79423132 + }, + { + "q": 7, + "k": 7, + "m": 3, + "floor_1e8_ratio": 71959023 + } + ] +} diff --git a/research/common-image-guard-pencils/SIGN.md b/research/common-image-guard-pencils/SIGN.md new file mode 100644 index 0000000000..2211510214 --- /dev/null +++ b/research/common-image-guard-pencils/SIGN.md @@ -0,0 +1,84 @@ +# When the joint probability crosses the product of the marginals + +Let $R_d=J_k/p^k$, with $d=m-1$ and $2\le k\le q$. Positive and negative below mean $R_d>1$ and $R_d<1$ respectively. In particular they compare the probability of **all** guards passing with the independence prediction. They do not describe the sign of an arbitrary higher cumulant. + +## Shape in the header dimension + +Put $x=1/q$, $s=A/B_k$, $\theta_1=A/q^2$, $\theta_k=B_k/q^3$, and $T=\theta_k/\theta_1^k$. The pencil formula gives + +~~~text +R_d = (1-x)^(1-k) T^d (1-x^(d+1))^(k-1) (1-s^d)/(1-x^d). +~~~ + +Here $x0$. Its logarithm is strictly concave. To see this, write $f_a(d)=\log(1-e^{-ad})$ for $a>0$. Then +$f'_a=a/(e^{ad}-1)$ and $f''_a=-[a/(2\sinh(ad/2))]^2$. For each fixed $d>0$, both $f'_a$ and $|f''_a|$ strictly decrease in $a$. This follows from the strictly increasing functions $(e^z-1)/z$ and $\sinh(z)/z$. Thus $f_{-\log s}-f_{-\log x}$ is strictly increasing and strictly concave. The remaining correction $(k-1)f_{-\log x}(d+1)$ is also increasing and strictly concave. The affine term $d\log T$ preserves strict concavity. + +In particular the consecutive ratios $R_{d+1}/R_d$ strictly decrease and tend to $T$. The positive integer dimensions form one interval, possibly empty or infinite. The correction to $T^d$ is increasing. Thus if $T\ge1$ and $R_1>1$, every dimension is positive. + +## Which pencils eventually fall below the product? + +We have $\theta_1=1-x+x^2$ and $\theta_k=\theta_1-(k-1)x(1-x)^2$. Factoring the difference gives + +~~~text +theta_k - theta_1^k + = x(1-x) [sum_{i=1}^{k-1} theta_1^i - (k-1)(1-x)]. +~~~ + +The average of the powers inside the sum strictly decreases with $k$. At $k=2$ it exceeds $1-x$. At $k=3$ twice the difference of the average from $1-x$ is $x(-1+4x-2x^2+x^3)$. This is strictly negative for $0(7/12)^3$ and $T>1$, so the sign is positive for all dimensions. Every pair is positive by the credited all-field pair theorem. [PR #6703](https://github.com/CrocSwap/integer-mult-bounds/pull/6703) + +At $q=4,k=3$ the exact positive dimensions are $2\le m\le60$; every $m\ge61$ is negative. At $q=k=5$ the only positive dimensions are $m=3,4$. At dimension two every proper subfamily with at least two members lies above its product, yet all five together lie below theirs. For instance the joint probabilities for subsets of sizes one through five are $7/10,17/30,13/30,3/10,1/6$. The inequalities are strict. Certify the endpoints by integer division: $\lfloor 10^8 R_{m-1}\rfloor$ is 127446517, 100873870, 99909668 at $(q,k,m)=(4,3,2),(4,3,60),(4,3,61)$, and 99165030, 111744023, 102119948, 86044038 at $(5,5,m)$ for $m=2,3,4,5$. Strict concavity fills the interval between positive endpoints, and a decreasing adjacent ratio at a crossing precludes a later return. + +## A complete sign classification for the full pencil + +| Field order $q$, with $k=q$ | Dimensions $m\ge2$ with $J_q>p^q$ | +| --- | --- | +| 2 or 3 | All | +| 4 | 2 through 8 | +| 5 | 3 and 4 | +| Every prime power $q\ge7$ | None | + +Every other dimension in this table has a strict negative sign. For the four-element case the scaled ratio floors at $m=2,8,9$ are 112040894, 109043745, 98225073. The five-element case was certified above. + +For $q\ge7$, first consider $m=2$. The full pencil has $J_q=1/(q+1)$ and $p=(1-x+x^2)/(1+x)$. The bounds $1-x+x^2\ge e^{-x}$ and $1+x\le e^x$ give $p^q\ge e^{-2}>1/(q+1)$ because $e^2<8$. To rule out a later positive window it suffices by strict concavity to prove $R_2/R_1<1$. Direct cancellation gives + +~~~text +R_2/R_1 = [(3q^2-3q+2)/(q(q^2+q+1))] + [1+(q^2+q-1)/(q^3+1)]^q. +~~~ + +The first factor is at most $3/(q+2)$ by multiplication. The second is less than $\exp(1+1/q)$ by $\log(1+y)\le y$. For $q\ge8$ their product is at most $(3/10)\exp(9/8)<1$; one elementary bound is $e<11/4$ and $\exp(1/8)\le8/7$. At $q=7$ the floors of $10^8R_1$ and $10^8R_2$ are 79423132 and 71959023. This proves the last row for every dimension. + +## Fixed family size as the field grows + +Fix $k\ge3$ and let $q$ grow through prime powers. The finite upper endpoint $m_*(q,k)$ of the positive interval exists for all sufficiently large $q$, and + +~~~text +m_*(q,k)/q -> 2/(k-2). +~~~ + +Indeed $\theta_k=1-kx+(2k-1)x^2-(k-1)x^3$, so $\log T=-(k-1)(k-2)x^2/2+O_k(x^3)$. If $d/q\to c>0$, then $s=O_k(1/q)$ and the logarithms of all three factors involving $s^d,x^d,x^{d+1}$ are $o(1/q)$. Therefore +$q\log R_d\to(k-1)-c(k-1)(k-2)/2$. Choose $c$ just below and just above $2/(k-2)$. The two strict opposite signs, together with concavity, trap the upper crossing and prove the limit. This fixed-$k$ limit has a different regime from the full-pencil table. + +SIGN-WINDOWS.json contains exact interval certificates for each pencil size at the listed prime-power orders through 31. The program first locates the peak by decreasing adjacent ratios, then bisects both boundaries. A separate bounded scan checks these intervals on $2\le m\le81$. The all-dimension conclusions above use the proof of strict concavity and the exact input ratios. + +## How many guards can be bundled at a fixed dimension? + +Hold $q,m$ fixed. The formula with $B_1=qA$ allows $k$ to vary continuously from $1$ to $q$. Apart from a constant and the affine term $-k\log p$, the logarithm of the ratio is $\log(B_k^d-A^d)$. Its second derivative with respect to $B=B_k$ is + +~~~text +-d B^(d-2) [B^d+(d-1)A^d] / (B^d-A^d)^2 < 0. +~~~ + +As $B_k$ decreases linearly in $k$, the ratio is strictly log-concave in family size too. It equals one at size one and is strictly larger at size two. At each fixed dimension there is thus a unique largest size $K(q,m)$ above the independence prediction. All sizes from two to $K(q,m)$ lie above it; a possible tie can only occur at $K+1$. Equivalently, the conditional probability $J_{k+1}/J_k$ of the next specified guard passing, given that all earlier ones pass, strictly decreases for $k\ge1$ while the next direction exists. This comparison begins after conditioning on at least one pass. + +For fixed $d=m-1\ge1$, as $q\to\infty$, +$K(q,m)/q\to\alpha_d$, the unique strictly positive root in $(0,1)$ of +$d\log(1-\alpha)+(d+1)\alpha=0$. Indeed for $k/q\to\alpha\in(0,1)$ the exact formulas give $J_k\to(1-\alpha)^d$ and $p^k\to\exp(-(d+1)\alpha)$, since $p=1-(d+1)/q+O_d(q^{-2})$. The limiting log ratio is strictly concave, has derivative one at zero, and tends to minus infinity at one. Two values bracketing its positive root, together with the single size cutoff, prove the stated limit. + +There is a joint scaling window as well. Suppose $k\to\infty$, $k/q\to0$, and $d k/q\to c>0$. Then $d\to\infty$ and + +~~~text +(q/k) log R_d -> 1-c/2. +~~~ + +In fact the expansion from the previous section has remainder $O(k^3/q^3)$ uniformly when $k/q$ is small: expand the two logarithms at $1$, using $|\theta_k-1|=O(k/q)$. The constant factor contributes $(k-1)/q+O(k/q^2)$ to the log ratio. Multiplying the quadratic term by $d$ supplies $-d(k-1)(k-2)/(2q^2)$; the multiplied remainder is $o(k/q)$. Also $s=O(1/q)$ along this scaling, so the three finite-power corrections are $o(k/q)$. In particular dimensions on either side of $dk/q=2$ have opposite eventual signs when bounded away from two. ASYMPTOTICS.json records finite bracketing examples for both endpoints and for $k$ near the square root of the field order. diff --git a/research/common-image-guard-pencils/SMALL-FIELDS.md b/research/common-image-guard-pencils/SMALL-FIELDS.md new file mode 100644 index 0000000000..4a30b7d08c --- /dev/null +++ b/research/common-image-guard-pencils/SMALL-FIELDS.md @@ -0,0 +1,28 @@ +# The first possible field order is four + +Over the fields of orders two and three, **every** normalized common-image family of at least two guards satisfies $J>p^k$ in every allowed dimension. Over every field of order at least four there is a three-direction pencil with $J0$ and $1-P_I\le(q+1)/Q$. Conditioning on $I$ gives exactly the uniform rank-three tuple orbit in PROOF.md. + +Let $z(u')$ be the single-row pass probability at fixed $u'$. Its mean is $p$. It vanishes unless $u'_m\ne0$, an event with probability $c=(1-1/q)/(1-q^{-m})$. In the enlarged space the joint probability is $T=\mathbb E[z^3]\ge p^3/c^2$ by conditional Jensen. In the independent-row orbit, +$P_I J_{\mathrm{ind},3}\ge T-(1-P_I)$. Consequently $T-p^3>1-P_I$ suffices. Here $c^{-1}=1+q^{-1}+\cdots+q^{-d}$, giving $c^{-2}-1\ge2/q$. Writing $t_1=1-1/q+1/q^2$ gives $p=c\,t_1^d>(1-1/q)t_1^d$. A sufficient **integer-checkable** inequality is therefore + +~~~text +L(q,d) = (2/q)(1-1/q)^3 (q t_1^3)^d > q+1. +~~~ + +For $q\ge3$ the base $q t_1^3>1$: at $q=3$ it equals $343/243$; at $q\ge4$ it exceeds $q(3/4)^3>1$. Thus once this condition holds it continues to hold as the dimension grows. + +## A uniform tail and finite certificates + +For every $q\ge19$ already at $d=2$, +$L(q,2)>2q(1-1/q)^9\ge2q-18\ge q+1$, using Bernoulli's inequality. For $q=2$ the last-coordinate bound in PROOF.md already gives strict positivity at family size three. + +For the remaining prime powers, the table gives the first $d_0\ge2$ certified by $L(q,d)>q+1$. Below it the four-term independent-triple formula gives the listed **minimum** floor of $10^6J_{\mathrm{ind},3}/p^3$ over $2\le d= 0 for v in cells) and sum(comb(k, j)*v + for j, v in enumerate(cells)) == 1, "pattern normalization") + require(all((cells[j] > 0) == (k - j <= m - 1) for j in range(1, k + 1)), + "support of nonempty passing masks") + checks["patterns"] += len(cells) + for m in range(3, 9): + require(joint(f, independent(3), m) == independent_triple(q, m), + "independent triple specialization") + checks["triples"] += 1 + f = Field(2) + for k in range(1, 7): + for m in sorted({max(2, k), max(2, k + 1), 7, 10, 16}): + if m >= k: + require(joint(f, independent(k), m) == binary_independent(k, m), + "binary predecessor specialization") + checks["binary"] += 1 + return checks + + +def prefix_rows(): + result = [] + for q in (2, 3, 4, 5, 8, 9): + f = Field(q) + families = [[(1, a) for a in range(min(q, 4))]] + if q <= 4: + families.append(independent(3)) + families.append([*independent(3), (1, 1, 1), independent(3)[0]]) + for forms in families: + rank = len(minimal_forms(f, forms)[0]) + for m in sorted({max(2, rank), max(3, rank + 1), 6}): + counted = prefix_count(f, forms, m) + require(counted == orbit_size(q, rank, m)*joint(f, forms, m), + "raw prefix DP vs lattice") + result.append(dict(q=q, m=m, forms=forms, rank=rank, + passing_tuples=counted, orbit=orbit_size(q, rank, m))) + return result + + +def sign_rows(): + q_values = (2, 3, 4, 5, 7, 8, 9, 11, 13, 16, 17, 19, 23, 25, 27, 29, 31) + windows = {} + comparisons = 0 + for q in q_values: + for k in range(2, q + 1): + w = sign_window(q, k) + span = w["positive"] + # An independent finite domain checks the infinite interval finder. + for m in range(2, 82): + positive = bool(span) and m >= span[0] and (span[1] is None or m <= span[1]) + expected = 1 if positive else (0 if m in w["ties"] else -1) + require(direction(q, k, m) == expected, "sign window vs finite scan") + comparisons += 1 + windows[f"{q},{k}"] = w + certs = [(4, 3, 2), (4, 3, 60), (4, 3, 61), (4, 4, 2), (4, 4, 8), + (4, 4, 9), (5, 5, 2), (5, 5, 3), (5, 5, 4), (5, 5, 5), + (7, 7, 2), (7, 7, 3)] + coeffs = [dict(q=q, k=k, m=m, floor_1e8_ratio=ratio_floor(q, k, m)) for q, k, m in certs] + return dict(windows=windows, finite_comparisons=comparisons, boundary_certificates=coeffs) + + +def scientific_result(): + controls() + a = independent_triple(4, 61)/marginal(4, 61)**3 + b = pencil(4, 3, 61)/marginal(4, 61)**3 + require(a > 1 > b, "same pair laws, opposite triple signs") + return dict(five_direction_GL2_F5=[str(pencil(5, k, 2)) for k in range(1, 6)], + opposite_triples_q4_m61=dict(independent_floor_1e8=a.numerator*10**8//a.denominator, + pencil_floor_1e8=b.numerator*10**8//b.denominator), + finite_formula_checks=formula_rows(), raw_prefix_cases=prefix_rows()) diff --git a/research/common-image-guard-pencils/dependency.py b/research/common-image-guard-pencils/dependency.py new file mode 100644 index 0000000000..2c6dad8585 --- /dev/null +++ b/research/common-image-guard-pencils/dependency.py @@ -0,0 +1,83 @@ +"""Lattice formula and an alternative direct prefix count for small fields.""" +from collections import Counter +from fractions import Fraction +from functools import lru_cache +from itertools import combinations + +from laws import orbit_size + + +def subspaces(field, width): + """Every RREF in a quotient of dimension width, once.""" + for dim in range(width + 1): + for cols in combinations(range(width), dim): + free = [(i, j) for i, pivot in enumerate(cols) + for j in range(pivot + 1, width) if j not in cols] + for values in field.vectors(len(free)): + rows = [[int(j == pivot) for j in range(width)] for pivot in cols] + for (i, j), value in zip(free, values): + rows[i][j] = value + yield tuple(tuple(row) for row in rows) + + +def minimal_forms(field, forms): + """Independent columns of the evaluation table span its actual image S.""" + if any(row[0] != 1 for row in forms): + raise ValueError("forms must take value one at e1") + pivots = [next(i for i, value in enumerate(row) if value) + for row in field.basis(forms)] + return tuple(tuple(row[i] for i in pivots) for row in forms) + + +def joint(field, forms, m): + if not forms: + return Fraction(1) + forms = minimal_forms(field, forms) + r, q = len(forms[0]), field.q + total = 0 + for basis in subspaces(field, r - 1): + dim = len(basis) + 1 + c = r - dim + vectors = [] + for coeff in field.vectors(dim - 1): + y = (0,)*(r - 1) + for scalar, row in zip(coeff, basis): + y = field.axpy(y, scalar, row) + vectors.extend((a, *y) for a in range(q)) + support = sum(all(field.dot(row, x) != 0 for row in forms) for x in vectors) + weight = q**dim + (q - 1)*support + mobius = (-1)**c * q**(c*(c - 1)//2) + total += mobius * weight**(m - 1) + return Fraction((q - 1)*total, orbit_size(q, r, m)) + + +def prefix_count(field, forms, m): + """Count correct-span pairs, retaining each prefix and quotient span. + + This path enumerates each raw coordinate/column choice. It uses no + torus counts, rank-subtraction weights, pencil law or lattice inversion. + """ + forms = minimal_forms(field, forms) + r, q = len(forms[0]), field.q + vectors = list(field.vectors(r)) + valid = {y for y in vectors if all(field.dot(row, y) != 1 for row in forms)} + + @lru_cache(None) + def branches(prefix, span): + next_counts = Counter() + for col in vectors: + enlarged = field.basis((*span, col[1:])) + for x in range(q): + y = field.axpy(prefix, x, col) + if y in valid: + next_counts[y, enlarged] += 1 + return next_counts + + states = {((0,)*r, ()): 1} + for _ in range(m - 1): + updates = Counter() + for (prefix, span), count in states.items(): + for state, ways in branches(prefix, span).items(): + updates[state] += count*ways + states = updates + return (q - 1)*sum(n for (_, span), n in states.items() if len(span) == r - 1) diff --git a/research/common-image-guard-pencils/finite.py b/research/common-image-guard-pencils/finite.py new file mode 100644 index 0000000000..b88d32f8ef --- /dev/null +++ b/research/common-image-guard-pencils/finite.py @@ -0,0 +1,68 @@ +"""Small explicit finite fields and exact row operations used by finite replays.""" +from itertools import product + + +class Field: + """Polynomial-basis digit encoding; field order and characteristic differ.""" + def __init__(self, q): + extensions = {4: (2, (1, 1)), 8: (2, (1, 1, 0)), 9: (3, (1, 0))} + if q in extensions: + p, modulus = extensions[q] + elif q in (2, 3, 5, 7): + p, modulus = q, (0,) + else: + raise ValueError("unimplemented arithmetic field") + self.q = q + degree = len(modulus) + coeff = [tuple((a // p**i) % p for i in range(degree)) for a in range(q)] + + def encode(values): + return sum((value % p)*p**i for i, value in enumerate(values)) + + def multiply(a, b): + word = [0] * (2*degree - 1) + for i in range(degree): + for j in range(degree): + word[i + j] += coeff[a][i] * coeff[b][j] + for i in range(len(word) - 1, degree - 1, -1): + for j, value in enumerate(modulus): + word[i - degree + j] -= word[i]*value + return encode(word[:degree]) + + self.add = [[encode([x + y for x, y in zip(coeff[a], coeff[b])]) + for b in range(q)] for a in range(q)] + self.mul = [[multiply(a, b) for b in range(q)] for a in range(q)] + self.neg = [self.add[a].index(0) for a in range(q)] + self.inv = [0] + [self.mul[a].index(1) for a in range(1, q)] + + def dot(self, a, b): + value = 0 + for x, y in zip(a, b): + value = self.add[value][self.mul[x][y]] + return value + + def vectors(self, width): + return product(range(self.q), repeat=width) + + def axpy(self, a, x, b): + return tuple(self.add[u][self.mul[x][v]] for u, v in zip(a, b)) + + def basis(self, rows): + """Canonical nonzero RREF rows, valid for the zero-dimensional quotient.""" + a = [list(row) for row in rows if any(row)] + if not a: + return () + i = 0 + for j in range(len(a[0])): + pivot = next((k for k in range(i, len(a)) if a[k][j]), None) + if pivot is None: + continue + a[i], a[pivot] = a[pivot], a[i] + a[i] = [self.mul[self.inv[a[i][j]]][v] for v in a[i]] + for k in range(len(a)): + if k != i and a[k][j]: + a[k] = list(self.axpy(a[k], self.neg[a[k][j]], a[i])) + i += 1 + if i == len(a): + break + return tuple(tuple(row) for row in a[:i]) diff --git a/research/common-image-guard-pencils/flat_check.py b/research/common-image-guard-pencils/flat_check.py new file mode 100644 index 0000000000..9eb84f27d4 --- /dev/null +++ b/research/common-image-guard-pencils/flat_check.py @@ -0,0 +1,34 @@ +"""Finite checks of the last-axis sufficient condition and full-flat formula.""" +from fractions import Fraction + +from dependency import joint +from finite import Field +from laws import full_flat, marginal, pencil, universal_positive_size + + +def flat_examples(): + matched = 0 + for q in (2, 3, 4, 5): + f = Field(q) + for r in range(2, 4): + forms = [(1, *x) for x in f.vectors(r - 1)] + for m in range(r, r + 4): + value = full_flat(q, r, m) + if value != joint(f, forms, m): + raise ValueError("complete flat vs lattice") + if r == 2 and value != pencil(q, q, m): + raise ValueError("complete line vs pencil") + if m == r and value != Fraction(q - 1, q**m - 1): + raise ValueError("last-axis equality at full rank") + matched += 1 + bounds = [] + for q in (2, 3, 4, 5, 7, 8, 9, 11, 13, 16, 17, 19, 23, 25, 27, 29, 31): + k = universal_positive_size(q) + t = Fraction(q*q - q + 1, q*q) + if not q*t**k <= 1 < q*t**(k - 1) or k > q*q: + raise ValueError("universal sufficient size boundary") + for m in (2, 3, 5, 10): + if Fraction(q - 1, q**m - 1) <= marginal(q, m)**k: + raise ValueError("last-axis strict inequality") + bounds.append(dict(q=q, first_size_certified_by_last_axis=k)) + return dict(full_flat_checks=matched, sufficient_sizes=bounds) diff --git a/research/common-image-guard-pencils/headers.py b/research/common-image-guard-pencils/headers.py new file mode 100644 index 0000000000..9e7fbb8fd9 --- /dev/null +++ b/research/common-image-guard-pencils/headers.py @@ -0,0 +1,80 @@ +"""Literal complete-header oracle, independent of the prefix counting proof.""" +import hashlib +from collections import Counter +from fractions import Fraction +from math import prod + +from finite import Field + + +def eliminate(field, square, inverse=False): + """Ordinary row elimination on an actual square matrix.""" + n = len(square) + a = [list(row) + ([int(i == j) for j in range(n)] if inverse else []) + for i, row in enumerate(square)] + det = 1 + for j in range(n): + pivot = next((i for i in range(j, n) if a[i][j]), None) + if pivot is None: + return 0, None + if pivot != j: + a[j], a[pivot] = a[pivot], a[j] + det = field.neg[det] + v = a[j][j] + det = field.mul[det][v] + a[j] = [field.mul[field.inv[v]][x] for x in a[j]] + for i in range(n): + if i != j and a[i][j]: + a[i] = list(field.axpy(a[i], field.neg[a[i][j]], a[j])) + return det, tuple(tuple(row[n:]) for row in a) if inverse else None + + +def matrix_product(field, left, right): + columns = list(zip(*right)) + return tuple(tuple(field.dot(row, col) for col in columns) for row in left) + + +def census(q, m, forms): + field = Field(q) + conjugands = [] + for form in forms: + row = (*form, *(0 for _ in range(m - len(form)))) + conjugands.append(tuple(tuple(field.add[int(i == j)][field.neg[row[j]] if i == 0 else 0] + for j in range(m)) for i in range(m))) + digest = hashlib.sha256() + masks = Counter() + strata = [Counter() for _ in range(q)] + for word in field.vectors(m*m): + header = tuple(tuple(word[i:i + m]) for i in range(0, m*m, m)) + det, inv = eliminate(field, header, inverse=True) + if not det: + continue + mask = 0 + for i, fixed in enumerate(conjugands): + actual = matrix_product(field, matrix_product(field, header, fixed), inv) + if all(eliminate(field, [row[:n] for row in actual[:n]])[0] + for n in range(1, m)): + mask |= 1 << i + masks[mask] += 1 + strata[det][mask] += 1 + digest.update(bytes((*word, det))) + digest.update(mask.to_bytes((len(forms) + 7)//8, "little")) + size = prod(q**m - q**j for j in range(m)) + if sum(masks.values()) != size: + raise ValueError("complete GL cardinality") + for det in range(1, q): + if any((q - 1)*strata[det][mask] != count for mask, count in masks.items()): + raise ValueError("determinant-conditioned histogram") + return dict(q=q, m=m, forms=forms, headers=size, determinant_classes=q - 1, + masks={str(mask): masks[mask] for mask in range(1 << len(forms)) if masks[mask]}, + word_det_mask_sha256=digest.hexdigest()) + + +def check_expected(row, probabilities): + masks = {int(i): n for i, n in row["masks"].items()} + k = len(row["forms"]) + for mask in range(1 << k): + observed = Fraction(sum(n for key, n in masks.items() if key & mask == mask), + row["headers"]) + if observed != probabilities(mask): + raise ValueError(f"literal named guard subset q={row['q']}, m={row['m']}, mask={mask}") diff --git a/research/common-image-guard-pencils/laws.py b/research/common-image-guard-pencils/laws.py new file mode 100644 index 0000000000..f2b35fad38 --- /dev/null +++ b/research/common-image-guard-pencils/laws.py @@ -0,0 +1,92 @@ +"""Closed probabilities and exact sign comparisons. No finite-field encoding needed.""" +from fractions import Fraction +from math import comb, prod + + +def orbit_size(q, rank, m): + """Number of pairs (u,V) with a given image S and Vu=t.""" + if not 1 <= rank <= m: + raise ValueError("rank outside header dimension") + d = m - 1 + return (q**m - 1) * q**d * prod(q**d - q**i for i in range(rank - 1)) + + +def marginal(q, m): + a = q + (q - 1)**2 + return Fraction((q - 1) * a**(m - 1), orbit_size(q, 1, m)) + + +def pencil(q, k, m): + if not 0 <= k <= q or m < 2: + raise ValueError("pencil size or header dimension") + if k == 0: + return Fraction(1) + if k == 1: + return marginal(q, m) + a = q + (q - 1)**2 + b = q*q + (q - 1)**2 * (q + 1 - k) + d = m - 1 + return Fraction((q - 1) * (b**d - a**d), orbit_size(q, 2, m)) + + +def independent_triple(q, m): + if m < 3: + raise ValueError("three independent covectors require m >= 3") + a = q + (q - 1)**2 + c = q**3 + (q - 1)**4 + b2 = q*q + (q - 1)**3 + b3 = q*q + (q - 1)**2 * (q - 2) + d = m - 1 + return Fraction((q - 1) * (c**d - 3*b2**d - (q - 2)*b3**d + q*a**d), + orbit_size(q, 3, m)) + + +def pattern(q, k, j, m): + """Exact probability of one named mask with j passes among k.""" + if not 0 <= j <= k: + raise ValueError("invalid pass count") + return sum((-1)**i * comb(k - j, i) * pencil(q, j + i, m) + for i in range(k - j + 1)) + + +def binary_independent(k, m): + """PR6701, formula (1). Independent predecessor specialization.""" + d = m - 1 + def count(j): + if j < k - 1: + return 0 + return 2**j * prod(2**j - 2**i for i in range(k - 1)) + return Fraction(sum(comb(d, j)*count(j) for j in range(d + 1)), + (2**m - 1)*count(d)) + + +def full_flat(q, r, m): + d = m - 1 + amount = sum(comb(d, j)*(q - 1)**(2*(d - j))*q**j * + prod(q**j - q**i for i in range(r - 1)) for j in range(r - 1, d + 1)) + return Fraction((q - 1)*amount, orbit_size(q, r, m)) + + +def universal_positive_size(q): + """First k guaranteed by the last-axis bound, not necessarily minimal.""" + a, b = q*q - q + 1, q*q + lo, hi = 1, 2 + while q*a**hi > b**hi: + hi *= 2 + while hi - lo > 1: + mid = (lo + hi)//2 + if q*a**mid <= b**mid: + hi = mid + else: + lo = mid + return hi + + +def direction(q, k, m): + delta = pencil(q, k, m) - marginal(q, m)**k + return (delta > 0) - (delta < 0) + + +def ratio_floor(q, k, m, scale=10**8): + value = pencil(q, k, m) / marginal(q, m)**k + return value.numerator * scale // value.denominator diff --git a/research/common-image-guard-pencils/literal_check.py b/research/common-image-guard-pencils/literal_check.py new file mode 100644 index 0000000000..6c16512314 --- /dev/null +++ b/research/common-image-guard-pencils/literal_check.py @@ -0,0 +1,62 @@ +"""Regenerate the complete literal GL histograms and their determinant slices.""" +import json +import sys +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +from dependency import joint +from finite import Field +from headers import census, check_expected +from laws import pattern + + +def independent(k): + return [(1, *(int(j == i) for j in range(1, k))) for i in range(k)] + + +def pencil_forms(q): + return [(1, a) for a in range(q)] + + +def experiments(large=False): + if large: + return [(4, 3, pencil_forms(4), "pencil")] + return ([(q, 2, pencil_forms(q), "pencil") for q in (2, 3, 4, 5, 7, 8, 9)] + + [(2, 3, independent(3), "independent"), (3, 3, pencil_forms(3), "pencil"), + (3, 3, independent(3), "independent"), (2, 4, independent(4), "independent"), + (3, 3, [(1, 0, 0), (1, 1, 0), (1, 2, 0), (1, 0, 1), (1, 1, 1)], "mixed")]) + + +def collect(large=False): + records = [] + for q, m, forms, name in experiments(large): + field = Field(q) + row = census(q, m, forms) + row["family"] = name + check_expected(row, lambda mask: joint(field, [f for i, f in enumerate(forms) + if mask & (1 << i)], m)) + if name == "pencil": + for mask in range(1 << len(forms)): + actual = row["masks"].get(str(mask), 0) + if row["headers"]*pattern(q, len(forms), mask.bit_count(), m) != actual: + raise ValueError("literal pencil mask vs inclusion-exclusion") + records.append(row) + return records + + +def main(): + large = sys.argv[1:] == ["--extended"] + if sys.argv[1:] not in ([], ["--extended"]): + raise ValueError("unknown check selection") + result = collect(large) + name = "GL4-ORDER3.json" if large else "LITERAL-GL.json" + if json.loads(json.dumps(result)) != json.loads((HERE/name).read_text(encoding="utf8")): + raise ValueError("frozen literal histogram or enumeration trace") + print(json.dumps(dict(status="PASS_LITERAL_GUARD_HEADERS",fixture=name, + experiments=len(result), headers=sum(v["headers"] for v in result), + named_masks=sum(1 << len(v["forms"]) for v in result)))) + + +if __name__ == "__main__": + main() diff --git a/research/common-image-guard-pencils/plane_check.py b/research/common-image-guard-pencils/plane_check.py new file mode 100644 index 0000000000..c6a6b7525a --- /dev/null +++ b/research/common-image-guard-pencils/plane_check.py @@ -0,0 +1,96 @@ +"""Check every named subfamily of an affine plane in one complete GL_3 census.""" +import hashlib +import json +import sys +from collections import defaultdict +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +from finite import Field +from headers import census +from laws import full_flat + + +def superset_sums(values, k): + """Replace each cell by the sum over masks containing its mask.""" + sums = values[:] + for bit in range(k): + half = 1 << bit + for block in range(0, len(sums), 2*half): + for i in range(block, block + half): + sums[i] += sums[i + half] + return sums + + +def torus_profile(field, space, forms): + masks = [0]*(1 << len(forms)) + for vector in space: + nonzero = sum(1 << i for i, row in enumerate(forms) if field.dot(row, vector)) + masks[nonzero] += 1 + return superset_sums(masks, len(forms)) + + +def one_plane(q): + f = Field(q) + forms = [(1, a, b) for a, b in f.vectors(2)] + k = len(forms) + matrix = census(q, 3, forms) + masks = [0]*(1 << k) + for name, count in matrix["masks"].items(): + masks[int(name)] = count + actual = superset_sums(masks, k) + whole = torus_profile(f, f.vectors(3), forms) + # Explicit q+1 planes through e1, parametrized by quotient projective lines. + planes = [] + lines = set() + for u, v in [(1, i) for i in range(q)] + [(0, 1)]: + coordinates = [(a, f.mul[b][u], f.mul[b][v]) for a, b in f.vectors(2)] + planes.append(torus_profile(f, coordinates, forms)) + for intercept in range(q): + line = sum(1 << i for i, (_, a, b) in enumerate(forms) + if f.dot((u,v), (a,b)) == intercept) + sub = line + while sub: + lines.add(sub) + sub = (sub - 1) & line + # At m=r=3 there is exactly one header per master tuple. All nonempty + # subsets are evaluated on this SAME rank-three master; even collinear + # subsets use this denominator, with unconstrained coordinates retained. + counts = defaultdict(lambda: [0, 0, 0]) + digest = hashlib.sha256() + a = q + (q - 1)**2 + p_num, p_den = (q - 1)*a*a, (q**3 - 1)*q*q + for mask, seen in enumerate(actual): + if mask: + predicted = (q - 1)*((q**3 + (q - 1)*whole[mask])**2 + - sum((q*q + (q - 1)*plane[mask])**2 for plane in planes) + + q*a*a) + if predicted != seen: + raise ValueError(f"affine plane subset q={q}, mask={mask}") + h = mask.bit_count() + rank = 1 if h == 1 else (2 if mask in lines else 3) + delta = seen*p_den**h - matrix["headers"]*p_num**h + counts[h,rank][1 + (delta > 0) - (delta < 0)] += 1 + digest.update(seen.to_bytes(4, "little")) + if actual[0] != matrix["headers"] or sum(sum(x) for x in counts.values()) != (1 << k) - 1: + raise ValueError("plane subset coverage") + if actual[-1] != matrix["headers"]*full_flat(q, 3, 3): + raise ValueError("all affine directions vs full-flat specialization") + return dict(q=q, named_directions=k, headers=matrix["headers"], subsets=1 << k, + determinant_classes=matrix["determinant_classes"], + nonempty_mask_signs_by_size_rank={f"{h},{r}":v for (h,r),v in sorted(counts.items())}, + subset_count_sha256=digest.hexdigest(), word_det_mask_sha256=matrix["word_det_mask_sha256"], + observed_exact_masks=matrix["masks"]) + + +def collect(): + return [one_plane(q) for q in (2, 3, 4)] + + +if __name__ == "__main__": + rows = collect() + if rows != json.loads((HERE/"AFFINE-PLANES.json").read_text(encoding="utf8")): + raise ValueError("frozen affine-plane census") + print(json.dumps(dict(status="PASS_COMPLETE_AFFINE_PLANES",headers=sum(x["headers"] for x in rows), + subset_counts=sum(x["subsets"] for x in rows), field_orders=[2,3,4]))) diff --git a/research/common-image-guard-pencils/scaling.py b/research/common-image-guard-pencils/scaling.py new file mode 100644 index 0000000000..9fd85320be --- /dev/null +++ b/research/common-image-guard-pencils/scaling.py @@ -0,0 +1,35 @@ +"""Exact integer bracketing examples for three different limit regimes.""" +from fractions import Fraction +from math import isqrt + +from laws import direction +from windows import sign_window + + +def last_size(q, m): + left, right = 2, q + 1 + while right - left > 1: + mid = (left + right)//2 + if direction(q, mid, m) > 0: + left = mid + else: + right = mid + if direction(q, left, m) <= 0 or (left < q and direction(q, left + 1, m) > 0): + raise ValueError("size cutoff endpoints") + return left + + +def brackets(): + fixed_m, fixed_k, joint = [], [], [] + for q in (16, 64, 256, 1024, 4096): + for m in (2, 3, 6, 11): + last = last_size(q, m) + fixed_m.append(dict(q=q, m=m, last_k=last, k_over_q=str(Fraction(last, q)))) + if q <= 1024: + for k in (3, 4, 7): + upper = sign_window(q, k)["positive"][-1] + fixed_k.append(dict(q=q, k=k, last_m=upper, m_over_q=str(Fraction(upper, q)))) + k = isqrt(q) + top = sign_window(q, k)["positive"][-1] + joint.append(dict(q=q, k=k, last_m=top, d_k_over_q=str(Fraction((top - 1)*k, q)))) + return dict(fixed_dimension=fixed_m, fixed_size=fixed_k, growing_size_and_dimension=joint) diff --git a/research/common-image-guard-pencils/ternary.py b/research/common-image-guard-pencils/ternary.py new file mode 100644 index 0000000000..8578559f32 --- /dev/null +++ b/research/common-image-guard-pencils/ternary.py @@ -0,0 +1,30 @@ +"""Exact small certificates in the sharp field-order boundary.""" +from fractions import Fraction + +from dependency import joint, prefix_count +from finite import Field +from laws import marginal, orbit_size + + +def four_rows(): + field = Field(3) + shapes = [[(1,0,0),(1,1,0),(1,2,0),(1,0,1)], + [(1,0,0),(1,1,0),(1,0,1),(1,1,1)], + [(1,0,0,0),(1,1,0,0),(1,0,1,0),(1,0,0,1)]] + t = Fraction(7, 9) + lower3 = Fraction(2, 3)*(Fraction(35, 81)/t**4)**4*(1 - 4*Fraction(17, 35)**4) + lower4 = Fraction(2, 3)*(Fraction(113, 243)/t**4)**4*( + 1 - 13*Fraction(43, 113)**4 - 27*Fraction(7, 113)**4) + if min(lower3, lower4) <= 1 or not 3*t**5 < 1: + raise ValueError("ternary tail threshold") + cases = [] + for forms in shapes: + rank = len(forms[0]) + for m in range(rank, 5): + counted = prefix_count(field, forms, m) + value = joint(field, forms, m) + if counted != value*orbit_size(3, rank, m) or value <= marginal(3, m)**4: + raise ValueError("ternary quartet comparison") + cases.append(dict(forms=forms,m=m,joint=str(value),ratio=str(value/marginal(3,m)**4), + passing_tuples=counted)) + return dict(lower_bound_at_d4={"rank3":str(lower3),"rank4":str(lower4)},exceptions=cases) diff --git a/research/common-image-guard-pencils/triples.py b/research/common-image-guard-pencils/triples.py new file mode 100644 index 0000000000..82679d9fe6 --- /dev/null +++ b/research/common-image-guard-pencils/triples.py @@ -0,0 +1,44 @@ +"""Finite exception certificates for the all-field independent-triple proof.""" +from fractions import Fraction +from math import comb + +from laws import independent_triple, marginal + + +def box_triple(q, m): + """Subtract actual collinear triples in each coordinate product box.""" + d = m - 1 + ambient = q**d + total = 0 + for free in range(d + 1): + restricted = d - free + n = q**free*(q - 1)**restricted + along_line = q**(2*free)*((q - 1)*(q - 2))**restricted + frames = n*(n - 1)*(n - 2) - (q - 2)*(along_line - n) + total += (q - 1)*comb(d, free)*(q - 1)**restricted*frames + return Fraction(total, (q**m - 1)*ambient*(ambient - 1)*(ambient - q)) + + +def certificates(): + result = [] + for q in (3, 4, 5, 7, 8, 9, 11, 13, 16, 17): + x = Fraction(1, q) + t = 1 - x + x*x + base = q*t**3 + if base <= 1: + raise ValueError("triple tail growth") + lower = 2*x*(1 - x)**3 * base**2 + d = 2 + exceptions = [] + while lower <= q + 1: + counted = box_triple(q, d + 1) + if counted != independent_triple(q, d + 1): + raise ValueError("triple affine box count") + ratio = counted/marginal(q, d + 1)**3 + if ratio <= 1: + raise ValueError("independent triple finite exception") + exceptions.append(dict(m=d + 1, ratio=str(ratio), floor_1e6=10**6*ratio.numerator//ratio.denominator)) + lower *= base + d += 1 + result.append(dict(q=q, first_d_with_tail=d, tail_lower=str(lower), exceptions=exceptions)) + return result diff --git a/research/common-image-guard-pencils/verify.py b/research/common-image-guard-pencils/verify.py new file mode 100644 index 0000000000..9b9b92b119 --- /dev/null +++ b/research/common-image-guard-pencils/verify.py @@ -0,0 +1,85 @@ +"""Replay the proof's finite certificates using only package files and stdlib.""" +import hashlib +import json +import sys +from fractions import Fraction +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +from checks import controls, scientific_result, sign_rows +from flat_check import flat_examples +from headers import census +from laws import full_flat, universal_positive_size +from scaling import brackets +from triples import box_triple, certificates +from ternary import four_rows + + +def sources(): + meta = json.loads((HERE/"SOURCES.json").read_text(encoding="utf8")) + count = 0 + for row in meta["files"]: + if "vendored_as" not in row: + continue + data = (HERE/row["vendored_as"]).read_bytes() + oid = hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest() + if oid != row["git_blob"] or hashlib.sha256(data).hexdigest() != row["sha256"]: + raise ValueError("source bytes or Git blob") + if "upstream_origin" in row: + origin = row["upstream_origin"] + if origin["git_blob"] != oid or not row["pin"].endswith(":" + row["path"]): + raise ValueError("pending source binding") + count += 1 + if count != 7: + raise ValueError("source inventory") + return count + + +def frozen(name, value): + if json.loads(json.dumps(value)) != json.loads((HERE/name).read_text(encoding="utf8")): + raise ValueError("frozen result: " + name) + + +def smoke(): + controls() + row = census(5, 2, [(1, i) for i in range(5)]) + if row["masks"] != {"0": 80, "15": 64, "23": 64, "27": 64, "29": 64, "30": 64, "31": 80}: + raise ValueError("literal five-direction matrix guard") + if box_triple(3, 3) != Fraction(20, 117): + raise ValueError("affine box triple anchor") + if full_flat(3, 3, 4) != Fraction(17, 520): + raise ValueError("full affine flat anchor") + if universal_positive_size(3) != 5: + raise ValueError("ternary dense-size anchor") + four_rows() + + +def main(): + n = sources() + if sys.argv[1:] == ["--controls"]: + smoke() + print(json.dumps(dict(status="PASS_PENCIL_SEMANTIC_CONTROLS",sources=n))) + return + if sys.argv[1:]: + raise ValueError("unknown mode") + result = scientific_result() + signs = sign_rows() + frozen("RESULT.json", result) + frozen("SIGN-WINDOWS.json", signs) + frozen("ASYMPTOTICS.json", brackets()) + frozen("FULL-FLATS.json", flat_examples()) + triples = certificates() + quartets = four_rows() + frozen("TRIPLE-CERTIFICATES.json", triples) + frozen("TERNARY-FOUR.json", quartets) + print(json.dumps(dict(status="PASS_COMMON_IMAGE_GUARD_LAW",sources=n, + prefix_cases=len(result["raw_prefix_cases"]), + triple_exceptions=sum(len(x["exceptions"]) for x in triples), + ternary_quartets=len(quartets["exceptions"]), + formula_checks=result["finite_formula_checks"], + sign_windows=len(signs["windows"]),sign_cases=signs["finite_comparisons"]))) + + +if __name__ == "__main__": + main() diff --git a/research/common-image-guard-pencils/windows.py b/research/common-image-guard-pencils/windows.py new file mode 100644 index 0000000000..f21811c565 --- /dev/null +++ b/research/common-image-guard-pencils/windows.py @@ -0,0 +1,43 @@ +"""Certify the integer dimension intervals using the concavity in SIGN.md.""" +from functools import lru_cache + +from laws import marginal, pencil + + +def sign_window(q, k): + if not 2 <= k <= q: + raise ValueError("a pencil requires 2 <= k <= q") + if k == 2 or q == 3: + return dict(positive=[2, None], ties=[]) + + @lru_cache(None) + def ratio(m): + return pencil(q, k, m)/marginal(q, m)**k + + def first_true(lo, hi, predicate): + while lo < hi: + mid = (lo + hi)//2 + if predicate(mid): + hi = mid + else: + lo = mid + 1 + return lo + + # Adjacent ratios decrease strictly and tend to T < 1. + def descending(m): + return ratio(m + 1) <= ratio(m) + + hi = 2 + while not descending(hi): + hi *= 2 + peak = first_true(2, hi, descending) + if ratio(peak) <= 1: + ties = [m for m in (peak, peak + 1) if ratio(m) == 1] + return dict(positive=[], ties=ties) + left = first_true(2, peak, lambda m: ratio(m) > 1) + hi = peak + 1 + while ratio(hi) > 1: + hi *= 2 + after = first_true(peak + 1, hi, lambda m: ratio(m) <= 1) + ties = [m for m in (left - 1, after) if m >= 2 and ratio(m) == 1] + return dict(positive=[left, after - 1], ties=ties) From 465a0060fbd236a5e202619de4a45a694d44970a Mon Sep 17 00:00:00 2001 From: SHIN09-git Date: Wed, 4 Nov 2026 13:39:33 +0800 Subject: [PATCH 3/3] Recount the sign crossings and larger finite header families --- .../EXTRA-CENSUSES.json | 101 ++++++++++++++++++ research/common-image-guard-pencils/README.md | 1 + .../common-image-guard-pencils/RESULT.json | 101 ++++++++++++++++++ .../common-image-guard-pencils/VALIDATION.md | 7 ++ research/common-image-guard-pencils/checks.py | 26 ++++- .../extra_censuses.py | 92 ++++++++++++++++ research/common-image-guard-pencils/verify.py | 3 + 7 files changed, 330 insertions(+), 1 deletion(-) create mode 100644 research/common-image-guard-pencils/EXTRA-CENSUSES.json create mode 100644 research/common-image-guard-pencils/extra_censuses.py diff --git a/research/common-image-guard-pencils/EXTRA-CENSUSES.json b/research/common-image-guard-pencils/EXTRA-CENSUSES.json new file mode 100644 index 0000000000..69174fdc66 --- /dev/null +++ b/research/common-image-guard-pencils/EXTRA-CENSUSES.json @@ -0,0 +1,101 @@ +{ + "five_direction_GL3_F5": { + "headers": 1488000, + "all_five_pass": 99200, + "masks": { + "0": 352000, + "7": 40960, + "11": 40960, + "13": 40960, + "14": 40960, + "15": 125440, + "19": 40960, + "21": 40960, + "22": 40960, + "23": 125440, + "25": 40960, + "26": 40960, + "27": 125440, + "28": 40960, + "29": 125440, + "30": 125440, + "31": 99200 + }, + "word_det_mask_sha256": "5fe98f4af1d2102d6eb363c0082d1e92d97da197a2be2c3ab38871591562cfc6" + }, + "ternary_GL4": { + "headers": 24261120, + "representatives": 1516320, + "named_subset_counts": [ + 24261120, + 7705152, + 7705152, + 3948480, + 7705152, + 3948480, + 3948480, + 1601856, + 7705152, + 3948480, + 3948480, + 2289600, + 3948480, + 2289600, + 2289600, + 1166400, + 7705152, + 3948480, + 3948480, + 2289600, + 3948480, + 2289600, + 2289600, + 1166400, + 3948480, + 2289600, + 2289600, + 1660608, + 2289600, + 1660608, + 1660608, + 1166400, + 7705152, + 3948480, + 3948480, + 2289600, + 3948480, + 2289600, + 2289600, + 1166400, + 3948480, + 2289600, + 2289600, + 1499712, + 2289600, + 1499712, + 1499712, + 917568, + 3948480, + 2289600, + 2289600, + 1499712, + 2289600, + 1499712, + 1499712, + 917568, + 2289600, + 1499712, + 1499712, + 1182912, + 1499712, + 1182912, + 1182912, + 917568 + ], + "quartet_counts": [ + 1166400, + 1660608, + 1499712 + ] + } +} diff --git a/research/common-image-guard-pencils/README.md b/research/common-image-guard-pencils/README.md index b6dd8e688f..0a040368a1 100644 --- a/research/common-image-guard-pencils/README.md +++ b/research/common-image-guard-pencils/README.md @@ -14,6 +14,7 @@ In the smallest example here with five guards, take the rows `(1,a)` for all fiv | Every binary common-image family of at least two guards beats its product; complete affine flats of rank at least three do so over all fields | [Last-coordinate bound](PROOF.md) · [Full-flat checks](FULL-FLATS.json) | | Every named mask has the same law in each uniform determinant class, including uniform special-linear headers | [Counting proof](PROOF.md) · [Literal checks](LITERAL-GL.json) | | Complete matches for every subset of all normalized covectors in dimension three over the fields of orders two, three and four | [Affine-plane census](AFFINE-PLANES.json) | +| Larger checks at the dimension-three sign reversal and the ternary quartet boundary | [Optional censuses](EXTRA-CENSUSES.json) · [Reproduction](VALIDATION.md) | One practical consequence concerns estimates for a caller that batches several tests on the same header. Even knowing every pair exactly leaves room for the all-pass probability to fall on the opposite side of the independence prediction. A physical caller, its price, an improved multiplication bound and a formal proof-kernel check are outside this result. diff --git a/research/common-image-guard-pencils/RESULT.json b/research/common-image-guard-pencils/RESULT.json index 422608157f..0296b768d5 100644 --- a/research/common-image-guard-pencils/RESULT.json +++ b/research/common-image-guard-pencils/RESULT.json @@ -953,5 +953,106 @@ "passing_tuples": 173905507752256, "orbit": 1852985321066880 } + ], + "crossing_prefix_cases": [ + { + "q": 5, + "k": 5, + "m": 2, + "family": "pencil", + "passing_tuples": 80, + "orbit": 480, + "ratio_floor_1e8": 99165030 + }, + { + "q": 5, + "k": 5, + "m": 3, + "family": "pencil", + "passing_tuples": 4960, + "orbit": 74400, + "ratio_floor_1e8": 111744023 + }, + { + "q": 5, + "k": 5, + "m": 4, + "family": "pencil", + "passing_tuples": 238640, + "orbit": 9672000, + "ratio_floor_1e8": 102119948 + }, + { + "q": 5, + "k": 5, + "m": 5, + "family": "pencil", + "passing_tuples": 10525120, + "orbit": 1218360000, + "ratio_floor_1e8": 86044038 + }, + { + "q": 4, + "k": 3, + "m": 60, + "family": "pencil", + "passing_tuples": 6829318386181815818111120508439049113689097000804587160654727483478668537593506097700905761, + "orbit": 146783911423364576743092537299333563658840451563524888924425216738601028205881308889079231211997871105638400, + "ratio_floor_1e8": 100873870 + }, + { + "q": 4, + "k": 3, + "m": 61, + "family": "pencil", + "passing_tuples": 232196825130181737815778130552755507012770130824001487845049991810233372803878905792393726125, + "orbit": 9394170331095332911557922387157348100668494871741357834912676382414243522650242285261617075834850865944985600, + "ratio_floor_1e8": 99909668 + }, + { + "q": 4, + "k": 4, + "m": 8, + "family": "pencil", + "passing_tuples": 18122301324, + "orbit": 17590843883520, + "ratio_floor_1e8": 109043745 + }, + { + "q": 4, + "k": 4, + "m": 9, + "family": "pencil", + "passing_tuples": 455316479712, + "orbit": 1125878432071680, + "ratio_floor_1e8": 98225073 + }, + { + "q": 7, + "k": 7, + "m": 2, + "family": "pencil", + "passing_tuples": 252, + "orbit": 2016, + "ratio_floor_1e8": 79423132 + }, + { + "q": 7, + "k": 7, + "m": 3, + "family": "pencil", + "passing_tuples": 32256, + "orbit": 804384, + "ratio_floor_1e8": 71959023 + }, + { + "q": 4, + "k": 3, + "m": 61, + "family": "independent", + "passing_tuples": 14427842369613896825964076119824148525492311027257437839969056078723719601681151335543333420395789042413001822257102973029713700022, + "orbit": 12486994201263968925526388919172665173674998332409386817757535305925409417493517313752578048650104998064207024139099030092447565575512363578163200, + "ratio_floor_1e8": 4670390039 + } ] } diff --git a/research/common-image-guard-pencils/VALIDATION.md b/research/common-image-guard-pencils/VALIDATION.md index 178160fb66..bba98e93f7 100644 --- a/research/common-image-guard-pencils/VALIDATION.md +++ b/research/common-image-guard-pencils/VALIDATION.md @@ -6,6 +6,7 @@ The seven commands registered in VERIFY.json use Python 3.12 and its standard li | --- | --- | | Algebra and raw prefixes | 248 pencil specializations, 28 binary predecessor comparisons, 42 independent triples and 668 exact-mask size cases. A second method retains each actual prefix and its current column span in 36 small cases. Repeated rows and mixed dependencies are included. | | Dimension and size signs | 232 field-order/pencil-size windows, compared with direct rational arithmetic at 18,560 dimensions. The scaled boundary integers are floors obtained by integer division. Further examples bound the dimension and family-size crossovers through field order 4096. | +| Recounting the crossings | Eleven raw-prefix calculations give the actual passing-tuple count and orbit denominator at the main boundaries. These include dimensions 60 and 61 over the four-element field and both the dependent and independent triples at dimension 61. They avoid enumerating the enormous groups at those dimensions. | | Full affine flats | 32 finite comparisons of a separate binomial formula with the lattice sum. Seventeen field orders have exact thresholds for the sufficient last-coordinate condition. | | Independent triples | A conditional sampling bound covers the infinite tail. The 17 remaining field/dimension pairs have exact ratios from both the lattice formula and a direct count of noncollinear points in coordinate boxes. [Certificates](TRIPLE-CERTIFICATES.json) | | Smallest possible field order | Five ternary quartet cases below the analytic dimension cutoff are recounted with raw prefixes, including an independent four-row case. [Exact values](TERNARY-FOUR.json) | @@ -34,3 +35,9 @@ python3.12 -I -W error -B audit_mutations.py ``` The compact hashes and histograms are retained in [literal fixtures](LITERAL-GL.json), [the four-element pencil](GL4-ORDER3.json) and [the full planes](AFFINE-PLANES.json). The formula checks and exact integer brackets are in [the primary result](RESULT.json), [the sign windows](SIGN-WINDOWS.json), [the scaling examples](ASYMPTOTICS.json) and [the full-flat examples](FULL-FLATS.json). Runtime uses no predecessor code or network input. + +## Optional larger censuses + +Run `python3.12 -I -W error -B extra_censuses.py` from the package directory. The full five-direction pencil passes on exactly 99,200 of the 1,488,000 headers in `GL_3(F_5)`, giving `1/15 > (441/775)^5`. This literally checks the opposite sign to the dimension-two case. + +Over the ternary field, the program traverses 1,516,320 invertible four-dimensional headers modulo the 16 free left diagonal scalings. These classes account for all 24,261,120 headers. The initial image vector has four nonzero entries. All 64 named subsets of six directions agree with the rank formula. The three quartet counts from SMALL-FIELDS.md at dimension four are 1,166,400, 1,660,608 and 1,499,712. [Larger census fixtures](EXTRA-CENSUSES.json) diff --git a/research/common-image-guard-pencils/checks.py b/research/common-image-guard-pencils/checks.py index a1a6c70436..f0f9dbc410 100644 --- a/research/common-image-guard-pencils/checks.py +++ b/research/common-image-guard-pencils/checks.py @@ -124,6 +124,29 @@ def sign_rows(): return dict(windows=windows, finite_comparisons=comparisons, boundary_certificates=coeffs) +def crossing_prefixes(): + """Recount the boundary dimensions by raw transitions, without inversion.""" + cases = [(5, 5, m, "pencil") for m in (2, 3, 4, 5)] + cases += [(4, 3, m, "pencil") for m in (60, 61)] + cases += [(4, 4, m, "pencil") for m in (8, 9)] + cases += [(7, 7, m, "pencil") for m in (2, 3)] + cases += [(4, 3, 61, "independent")] + rows = [] + for q, k, m, family in cases: + field = Field(q) + forms = independent(k) if family == "independent" else [(1, a) for a in range(k)] + rank = len(forms[0]) + passing = prefix_count(field, forms, m) + total = orbit_size(q, rank, m) + actual = Fraction(passing, total) + expected = independent_triple(q, m) if family == "independent" else pencil(q, k, m) + require(actual == expected, "raw crossing count") + ratio = actual/marginal(q, m)**k + rows.append(dict(q=q, k=k, m=m, family=family, passing_tuples=passing, + orbit=total, ratio_floor_1e8=ratio.numerator*10**8//ratio.denominator)) + return rows + + def scientific_result(): controls() a = independent_triple(4, 61)/marginal(4, 61)**3 @@ -132,4 +155,5 @@ def scientific_result(): return dict(five_direction_GL2_F5=[str(pencil(5, k, 2)) for k in range(1, 6)], opposite_triples_q4_m61=dict(independent_floor_1e8=a.numerator*10**8//a.denominator, pencil_floor_1e8=b.numerator*10**8//b.denominator), - finite_formula_checks=formula_rows(), raw_prefix_cases=prefix_rows()) + finite_formula_checks=formula_rows(), raw_prefix_cases=prefix_rows(), + crossing_prefix_cases=crossing_prefixes()) diff --git a/research/common-image-guard-pencils/extra_censuses.py b/research/common-image-guard-pencils/extra_censuses.py new file mode 100644 index 0000000000..7486020373 --- /dev/null +++ b/research/common-image-guard-pencils/extra_censuses.py @@ -0,0 +1,92 @@ +"""Optional larger counts of the five-direction crossing and ternary quartets.""" +import json +import sys +from collections import Counter +from fractions import Fraction +from itertools import product +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +from dependency import joint +from finite import Field +from headers import census, check_expected, eliminate +from laws import pencil + + +def odd_pencil(): + row = census(5, 3, [(1, a) for a in range(5)]) + check_expected(row, lambda mask: pencil(5, mask.bit_count(), 3)) + if row["headers"] != 1488000 or row["masks"]["31"] != 99200: + raise ValueError("five-direction GL3(F5) census") + return dict(headers=row["headers"], all_five_pass=row["masks"]["31"], + masks=row["masks"], word_det_mask_sha256=row["word_det_mask_sha256"]) + + +def ternary_quartets(): + field = Field(3) + rows = [(1,0,0,0),(1,1,0,0),(1,2,0,0),(1,0,1,0),(1,1,1,0),(1,0,0,1)] + # Use u=(1,1,1,1), not a coordinate vector. This basis change preserves + # Vu=t and recovers the indicated dependency forms for comparison. + forms = [((1-a-b-c) % 3, a, b, c) for _, a, b, c in rows] + bad = {v: sum(1 << i for i, row in enumerate(forms) if field.dot(row, v) == 1) + for v in field.vectors(4)} + points = [v for v in field.vectors(4) if next((x for x in v if x), 0) == 1] + histogram = Counter() + for g in product(points, repeat=4): + det, inv = eliminate(field, g, inverse=True) + if not det: + continue + prefix, passing = (0, 0, 0, 0), 63 + for j in range(3): + scalar = sum(g[j]) % 3 + prefix = tuple((prefix[i] + scalar*inv[i][j]) % 3 for i in range(4)) + passing &= ~bad[prefix] + # Each invertible representative stands for 2^4 left row scalings + # with identical principal minors in every conjugate. + histogram[passing] += 16 + total = sum(histogram.values()) + if total != 24261120: + raise ValueError("ternary GL4 cardinality") + counts = [] + for mask in range(64): + observed = sum(n for key, n in histogram.items() if key & mask == mask) + chosen = [v for i, v in enumerate(rows) if mask & (1 << i)] + if Fraction(observed, total) != joint(field, chosen, 4): + raise ValueError("ternary projective header subset") + counts.append(observed) + return dict(headers=total, representatives=total//16, named_subset_counts=counts, + quartet_counts=[counts[s] for s in (15, 27, 43)]) + + +def check_retained(): + data = json.loads((HERE/"EXTRA-CENSUSES.json").read_text(encoding="utf8")) + odd, ternary = data["five_direction_GL3_F5"], data["ternary_GL4"] + if odd["headers"] != 1488000 or odd["all_five_pass"] != 99200: + raise ValueError("retained five-direction census") + check_expected(dict(odd, forms=[(1, a) for a in range(5)], q=5, m=3), + lambda mask: pencil(5, mask.bit_count(), 3)) + forms = [(1,0,0,0),(1,1,0,0),(1,2,0,0),(1,0,1,0),(1,1,1,0),(1,0,0,1)] + counts = ternary["named_subset_counts"] + if (ternary["headers"], ternary["representatives"], len(counts)) != (24261120, 1516320, 64): + raise ValueError("retained projective census size") + if ternary["quartet_counts"] != [counts[i] for i in (15, 27, 43)]: + raise ValueError("retained quartet labels") + field = Field(3) + for mask, count in enumerate(counts): + chosen = [v for i, v in enumerate(forms) if mask & (1 << i)] + if count != ternary["headers"]*joint(field, chosen, 4): + raise ValueError("retained projective census probability") + + +def main(): + data = dict(five_direction_GL3_F5=odd_pencil(), ternary_GL4=ternary_quartets()) + if data != json.loads((HERE/"EXTRA-CENSUSES.json").read_text(encoding="utf8")): + raise ValueError("optional complete-header fixtures") + print(json.dumps(dict(status="PASS_EXTRA_GUARD_CENSUSES", + literal_F5_headers=data["five_direction_GL3_F5"]["headers"], + F3_representatives=data["ternary_GL4"]["representatives"]))) + + +if __name__ == "__main__": + main() diff --git a/research/common-image-guard-pencils/verify.py b/research/common-image-guard-pencils/verify.py index 9b9b92b119..8e9638002b 100644 --- a/research/common-image-guard-pencils/verify.py +++ b/research/common-image-guard-pencils/verify.py @@ -8,6 +8,7 @@ HERE = Path(__file__).resolve().parent sys.path.insert(0, str(HERE)) from checks import controls, scientific_result, sign_rows +from extra_censuses import check_retained from flat_check import flat_examples from headers import census from laws import full_flat, universal_positive_size @@ -65,6 +66,7 @@ def main(): raise ValueError("unknown mode") result = scientific_result() signs = sign_rows() + check_retained() frozen("RESULT.json", result) frozen("SIGN-WINDOWS.json", signs) frozen("ASYMPTOTICS.json", brackets()) @@ -75,6 +77,7 @@ def main(): frozen("TERNARY-FOUR.json", quartets) print(json.dumps(dict(status="PASS_COMMON_IMAGE_GUARD_LAW",sources=n, prefix_cases=len(result["raw_prefix_cases"]), + crossing_prefix_cases=len(result["crossing_prefix_cases"]), triple_exceptions=sum(len(x["exceptions"]) for x in triples), ternary_quartets=len(quartets["exceptions"]), formula_checks=result["finite_formula_checks"],