diff --git a/research/principal-demand-dirty-spare/PROOF.md b/research/principal-demand-dirty-spare/PROOF.md new file mode 100644 index 0000000000..5b79143499 --- /dev/null +++ b/research/principal-demand-dirty-spare/PROOF.md @@ -0,0 +1,195 @@ +# A restored spare removes the principal-demand orbit obstruction + +This contribution was produced by Nick Petalas. Apache-2.0. + +## Contract + +Let R be any associative ring with identity, 1 != 0. It need not be finite, +commutative, a domain or a field. Three rows A0,A1,H and a disjoint source p +start with independent arbitrary values a0,a1,h,p in R^w, w >= 1. Every +coefficient acts by left multiplication. The required endpoint is + +```text +(A0,A1,H,p) = (a0+x p, a1+y p, h, p). +``` + +A fixed, input-independent finite word may use only source insertions +P_i(beta): row i += beta p and row additions E_ij(c): row i += c row j, +i != j, with rows numbered 0,1,2 and H numbered 2. Every original dirt +column must return exactly. There is no clearing, observation, free basis +map, extra row, or input-dependent control. We count nonzero source +insertions. Row additions, coefficient preparation and physical use are +separate costs. The optional tariff below charges every gate in the word. + +## Theorem + +Put L=Rx+Ry, a left ideal. The minimum number of nonzero source insertions is + +```text +0 if x=y=0; +1 if L is nonzero and principal; +2 if L is not principal. +``` + +The new assertion is sufficiency of principality over arbitrary rings after +adding one restored dirty spare. A one-insertion word uses at most eight +row additions, with its insertion at the spare. This bound need not be a +shortest word. Necessity and the two-insertion echo are credited to Ali +Romman #5310 and the retained ring-valued fanout lineage. Their finite-ring +sufficiency theorem does not assert this arbitrary-ring stabilization. + +### Necessity + +No insertion leaves the source column zero. If a word has exactly one +nonzero insertion beta at row i, let C be the invertible matrix product of +all later row additions. The final source column is + +```text +lambda=(x,y,0)^T = C e_i beta. +``` + +Every coordinate is a left multiple of beta, so L is contained in R beta. +Applying C^-1 expresses beta as a left linear combination of x,y,0 and +gives the opposite containment. Thus L=R beta is principal. This proof +works with any finite number of restored dirty spectators, and it does +not use commutativity, finiteness, or a division operation. Invertibility +also shows that nonzero beta cannot produce zero demand. + +### The eight-ADD construction + +Suppose L=R beta is nonzero. Since x,y belong to R beta and beta belongs +to Rx+Ry, choose a,b,s,t in R satisfying + +```text +x=a beta, y=b beta, beta=s x+t y. +``` + +These are witnesses, not free divisions. The theorem is existential when +only the ideal's principality is known. An implementation must supply the +witnesses and pay for their preparation. Define the four-ADD word R in +chronological order by + +```text +E_20(s), E_21(t), E_02(-a), E_12(-b). +``` + +On the desired source column it performs + +```text +(x,y,0) -> (x,y,sx) -> (x,y,beta) + -> (0,y,beta) -> (0,0,beta). +``` + +Execute R, then P_2(beta), then the literal inverse of R: + +| Step | Gate | +|---:|---| +| 1 | H += s A0 | +| 2 | H += t A1 | +| 3 | A0 -= a H | +| 4 | A1 -= b H | +| 5 | H += beta p | +| 6 | A1 += b H | +| 7 | A0 += a H | +| 8 | H -= t A1 | +| 9 | H -= s A0 | + +On every original dirt column, steps 1-4 and 6-9 cancel exactly. The source +column after step 5 evolves under steps 6-9 as + +```text +(0,0,beta) -> (0,b beta,beta) + -> (a beta,b beta,beta) + -> (a beta,b beta,beta-t b beta) + -> (a beta,b beta,beta-t b beta-s a beta) + = (x,y,0). +``` + +The additive group of a ring is commutative; no multiplicative coefficients +were commuted. In particular the order is s a and t b, not a s or b t. +This proves the endpoint for arbitrary dirt and every data width. Zero +coefficient gates may be deleted. The inverse reverses all nine gates and +negates their coefficients, and must be charged if used. + +A useful stronger identity holds without any witness relation: the same +word has identity dirt block and source column + +```text +(a beta, b beta, (1-s a-t b) beta)^T. +``` + +The verifier checks this full identity over the free associative integer +polynomial ring. It is a finite coefficient certificate, independently of +all finite-ring substitutions. + +### At most two insertions + +For any x,y, even without a spare, the chronological word + +```text +A1 -= y A0; A0 += p; A1 += y A0; A0 += (x-1) p +``` + +restores all dirt and produces increments (x p,y p). Delete zero calls. +If L is nonprincipal, x cannot equal 1, so both source coefficients are +nonzero. The necessity argument makes two insertions minimal. Zero demand +has the empty word. These observations complete the classification. + +## Polynomial first example and complete declared gate price + +For R=K[u,v] over any field K, take + +```text +x=1+uv, y=u^2, beta=1, +a=1+uv, b=u^2, s=1-uv, t=v^2. +``` + +The witness identity is (1-uv)(1+uv)+v^2 u^2=1. Every coefficient of the +eight row additions is a nonzero polynomial over every field, including +characteristic two. The word therefore uses exactly eight nonzero row +additions and one nonzero source insertion, restores the arbitrary third +row, and realizes precisely the demand in Nick Petalas #5211. + +That predecessor proves that the same demand with exactly two mutable +rows has no one-insertion word, using Cohn's cited classical theorem. +We use that obstruction as a cited premise and do not replay or reprove it. +The new constructive upper bound is independent of Cohn's theorem. + +Let each row addition into row i cost c_i>0, independently of coefficient +and source row, and let insertion at the spare cost mu_2>0. The exact price +of the displayed polynomial word is + +```text +mu_2 + 2 c_0 + 2 c_1 + 4 c_2. +``` + +This charges all preparation, dirty restoration and the insertion in this +abstract alphabet. At mu_0=100, mu_1=1000, mu_2=100 and c_0=c_1=c_2=1, +the displayed word costs 108. The predecessor's exact two-row tariff at +the matching two-row prices is 202. This is a comparison of two explicitly +different workspace contracts, not a new three-row optimum or a physical +cost claim. Inverse execution would cost another 108 under these stationary +prices. Coefficient preparation, storage, movement and actual native gates +are outside the declared abstract tariff and are not assigned zero cost. + +## Relation to stabilized dual exchange + +Nick Petalas #6280 gives a dyadic exchange for a genuine dual pair ab=1, +with three block shears and one sign SCALE. Its classical stabilized +completion mechanism is related precedent. The present word uses only +elementary row additions and requires merely (1-sa-tb) beta=0. The element +beta may be a zero divisor and sa+tb need not equal 1. Thus no dual pair or +unit beta is assumed. For example, in Z/4, beta=2, a=b=s=1, t=2 satisfies +the witness while sa+tb=3. The claim here is the exact ring-valued fanout +criterion, explicit eight-ADD word and Cohn application, not historical +priority for stabilization or elementary matrix algebra. + +## Limits + +The finite certificate establishes the stated polynomial identity. The +all-ring classification rests on the written algebraic proof. No shortest +ADD count, all-positive-price three-row tariff, native coefficient +implementation, physical spare lifetime, precision/tape cost, recursive +supplier admission, new kappa, or complete multiplication theorem follows. +All five selected framework assumptions remain. Independent human and +formal proof-kernel review are unclaimed. diff --git a/research/principal-demand-dirty-spare/README.md b/research/principal-demand-dirty-spare/README.md new file mode 100644 index 0000000000..4b4282c0d1 --- /dev/null +++ b/research/principal-demand-dirty-spare/README.md @@ -0,0 +1,164 @@ +# A restored dirty spare reaches every principal two-row demand + +This contribution was produced by Nick Petalas. Apache-2.0. + +Claim type: scoped algebraic proof with an exact free-associative polynomial +certificate and finite corroboration. Over every associative unital ring R, +for two demanded rows and one arbitrary dirty spare restored to its original +value, the minimum source-insertion count is + +```text +0 for zero demand; +1 for a nonzero principal left demand ideal; +2 for a nonprincipal left demand ideal. +``` + +The new step is arbitrary-ring sufficiency with the restored spare, using +one source insertion and at most eight elementary row additions. Finiteness, +commutativity, invertible demand coefficients and a clean spare are unnecessary. +[PROOF.md](PROOF.md) gives the ordered-ring construction and all-input proof. +The bound of eight ADDs is constructive, not an ADD optimum or exact tariff. + +This answers the feasibility part of Open next question in Nick Petalas's +[PR #5211](https://github.com/CrocSwap/integer-mult-bounds/pull/5211). For its +polynomial demand `(1+uv,u²)` over every field K, one restored dirty spare +removes the two-row one-insertion obstruction. The literal new word has +exactly eight nonzero ADDs and one insertion. Its complete declared abstract +gate price is `mu_2+2c_0+2c_1+4c_2`, with c_i charging each ADD into row i +and mu_2 charging the insertion at the spare. At prices mu_0=100, mu_1=1000, +mu_2=100 and all c_i=1, the word costs 108. The cited two-row optimum is +202 at the matching original prices. The workspace contracts differ; no +three-row optimum or physical saving is inferred. + +## Construction and evidence + +Given witnesses `x=a beta`, `y=b beta`, `beta=s x+t y`, execute the following +nine gates on arbitrary incoming A0,A1,H,p: + +```text +H += s A0; H += t A1; A0 -= a H; A1 -= b H; +H += beta p; +A1 += b H; A0 += a H; H -= t A1; H -= s A0. +``` + +The endpoint is `(A0+x p,A1+y p,H,p)`. The first and last four gates cancel +on every original dirt column. Without any witness relation, the residual +increment at H is exactly `(1-sa-tb) beta p`. Thus witnesses need only satisfy +an annihilator relation, not `sa+tb=1`. Coefficient preparation and physical +access remain separately paid obligations. + +The standard-library verifier imports no predecessor scientific code. It +checks the full four-by-four affine map over the free associative integer +polynomial ring, including the precise product orders, and the literal +inverse. A separate commutative integer polynomial specialization checks +the Cohn word, its inverse, all nine individual gate deletions, every +nonzero coefficient and destination counts `(2,2,4)`. + +Exact finite substitutions cover every five-tuple `(beta,a,b,s,t)` over Z/4 +and UT2(F2): 1,024 and 32,768 tuples, respectively. Every full affine map and +inverse agrees with the unconstrained residual identity. Among these are +192 and 6,720 nonzero valid witnesses; 48 and 4,704 of those have the chosen +`sa+tb != 1`. A further 3,420 selected witnesses in M2(F2), including 2,160 +with the chosen `sa+tb != 1`, check genuinely noncommutative substitutions. +These finite tests check the new word, not predecessor source-count theorems. +Eight invalid-domain controls and explicit wrong-order/nonzero-residual +discriminators also pass. Three disposable optimized-script mutations are +rejected at the free-associative endpoint check: lost restoration, wrong +preparation sign and reversed multiplication. The universal criterion is +the written proof. + +## Reproduce + +From the repository root, with standard-library CPython 3.12: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/principal-demand-dirty-spare/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/principal-demand-dirty-spare/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/principal-demand-dirty-spare +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/principal-demand-dirty-spare --check-source-history +``` + +Substitute another CPython 3.12 path on other hosts. Both registered commands +emit `PASS_PRINCIPAL_DEMAND_DIRTY_SPARE` in a generated JSON receipt binding +all six package files by SHA256. Replay writes nothing. The receipt is +generated by execution, not handwritten. SOURCES.json pins predecessor text +as historical provenance; no external live scientific inputs are required. + +## Scope, credit and overlap + +Base is canonical main `e54523517d0f03e58352e647c403a5af3e525a57`, priority +revision 8, selected #7000 with conditional kappa 0.00363005817 unchanged. +The selected source-binding positive control passed. The priority catalogue +still describes #5599; its numerical headline is historical. TASK.json +explicitly changes the bit-helper-contract card to this algebraic interface +question. No G20 supplier or selected framework assumption is discharged. +The [advance CLAIM](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19601509) +records the question and proposed ten-ADD bound before the new checks. The +first verified word uses eight ADDs and is packaged without seeking an optimum. + +Credit Nick Petalas #5211 for the explicit restored-spare question and the +cited two-row polynomial obstruction; lee-phys #5139/#5089 for the principal +ideal interface; Ali Romman #5310 for the finite associative-ring criterion, +all-ring necessity and two-insertion echo; Krzysztof Wójt #5045 for the +source-count/return classification; and Nick Petalas #4916 for the ring-valued +contract. Ross Richardson, Cinna Davis, Anthony, Oscar Fennell, Tekalign and +the retained fanout lineage keep their credit. Nick Petalas #6280 is related +dyadic dual-exchange precedent. The new annihilator-witness word uses no +SCALE and need not have a genuine dual pair. Elementary stabilization and +row algebra are classical; no literature-wide priority is claimed. + +Live open/account PR lists, recent handoffs, active Discussions, local +reservations, all-main README searches for the object and its general-ring +form, and merged/all-state PR searches were checked before the claim. +The batch reservation records the source and main predecessor author. +The cached card search covers 846 open PRs and 7,480 Discussion records, +with complete reported remote pagination at 22:38 and 22:39 UTC on November +13, 2026. Its later local scan covers 222 of 10,178 tracked notes. Sparse local +notes, unpublished work and arbitrary historical diffs are not exhaustively +covered. These searches are overlap checks, not a novelty certificate. + +## Limits and verifier constraints + +Only the abstract ring gate contract and source-insertion count are settled. +A shortest ADD word and exact three-row directional tariff remain open. +Native coefficient realization, a physical restored spare, source access, +precision/tapes, movement, stock, compiler closure and a complete supplier +invoice are not supplied. Unknown physical costs are not zero. No new kappa, +selected-frontier update or complete multiplication theorem is claimed. +Independent human and formal proof-kernel review are unclaimed. No predecessor +scientific replay, selected cold replay, Lean or Docker build was run. + +Build the Lever led to the retained deterministic full-state checker. Prove +It Works led to every independent dirty column, exact noncommutative product +orders, literal inverses and gate-deletion controls. Power of Ten inspection +covers this verifier. Its functions remain below 60 physical lines, matrices +are four by four, words have at most eighteen gates, ring tables have at most +sixteen elements, and the exhaustive tuple domain has at most 32,768 members. +Polynomial capacity is 128 terms and degree twelve, with at most 16,384 term +pairs per product. Six source reads are capped at 256 KiB plus one guard byte. +There is no recursion, subprocess, network, dynamic code generation or write +path. Explicit exception checks remain active under -O. Warning-strict normal +and optimized replay supply interpreter diagnostics; no shared build settings +change. + +Power of Ten rule 3 deviation: Python and its standard library allocate managed +objects during this fixed offline run. The capacities above bound live data; +allocator internals are not instrumented. A larger domain or embedded service +must add a separately verified allocation policy. Rule 9 deviation: word +inversion receives only the locally defined polynomial negation function or +a fixed finite-table lookup. These two targets are immediate and retain no +mutable state; both are exercised by the normal and optimized replay. No +open-ended dispatch is accepted. + +## Open next questions + +- Find the exact directional tariff for the polynomial demand with one + restored dirty spare. Start from the displayed `(2,2,4)` ADD vector and + retain all three dirt columns while classifying arbitrary words. The + missing step is a three-row lower bound, not another check of this word. +- Bind one actual helper boundary to the ring action and a physically + available restored spare. First price coefficient preparation, source + access, lifetimes, routing and the complete consumer. No such physical + binding or favorable recursive invoice is supplied. + +Structured relevance, first steps and blockers are in TASK.json. diff --git a/research/principal-demand-dirty-spare/SOURCES.json b/research/principal-demand-dirty-spare/SOURCES.json new file mode 100644 index 0000000000..6ff426199c --- /dev/null +++ b/research/principal-demand-dirty-spare/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/cohn-fanout-obstruction/README.md", + "usage": "provenance", + "git_blob": "831e465aa74eb0b8265fdc9f7ee6b692a895e9b3", + "sha256": "a3ffdc41437ba17031276b215fd4a55173817af41b1ddfd426c3ce0127076f07" + }, + { + "path": "research/division-free-dual-exchange/README.md", + "usage": "provenance", + "git_blob": "5cf1073edeca87d6a28f0e1b29101d3a3aeafbbd", + "sha256": "c7f6c03990f858c85fd199babdc927f79af25de4421681d9a488c9f8d231ce09" + }, + { + "path": "research/finite-ring-source-insertions/README.md", + "usage": "provenance", + "git_blob": "74b9c1a2c17c1330ade8b6f24af225d8aa74f17e", + "sha256": "4e44aabcfb788f16732ecadfe3b85dfa516fdc12909712fd5edb60ea8c6c89b6" + } + ] +} diff --git a/research/principal-demand-dirty-spare/TASK.json b/research/principal-demand-dirty-spare/TASK.json new file mode 100644 index 0000000000..df00c9944b --- /dev/null +++ b/research/principal-demand-dirty-spare/TASK.json @@ -0,0 +1,84 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "bit-helper-contract", + "question": "Can a changed G20 helper path or independent-target split improve the complete BIT moment without losing its physical endpoint?", + "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", + "research/g20-helper-split/README.md", + "research/g20-conjugation-admission/README.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": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "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": "First read #5679/#5708 and their audits as pending component proposals. Choose one uncovered helper group/cut on an exact word; compare arbitrary-input native action, targets, owned storage, both orientations and full signed bill. Stop if the gain is only a scalar count or repaid by lost targets. Do not rerun the frozen #5609 common-frame domain without changing its hypothesis.", + "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": [ + "G20", + "helper split", + "5679", + "5708", + "independent target" + ], + "existing_checks": [ + { + "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": "Classify single-source-insertion feasibility for two demanded rows with one restored arbitrary dirty spare over every associative unital ring. Construct an eight-ADD word from a principal-left-ideal witness; specialize it to the polynomial Cohn demand.", + "scope_change_reason": "Follow Open next question of PR5211. This is an algebraic stabilization result, not a changed G20 supplier, physical caller or improvement in kappa.", + "bottleneck_link": "An explicitly paid restored spare removes an elementary-orbit obstruction to single source insertion. Native coefficient production, spare availability, precision, routing, compiler closure and the complete recursive invoice remain separate.", + "budget_minutes": 60, + "stop_rule": "Stop at the first verified restoring construction and insertion-count criterion. Do not seek a shortest ADD word or expand into a supplier.", + "outcome": "completed", + "evidence": "PROOF.md gives the all-ring criterion and full eight-ADD construction. verify.py checks the free associative polynomial identity, the literal Cohn word and exact finite ring substitutions.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "What is the least complete directional tariff for the Cohn demand with this restored dirty spare?", + "why_it_matters": "The eight-ADD word is an upper bound; additional legal interleavings may lower the bill.", + "first_step": "Keep all three dirt columns and compare count vectors under positive destination prices, starting with the eight-ADD word.", + "blocked_by": "No arbitrary-word three-row tariff lower bound is supplied." + }, + { + "question": "Can a current physical helper boundary supply this ring action and restored spare at a favorable complete price?", + "why_it_matters": "The algebraic source-count improvement alone does not improve a recursive supplier.", + "first_step": "Name one coefficient representation, source access contract and spare lifetime, then charge the full consumer.", + "blocked_by": "Native coefficient operations, routing, precision and complete caller costs are unspecified." + } + ], + "coordination": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19601509" +} diff --git a/research/principal-demand-dirty-spare/VERIFY.json b/research/principal-demand-dirty-spare/VERIFY.json new file mode 100644 index 0000000000..2655ee83c1 --- /dev/null +++ b/research/principal-demand-dirty-spare/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Free associative full-state identity, polynomial Cohn specialization, finite noncommutative substitutions, witness and restoration controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Repeat every scientific and failure control with Python assertions disabled." + } + ] +} diff --git a/research/principal-demand-dirty-spare/verify.py b/research/principal-demand-dirty-spare/verify.py new file mode 100644 index 0000000000..35e8b196c9 --- /dev/null +++ b/research/principal-demand-dirty-spare/verify.py @@ -0,0 +1,262 @@ +#!/usr/bin/env python3 +"""Exact full-state certificates for the restored-spare fanout word.""" +import hashlib +import itertools +import json +from pathlib import Path +import sys + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def poly(terms): + require(len(terms) <= 128, 'polynomial term capacity') + require(all(len(w) <= 12 for w in terms), 'polynomial degree capacity') + return tuple(sorted((w, c) for w, c in terms.items() if c)) + + +def add(p, q): + out = dict(p) + for w, c in q: + out[w] = out.get(w, 0) + c + return poly(out) + + +def neg(p): + return tuple((w, -c) for w, c in p) + + +def mul(p, q, commutative): + require(len(p) * len(q) <= 16384, 'polynomial product capacity') + out = {} + for u, c in p: + for v, d in q: + w = ''.join(sorted(u + v)) if commutative else u + v + out[w] = out.get(w, 0) + c * d + return poly(out) + + +def word(a, b, s, t, beta, negative): + prefix = ((2, 0, s), (2, 1, t), (0, 2, negative(a)), + (1, 2, negative(b))) + suffix = tuple((i, j, negative(c)) for i, j, c in reversed(prefix)) + return prefix + ((2, 3, beta),) + suffix + + +def inverse(gates, negative): + return tuple((i, j, negative(c)) for i, j, c in reversed(gates)) + + +def execute_poly(gates, commutative): + require(len(gates) <= 18, 'word capacity') + one = poly({'': 1}) + rows = [[one if i == j else () for j in range(4)] for i in range(4)] + for i, j, c in gates: + require(0 <= i < 3 and 0 <= j < 4 and i != j, 'gate indices') + rows[i] = [add(x, mul(c, y, commutative)) + for x, y in zip(rows[i], rows[j], strict=True)] + return rows + + +def expected_poly(x, y, residual): + one = poly({'': 1}) + out = [[one if i == j else () for j in range(4)] for i in range(4)] + out[0][3], out[1][3], out[2][3] = x, y, residual + return out + + +def symbolic_checks(): + a, b, s, t, z = (poly({c: 1}) for c in 'abstz') + gates = word(a, b, s, t, z, neg) + x, y = poly({'az': 1}), poly({'bz': 1}) + residual = poly({'z': 1, 'saz': -1, 'tbz': -1}) + require(execute_poly(gates, False) == expected_poly(x, y, residual), + 'free associative full-state identity') + require(execute_poly(gates + inverse(gates, neg), False) + == expected_poly((), (), ()), 'formal inverse endpoint') + wrong = add(z, neg(add(mul(x, s, False), mul(y, t, False)))) + require(wrong != residual, 'ordered products discriminator') + return {'free_associative_identities': 2, 'order_discriminators': 1} + + +def cohn_checks(): + one, u, v = (poly({w: 1}) for w in ('', 'u', 'v')) + uv = mul(u, v, True) + a, b = add(one, uv), mul(u, u, True) + s, t = add(one, neg(uv)), mul(v, v, True) + gates = word(a, b, s, t, one, neg) + endpoint = expected_poly(a, b, ()) + require(add(mul(s, a, True), mul(t, b, True)) == one, + 'Cohn witness identity') + require(execute_poly(gates, True) == endpoint, 'Cohn full dirty endpoint') + require(execute_poly(inverse(gates, neg), True) + == expected_poly(neg(a), neg(b), ()), 'Cohn literal inverse') + require(all(c for _, _, c in gates), 'nonzero polynomial gate census') + counts = tuple(sum(i == k and j != 3 for i, j, _ in gates) + for k in range(3)) + require(counts == (2, 2, 4), 'complete destination counts') + for cut in range(9): + shortened = gates[:cut] + gates[cut + 1:] + require(execute_poly(shortened, True) != endpoint, 'omitted gate') + require(100 + sum(counts) == 108, 'declared complete word price') + return {'cohn_words': 2, 'cohn_gate_deletions': 9, + 'cohn_row_adds': sum(counts), 'cohn_source_insertions': 1, + 'cohn_destination_counts': counts, 'cohn_declared_word_price': 108} + + +def table_product(kind, x, y): + if kind == 'Z4': + return x * y % 4 + if kind == 'UT2F2': + a, b, c = ((x >> i) & 1 for i in range(3)) + d, e, f = ((y >> i) & 1 for i in range(3)) + return (a * d) | ((a * e ^ b * f) << 1) | ((c * f) << 2) + require(kind == 'M2F2', 'unknown finite ring') + a, b, c, d = ((x >> i) & 1 for i in range(4)) + e, f, g, h = ((y >> i) & 1 for i in range(4)) + return ((a * e ^ b * g) | ((a * f ^ b * h) << 1) + | ((c * e ^ d * g) << 2) | ((c * f ^ d * h) << 3)) + + +def tables(kind): + require(kind in ('Z4', 'UT2F2', 'M2F2'), 'unknown finite ring') + size, one = {'Z4': (4, 1), 'UT2F2': (8, 5), 'M2F2': (16, 9)}[kind] + plus = tuple(tuple((x + y) % 4 if kind == 'Z4' else x ^ y + for y in range(size)) for x in range(size)) + times = tuple(tuple(table_product(kind, x, y) for y in range(size)) + for x in range(size)) + minus = tuple(next(y for y in range(size) if plus[x][y] == 0) + for x in range(size)) + for a, b, c in itertools.product(range(size), repeat=3): + require(times[times[a][b]][c] == times[a][times[b][c]], 'associativity') + require(times[a][plus[b][c]] == plus[times[a][b]][times[a][c]], + 'left distributivity') + require(times[plus[a][b]][c] == plus[times[a][c]][times[b][c]], + 'right distributivity') + for a in range(size): + require(times[one][a] == a == times[a][one], 'ring identity') + return plus, times, minus, one + + +def execute_finite(gates, ring): + plus, times, _, one = ring + size = len(plus) + require(len(gates) <= 18, 'word capacity') + rows = [[one if i == j else 0 for j in range(4)] for i in range(4)] + for i, j, c in gates: + require(0 <= i < 3 and 0 <= j < 4 and i != j, 'gate indices') + require(0 <= c < size, 'finite coefficient domain') + rows[i] = [plus[x][times[c][y]] + for x, y in zip(rows[i], rows[j], strict=True)] + return rows + + +def check_tuple(values, ring): + beta, a, b, s, t = values + plus, times, minus, one = ring + x, y = times[a][beta], times[b][beta] + residual = plus[beta][minus[plus[times[s][x]][times[t][y]]]] + gates = word(a, b, s, t, beta, minus.__getitem__) + expected = [[one if i == j else 0 for j in range(4)] for i in range(4)] + expected[0][3], expected[1][3], expected[2][3] = x, y, residual + require(execute_finite(gates, ring) == expected, 'finite full-state identity') + backwards = inverse(gates, minus.__getitem__) + for i in range(3): + expected[i][3] = minus[expected[i][3]] + require(execute_finite(backwards, ring) == expected, 'finite inverse identity') + witness = residual == 0 and beta != 0 + nondual = witness and plus[times[s][a]][times[t][b]] != one + return witness, nondual + + +def exhaustive_substitutions(kind): + ring = tables(kind) + size = len(ring[0]) + count = witnesses = nondual = 0 + for values in itertools.product(range(size), repeat=5): + good, weak = check_tuple(values, ring) + count += 1 + witnesses += good + nondual += weak + require(count == size**5 and witnesses > 0, 'complete tuple domain') + require(nondual > 0, 'annihilator-only witness domain') + return {'ring': kind, 'tuples': count, 'nonzero_witnesses': witnesses, + 'witnesses_with_sa_plus_tb_not_one': nondual} + + +def matrix_witnesses(): + ring = tables('M2F2') + plus, times, _, _ = ring + count = nondual = 0 + for beta, a, b in itertools.product(range(16), repeat=3): + if beta == 0: + continue + x, y = times[a][beta], times[b][beta] + candidates = ((s, t) for s, t in itertools.product(range(16), repeat=2) + if plus[times[s][x]][times[t][y]] == beta) + found = next(candidates, None) + if found is not None: + good, weak = check_tuple((beta, a, b, *found), ring) + require(good, 'selected noncommutative witness') + count += 1 + nondual += weak + require(count > 0 and nondual > 0, 'matrix witness coverage') + return {'ring': 'M2F2', 'selected_witnesses': count, + 'selected_witnesses_with_sa_plus_tb_not_one': nondual} + + +def controls(): + ring = tables('UT2F2') + _, times, minus, one = ring + require(times[1][2] == 2 and times[2][1] == 0, + 'literal E00 E01 differs from E01 E00') + # This tuple does not satisfy the witness relation: spare must retain p. + gates = word(one, one, 0, 0, one, minus.__getitem__) + require(execute_finite(gates, ring)[2][3] == one, 'invalid witness residual') + rejected = 0 + for gates in (((3, 0, one),), ((0, 0, one),), ((0, 4, one),), + ((0, 1, 8),), ((0, 1, -1),), ((0, 1, one),) * 19): + try: + execute_finite(gates, ring) + except ValueError: + rejected += 1 + require(rejected == 6, 'invalid gate controls') + for terms in ({'x' * 13: 1}, {str(i): 1 for i in range(129)}): + try: + poly(terms) + except ValueError: + rejected += 1 + require(rejected == 8, 'polynomial capacity controls') + return {'invalid_domain_controls': rejected, 'semantic_controls': 2} + + +def receipt(results): + root = Path(__file__).resolve().parent + names = ('README.md', 'PROOF.md', 'TASK.json', 'SOURCES.json', + 'VERIFY.json', 'verify.py') + hashes = {} + for name in names: + with (root / name).open('rb') as stream: + data = stream.read(262145) + require(len(data) <= 262144, 'source file capacity') + hashes[name] = hashlib.sha256(data).hexdigest() + return {'status': 'PASS_PRINCIPAL_DEMAND_DIRTY_SPARE', + 'claim_type': 'scoped written proof and exact polynomial certificate', + 'python': sys.version.split()[0], 'results': results, + 'sha256': hashes, 'no_new_kappa': True} + + +def main(): + require(len(sys.argv) == 1, 'no command-line inputs supported') + results = {'symbolic': symbolic_checks(), 'polynomial': cohn_checks(), + 'complete_substitutions': [exhaustive_substitutions('Z4'), + exhaustive_substitutions('UT2F2')], + 'matrix_substitutions': matrix_witnesses(), 'controls': controls()} + print(json.dumps(receipt(results), indent=2, sort_keys=True)) + + +if __name__ == '__main__': + main()