From 8b8134a77db03bd5ce8fb0e7de9cb96f90fad7cc Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Fri, 13 Nov 2026 14:27:52 +0000 Subject: [PATCH] feat(research): prove minimal affine algebra carrier dimensions --- .../affine-algebra-minimal-carrier/PROOF.md | 190 ++++++++++++++++ .../affine-algebra-minimal-carrier/README.md | 138 ++++++++++++ .../SOURCES.json | 24 ++ .../affine-algebra-minimal-carrier/TASK.json | 81 +++++++ .../VERIFY.json | 34 +++ .../affine-algebra-minimal-carrier/carrier.py | 185 ++++++++++++++++ .../affine-algebra-minimal-carrier/verify.py | 206 ++++++++++++++++++ 7 files changed, 858 insertions(+) create mode 100644 research/affine-algebra-minimal-carrier/PROOF.md create mode 100644 research/affine-algebra-minimal-carrier/README.md create mode 100644 research/affine-algebra-minimal-carrier/SOURCES.json create mode 100644 research/affine-algebra-minimal-carrier/TASK.json create mode 100644 research/affine-algebra-minimal-carrier/VERIFY.json create mode 100644 research/affine-algebra-minimal-carrier/carrier.py create mode 100644 research/affine-algebra-minimal-carrier/verify.py diff --git a/research/affine-algebra-minimal-carrier/PROOF.md b/research/affine-algebra-minimal-carrier/PROOF.md new file mode 100644 index 0000000000..b6c6ce8293 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/PROOF.md @@ -0,0 +1,190 @@ +# A smallest faithful affine group-algebra carrier + +This result was produced by Nick Petalas. New material is Apache-2.0. +Claim type: scoped written proof, with finite exact corroboration. + +## 1. Statement and boundary + +Let F be a finite field of order q and characteristic p, and let H be a +subgroup of F* of order h. Write G = F semidirect H, with elements (a,b), +a in H and b in F, and multiplication + + (a,b)(c,d) = (ac, b+ad). + +Let K be any field of characteristic different from p. Characteristic zero +is allowed; the characteristic may divide h. A carrier means a finite +dimensional unital K-linear representation of the entire algebra K[G]. +Faithful means injective on all formal K-linear combinations, rather than +only injective on the group elements. + +**Theorem.** The smallest dimension of a faithful carrier is exactly + + d_min = q+h-1. + +An explicit attainer is W direct-sum Q. Here W is the sum-zero subspace of +the natural q-dimensional affine permutation module, and Q is the +h-dimensional left regular module of the quotient H. The kernel of the +natural permutation module has dimension exactly h-1. Every formal +coefficient can be recovered from the attainer by the formulas below. + +The regular group carrier has dimension qh, so the reduction is +(q-1)(h-1). For h=1 there is no reduction. No claim is made about the +smallest *permutation* carrier or a physically implementable native address +action. W uses differences of coordinate vectors. Arithmetic, encoding, +source acquisition, restoration, precision, routing and complete supplier +costs are outside this algebraic statement. The selected frontier is unchanged. + +## 2. Explicit coefficient inverse + +Use the natural column convention P_(a,b)e_x = e_(ax+b). For + + u = sum_(a in H,b in F) c_(a,b) [(a,b)], + M = sum c_(a,b) P_(a,b), + s_a = sum_b c_(a,b), C = sum_a s_a, + +every row and column sum of M is C. For fixed a,b define its affine line sum + + L_(a,b) = sum_(x in F) M_(ax+b,x). + +Expanding this sum yields the exact identity + + L_(a,b) = q c_(a,b) + sum_(t != a) s_t. + +Indeed, the t=a contribution repeats c_(a,b) exactly q times. For t!=a, +the index (a-t)x+b visits every element of F exactly once, so that +contribution is s_t. Consequently + + c_(a,b) = (L_(a,b) - C + s_a)/q. (1) + +Only q is inverted. This proves that the natural action together with the +quotient regular action is faithful: the first column of the latter gives +each s_a, and (1) recovers all c_(a,b). In particular the conclusion remains +valid when the characteristic of K divides h. + +## 3. Remove the redundant constant direction + +Let 1 denote the vector with all q entries equal to one. Since q is +invertible in K, + + K^F = K 1 direct-sum W, + W = {v: sum_x v_x = 0}. + +The action on K 1 is the scalar C, already obtainable from Q. Removing +this one-dimensional summand preserves faithfulness and gives dimension +(q-1)+h. Here is a literal inverse in the basis + + w_x = e_x-e_0, x in F minus {0}. + +Let B be the W block of the supplied carrier matrix. Define columns d_x +of length q by d_0=0 and, for x!=0, + + (d_x)_y = B_(y,x) for y!=0, + (d_x)_0 = -sum_(y!=0) B_(y,x). + +Then d_x=M e_x-M e_0. The row sums of M give + + M e_0 = (C 1 - sum_(x!=0) d_x)/q, + M e_x = M e_0+d_x. (2) + +Recover s_a from Q, recover M using (2), then use (1). These formulas +give a linear left inverse of the carrier map. They do not assert that +an arbitrary block matrix belongs to its image. The executable decoder +re-encodes the recovered coefficients and rejects a matrix outside that image. + +For the natural action alone, M=0 implies C=0. Equation (1) then makes +c_(a,b)=s_a/q independent of b. Conversely put + + Z_a = sum_(b in F) [(a,b)]. + +Every Z_a acts as the same all-ones q-by-q matrix. Thus the complete kernel is + + {sum_a t_a Z_a : sum_a t_a=0}, + +with basis Z_a-Z_1 for a!=1 and dimension h-1. This is a complete kernel +classification, not an inference from finding a single alias. On W the +kernel is the full h-dimensional span of the Z_a. + +## 4. Matching lower bound for every coefficient field + +Let rho:K[G] -> End_K(V) be any faithful unital representation. Put + + e = (1/q) sum_(b in F) [(1,b)]. + +The translation subgroup is normal, so e is a central idempotent. The +elements e[(a,0)] for a in H are linearly independent and multiply as H. +Hence eK[G] is isomorphic to K[H]. Also + + V = eV direct-sum (1-e)V. + +The restriction to eV must be faithful on eK[G], because that ideal acts +as zero on (1-e)V. A finite multiplicative subgroup of a field is cyclic. +For completeness, its exponent d is attained by an element: combine +elements attaining the largest prime-power orders in this finite abelian +group. All h elements solve X^d=1, so the polynomial root bound gives h<=d; +Lagrange gives d<=h. Thus d=h. + +Choose a generator a of H. Then K[H] is K[T]/(T^h-1). Faithfulness on eV +requires the minimal polynomial of rho(e[(a,0)]) restricted to eV to be +exactly T^h-1. Otherwise a nonzero class of degree below h acts as zero. +Cayley-Hamilton therefore gives + + dim_K(eV) >= h. (3) + +This reasoning permits repeated roots in T^h-1. Replacing it by its +squarefree part would lose the modular case. + +To bound the other summand, extend scalars to an algebraic closure L of K. +An injective linear map remains injective under a field extension, and +dimensions of the two summands do not change. The additive group of F is +an elementary abelian p-group of order q. Since char K != p, L contains +q distinct additive characters chi. Their Fourier idempotents are + + e_chi = (1/q) sum_(b in F) chi(-b) [(1,b)]. + +Character orthogonality gives q nonzero pairwise orthogonal idempotents +with sum one. One is e, for the trivial character. These facts follow by +summing the nontrivial pth-root geometric series in any one coordinate of +the additive F_p-vector space. In a faithful representation each e_chi +has nonzero image. The q-1 nontrivial images lie in (1-e)(L tensor_K V) +and are linearly independent summands. Therefore + + dim_K((1-e)V) >= q-1. (4) + +Adding (3) and (4) proves dim V>=q+h-1. Section 3 attains this bound. +The Fourier and minimal-polynomial arguments are classical. Their use +here, together with the explicit coefficient inverse, establishes the +stated exact carrier size. No general representation-theory priority is claimed. + +## 5. Formal-identity consequence + +For any number r of scalar roles, applying the carrier entrywise gives an +injective algebra map + + Mat_r(K[G]) -> Mat_(r(q+h-1))(K). + +Thus exact equality on every column of this smaller carrier is equivalent +to coefficientwise equality of the formal endpoint matrices. All relevant +matrices must actually be tested; a natural action, a sample of vectors, +floating-point equality or group-element faithfulness alone does not imply +this equivalence. This is a verifier interface, not a native implementation. + +## 6. Finite evidence and scope + +The executable builds F2,F3,F4,F5,F7,F8,F9, every subgroup of their +multiplicative groups, and coefficient fields F2,F3,F5,F7 of different +characteristic from the address field. It checks every group product in +the integer carrier, ranks the natural/augmentation/hybrid algebra maps, +reconstructs every formal basis vector and mixed vectors, and checks the +entire displayed natural-kernel basis. A separate rational line-sum +calculation uses literal natural matrices. These checks corroborate the +written proof rather than replace its all-parameter quantifiers. + +In the excluded characteristic, the F3 affine group with h=2 has hybrid +algebra rank three instead of six over F3. The executable checks this +boundary as a rejection control. It is not a theorem about the smallest +carrier in that characteristic. + +No predecessor scientific verifier, selected cold replay, native program, +Lean, Docker or formal proof kernel is run. Independent human and formal +proof-kernel review are unclaimed. The five selected framework assumptions +remain unresolved by this result. diff --git a/research/affine-algebra-minimal-carrier/README.md b/research/affine-algebra-minimal-carrier/README.md new file mode 100644 index 0000000000..fdb294f4e3 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/README.md @@ -0,0 +1,138 @@ +# Smallest faithful carriers for affine group algebras + +This result was produced by Nick Petalas. New material is Apache-2.0. +Claim type: scoped written proof with exact finite corroboration. No new kappa. + +For every finite field F_q of characteristic p, every subgroup H of F_q* +of order h, and every coefficient field K of characteristic different from p, +the smallest faithful linear carrier of K[F_q semidirect H] has dimension + + q+h-1. + +The sum-zero part of the natural permutation module, of dimension q-1, +together with the regular H quotient, of dimension h, attains the bound. +This replaces the regular group carrier's qh coordinates. It works even +when char K divides h. [PROOF.md](PROOF.md) gives the explicit coefficient +inverse and matching dimension lower bound. These are algebraic verifier +sizes, not native operation costs or physical memory measurements. + +| Address field | h | Regular dimension | Smallest faithful linear dimension | +| --- | ---: | ---: | ---: | +| F3 | 2 | 6 | 4 | +| F4 | 3 | 12 | 6 | +| F7 | 3 | 21 | 9 | +| F7 | 6 | 42 | 12 | +| F9 | 8 | 72 | 16 | + +The natural q-point action has an exactly (h-1)-dimensional algebra kernel, +spanned by differences of complete translation coset sums. Its faithfulness +on group elements does not make it a formal-identity checker. Ali Romman's +#5394 already supplies an explicit warning and alias; that warning is +credited background. The new result is the complete kernel, explicit +repaired carrier and exact optimal linear dimension. + +## Construction and evidence + +Write an algebra element as sum c_(a,b)[(a,b)] for a in H, b in F_q, +acting by x -> ax+b. Let M be its natural matrix, s_a=sum_b c_(a,b), and +C=sum_a s_a. Its coefficients satisfy the line-sum inverse + + c_(a,b) = (sum_x M_(ax+b,x) - C + s_a)/q. + +The quotient regular block supplies s_a. The augmentation block and C +reconstruct M after removing its redundant constant direction. Only q is +inverted. The lower bound uses a central translation-average idempotent, +the degree-h minimal polynomial needed for a faithful cyclic H algebra, +and the q-1 nontrivial translation-character idempotents. These ingredients +are classical; no literature-priority claim is made for them. + +The checker builds every multiplicative subgroup of F2,F3,F4,F5,F7,F8,F9. +It checks all integer carrier products and, over coefficient fields +F2,F3,F5,F7 of different characteristic, independently eliminates the +flattened matrix banks to measure their exact span ranks. Every formal +basis vector and twelve mixed vectors per context are recovered. A separate +rational calculation checks the line inverse directly on natural matrices. +No predecessor scientific verifier is imported or replayed. + +The result is zero errors in 54 coefficient contexts, 13,269 group-product +pairs, 1,808 field triples, 1,683 recovered coefficient vectors, 1,380 rational +coefficient recoveries, and 96 natural-kernel basis vectors. Nine controls +cover malformed images, invalid domains and the excluded characteristic. +The latter F3/S3 construction has algebra rank three over F3 instead of six; +this is only a boundary fixture. The span-rank checks also reject omitting +quotient information. The all-parameter claims rest on the written proof. + +## Reproduce + +From the repository root: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/affine-algebra-minimal-carrier +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/affine-algebra-minimal-carrier/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/affine-algebra-minimal-carrier/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/affine-algebra-minimal-carrier --check-source-history +``` + +Other machines may substitute their CPython 3.12 path. Direct runs print +`PASS_AFFINE_ALGEBRA_MINIMAL_CARRIER`; the generic runner adds +`PASS_REGISTERED_RESEARCH_PACKAGE`. JSON output includes counts, per-context +ranks and SHA256 hashes of every package file. Default replay writes nothing. +To save a generated receipt, add `--receipt /absolute/external/scratch/receipt.json`; +an existing destination or a destination inside the checkout is rejected. + +No timing speedup is claimed. Both registered runs have a 120-second bound. +The standard-library code uses fixed fields with q<=9, at most 72 group +elements, 16 carrier coordinates and 256 flattened matrix entries. It uses +no recursion, subprocesses, dynamic code generation or external scientific +input. Functions stay below 60 lines. Managed Python allocations are a +Power of Ten rule-3 deviation bounded by these domains. Warning-strict +normal and optimized replay provide interpreter diagnostics; no shared +analyzer configuration is changed. + +## Scope, provenance and overlap + +The `bit-new-register-model` card changes scope to a side result about exact +finite formal-identity checking, rather than a new paid word. A formal affine +matrix identity can be checked entrywise on this smaller carrier; the result +does not construct a bit supplier. The baseline binding command passes on +canonical main e54523517d0f03e58352e647c403a5af3e525a57. Its selected record is +#7000; the revision-8 catalogue describes the older #5599 assessment. No +selected file changes. [TASK.json](TASK.json) preserves the original card. + +The [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19592134) +records the question before the proof checks. Live open/account PR lists, +handoffs, local reservations, all-main README searches for the quantity and +general group family, and merged-PR searches were checked. The overlap +helper's remote snapshot covers 810 open PRs and 7,424 Discussion records +with reported complete pagination; its local note search is sparse and +incomplete. This is bounded overlap evidence, not a novelty certificate or +an unpublished-work search. + +## Open next questions + +- Determine a smallest permutation carrier under an explicit admissible + action class. Start with the natural q-point orbit and an H quotient orbit; + the linear optimum here need not be a permutation representation. +- Determine the smallest faithful carrier in the excluded address + characteristic p. Start with the F3/S3 fixture and account for the complete + group-algebra radical; the averaging inverse and proof here do not apply. +- Bind one actual formal-word checker to this carrier, including its coefficient + field and every basis column, then measure its complete costs. Algebraic + dimension reduction alone establishes no runtime speedup. + +## Credit and limitations + +Credit Ali Romman #5394 for the formal/natural distinction and order-21 alias, +retaining Cinna Davis #2011's order-21 model, the Q8 comparison and +JoyboyBrian's formal support lineage. They are cited background rather than +replay targets. Translation averaging, finite-field character orthogonality, +cyclic group algebras and Cayley-Hamilton are classical. No predecessor +package supplies the main construction or coefficient inverse used here. + +The optimum permits arbitrary linear matrices. It does not price their +realization as permutations, recursive native operations or physical tapes. +Precision, source preparation, routing, ownership, dirty restoration, +compiler closure, complete invoices, outer use and all five selected +assumptions remain. No selected scientific replay, Lean, Docker, native +execution or complete multiplication theorem is claimed. Independent human +and formal proof-kernel review are unclaimed. diff --git a/research/affine-algebra-minimal-carrier/SOURCES.json b/research/affine-algebra-minimal-carrier/SOURCES.json new file mode 100644 index 0000000000..95aa3a7554 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/SOURCES.json @@ -0,0 +1,24 @@ +{ + "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/group-subproduct-cover/README.md", + "usage": "provenance", + "git_blob": "36faba920c546d36f3a51a026e8e84d925acf723", + "sha256": "b9241c29301d2d20af35fe9f09ff2b0e7e7aca0566394b8e4c7708924e59d161" + } + ] +} diff --git a/research/affine-algebra-minimal-carrier/TASK.json b/research/affine-algebra-minimal-carrier/TASK.json new file mode 100644 index 0000000000..e9cb743e14 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/TASK.json @@ -0,0 +1,81 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. 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": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "changed", + "actual_scope": "Smallest faithful linear carrier for K[F_q semidirect H], over every coefficient field of characteristic different from that of F_q.", + "scope_change_reason": "Replace paid-word synthesis with a self-contained algebraic side result: make finite formal-identity checks smaller and coefficient-faithful. No native supplier is constructed.", + "bottleneck_link": "Exact formal-versus-natural equality is an interface obligation for nonabelian word searches. This result reduces the faithful finite carrier and supplies a coefficient decoder; physical and recursive costs remain open.", + "budget_minutes": 60, + "stop_rule": "Stop at the first explicit smaller faithful carrier with a matching dimension lower bound and exact finite corroboration.", + "outcome": "completed", + "evidence": "PROOF.md; warning-strict normal/optimized verify.py; 54 coefficient contexts with zero errors. No predecessor scientific verifier replayed.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "What is the smallest faithful permutation carrier in a specified action class?", + "why_it_matters": "This distinguishes the linear optimum from a possible native address action.", + "first_step": "Compare the natural F_q orbit plus a quotient H orbit.", + "blocked_by": "No admissible physical/permutation action class or complete cost is fixed." + }, + { + "question": "What is the minimum in address characteristic p?", + "why_it_matters": "The present explicit inverse requires division by q.", + "first_step": "Classify the group-algebra radical for the F3/S3 boundary fixture.", + "blocked_by": "The translation-average argument does not apply." + }, + { + "question": "Can one complete formal-word checker use the new carrier profitably?", + "why_it_matters": "Carrier dimension alone is not a runtime comparison.", + "first_step": "Pin one checker and preserve every coefficient field and basis column.", + "blocked_by": "No source-bound implementation or measured complete invoice is supplied." + } + ], + "environment": { + "python": "3.12.15", + "dependencies": "standard library only" + }, + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19592134" +} diff --git a/research/affine-algebra-minimal-carrier/VERIFY.json b/research/affine-algebra-minimal-carrier/VERIFY.json new file mode 100644 index 0000000000..9c7e899c58 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/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": "Exact carrier group products, natural/augmentation/hybrid span ranks, complete basis recovery, rational line inverse, kernel basis and rejection controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact carrier group products, natural/augmentation/hybrid span ranks, complete basis recovery, rational line inverse, kernel basis and rejection controls." + } + ] +} diff --git a/research/affine-algebra-minimal-carrier/carrier.py b/research/affine-algebra-minimal-carrier/carrier.py new file mode 100644 index 0000000000..0e0d402871 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/carrier.py @@ -0,0 +1,185 @@ +"""Bounded exact affine carriers; no predecessor code or external dependencies.""" + +SPECS = { + "F2": (2, (0, 1)), "F3": (3, (0, 1)), + "F4": (2, (1, 1, 1)), "F5": (5, (0, 1)), + "F7": (7, (0, 1)), "F8": (2, (1, 1, 0, 1)), + "F9": (3, (1, 0, 1)), +} + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def digits(value, prime, degree): + result = [] + for _ in range(degree): + result.append(value % prime) + value //= prime + return result + + +def encode(coefficients, prime): + result = 0 + for coefficient in reversed(coefficients): + result = result * prime + coefficient % prime + return result + + +def product(left, right, prime, modulus): + degree = len(modulus) - 1 + a, b = digits(left, prime, degree), digits(right, prime, degree) + c = [0] * (2 * degree - 1) + for i in range(degree): + for j in range(degree): + c[i + j] += a[i] * b[j] + for i in range(2 * degree - 2, degree - 1, -1): + lead = c[i] % prime + for j in range(degree + 1): + c[i - degree + j] -= lead * modulus[j] + return encode(c[:degree], prime) + + +class Field: + __slots__ = ("name", "prime", "size", "add", "mul", "neg") + + def __init__(self, name, prime, size, add, mul, neg): + self.name = name + self.prime = prime + self.size = size + self.add = add + self.mul = mul + self.neg = neg + + +def field(name): + require(name in SPECS, "unsupported finite field") + prime, modulus = SPECS[name] + degree = len(modulus) - 1 + size = prime ** degree + values = [digits(x, prime, degree) for x in range(size)] + add = tuple(tuple(encode([values[x][i] + values[y][i] + for i in range(degree)], prime) + for y in range(size)) for x in range(size)) + mul = tuple(tuple(product(x, y, prime, modulus) + for y in range(size)) for x in range(size)) + neg = tuple(encode([-v for v in values[x]], prime) for x in range(size)) + require(all(any(mul[x][y] == 1 for y in range(1, size)) + for x in range(1, size)), "field contains a nonunit") + return Field(name, prime, size, add, mul, neg) + + +def subgroup(f, order): + require(type(order) is int and 1 <= order < f.size + and (f.size - 1) % order == 0, "invalid subgroup order") + for generator in range(1, f.size): + powers, value = [], 1 + for _ in range(order): + powers.append(value) + value = f.mul[value][generator] + if value == 1 and len(set(powers)) == order: + return tuple(powers) + raise ValueError("subgroup generator not found") + + +def elements(f, h): + return tuple((a, b) for a in h for b in range(f.size)) + + +def compose(f, left, right): + a, b = left + c, d = right + return f.mul[a][c], f.add[b][f.mul[a][d]] + + +def natural(f, g): + a, b = g + return tuple(f.add[f.mul[a][x]][b] for x in range(f.size)) + + +def zero_matrix(size): + return [[0] * size for _ in range(size)] + + +def matrices(f, h, g): + """Return natural, augmentation, and augmented/quotient carrier matrices.""" + permutation = natural(f, g) + q, order = f.size, len(h) + nat, aug = zero_matrix(q), zero_matrix(q - 1) + hybrid = zero_matrix(q + order - 1) + for x, y in enumerate(permutation): + nat[y][x] = 1 + for x in range(1, q): + for y in range(1, q): + entry = int(permutation[x] == y) - int(permutation[0] == y) + aug[y - 1][x - 1] = entry + hybrid[y - 1][x - 1] = entry + for i, a in enumerate(h): + j = h.index(f.mul[g[0]][a]) + hybrid[q - 1 + j][q - 1 + i] = 1 + return nat, aug, hybrid + + +def linear_combination(mats, coefficients, modulus): + require(len(mats) == len(coefficients) and len(mats) <= 72, + "coefficient length mismatch") + size = len(mats[0]) + require(1 <= size <= 16, "matrix capacity exceeded") + return [[sum(c * matrix[i][j] for c, matrix in zip(coefficients, mats)) + % modulus for j in range(size)] for i in range(size)] + + +def recover(f, h, matrix, modulus): + """Invert the hybrid algebra map using affine line sums, with no H division.""" + q, order = f.size, len(h) + require(modulus in (2, 3, 5, 7) and q % modulus != 0, + "unsupported coefficient characteristic") + size = q + order - 1 + require(len(matrix) == size and all(len(row) == size for row in matrix), + "wrong carrier matrix shape") + require(all(type(x) is int for row in matrix for x in row), + "noninteger carrier entry") + require(all(matrix[i][j] % modulus == 0 + for i in range(size) for j in range(size) + if (i < q - 1) != (j < q - 1)), "mixed carrier blocks") + sums = [matrix[q - 1 + a][q - 1] % modulus for a in range(order)] + total, invq = sum(sums) % modulus, pow(q, -1, modulus) + difference = [[0] + list(row[:q - 1]) for row in matrix[:q - 1]] + difference.insert(0, [0] + [-sum(matrix[i][j] for i in range(q - 1)) + for j in range(q - 1)]) + nat = zero_matrix(q) + for y in range(q): + first = (total - sum(difference[y])) * invq % modulus + nat[y] = [(first + difference[y][x]) % modulus for x in range(q)] + result = [] + for i, a in enumerate(h): + for b in range(q): + line = sum(nat[f.add[f.mul[a][x]][b]][x] for x in range(q)) + result.append((line - total + sums[i]) * invq % modulus) + # This is a decoder for the algebra image, not for arbitrary block matrices. + mats = [matrices(f, h, g)[2] for g in elements(f, h)] + require(linear_combination(mats, result, modulus) + == [[x % modulus for x in row] for row in matrix], + "matrix is outside the carrier algebra") + return result + + +def rank(vectors, modulus): + """Finite row elimination; at most 72 vectors of length at most 256.""" + require(len(vectors) <= 72 and all(len(v) <= 256 for v in vectors), + "rank capacity exceeded") + pivots = {} + for vector in vectors: + row = [x % modulus for x in vector] + for pivot, basis in sorted(pivots.items()): + coefficient = row[pivot] + if coefficient: + row = [(x - coefficient * y) % modulus + for x, y in zip(row, basis)] + pivot = next((i for i, x in enumerate(row) if x), None) + if pivot is not None: + inverse = pow(row[pivot], -1, modulus) + pivots[pivot] = [x * inverse % modulus for x in row] + return len(pivots) diff --git a/research/affine-algebra-minimal-carrier/verify.py b/research/affine-algebra-minimal-carrier/verify.py new file mode 100644 index 0000000000..816a20e684 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/verify.py @@ -0,0 +1,206 @@ +"""Exact finite corroboration of the written all-field carrier theorem.""" + +import argparse +import hashlib +import json +import sys +from fractions import Fraction +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import carrier as c + + +PACKAGE_FILES = ("PROOF.md", "README.md", "SOURCES.json", "TASK.json", + "VERIFY.json", "carrier.py", "verify.py") + + +def flatten(matrix): + return [x for row in matrix for x in row] + + +def multiply(left, right): + size = len(left) + result = c.zero_matrix(size) + for i in range(size): + for k in range(size): + if left[i][k]: + for j in range(size): + result[i][j] += left[i][k] * right[k][j] + return result + + +def check_field(f): + q = f.size + for x in range(q): + for y in range(q): + c.require(f.add[x][y] == f.add[y][x], "addition symmetry") + c.require(f.mul[x][y] == f.mul[y][x], "multiplication symmetry") + for z in range(q): + c.require(f.add[f.add[x][y]][z] == f.add[x][f.add[y][z]], + "addition associativity") + c.require(f.mul[f.mul[x][y]][z] == f.mul[x][f.mul[y][z]], + "multiplication associativity") + c.require(f.mul[x][f.add[y][z]] + == f.add[f.mul[x][y]][f.mul[x][z]], "distributivity") + c.require(f.add[x][0] == x and f.mul[x][1] == x + and f.add[x][f.neg[x]] == 0, "field identities") + return q ** 3 + + +def check_group(f, h, group, hybrid): + lookup = {g: i for i, g in enumerate(group)} + c.require(len({c.natural(f, g) for g in group}) == len(group), + "natural group action is not faithful") + for i, left in enumerate(group): + for j, right in enumerate(group): + result = c.compose(f, left, right) + c.require(multiply(hybrid[i], hybrid[j]) == hybrid[lookup[result]], + "hybrid representation product") + a, b = c.natural(f, left), c.natural(f, right) + c.require(tuple(a[b[x]] for x in range(f.size)) + == c.natural(f, result), "literal affine action product") + return len(group) ** 2 + + +def check_context(f, h, group, natural, aug, hybrid, modulus): + count, order = len(group), len(h) + expected = (count - order + 1, count - order, count) + observed = tuple(c.rank([flatten(m) for m in bank], modulus) + for bank in (natural, aug, hybrid)) + c.require(observed == expected, "algebra span rank mismatch") + recovered = 0 + for i, matrix in enumerate(hybrid): + coefficients = [int(j == i) for j in range(count)] + c.require(c.recover(f, h, matrix, modulus) == coefficients, + "basis coefficient reconstruction") + recovered += 1 + for seed in range(12): + coefficients = [(seed * i * i + i + seed // 3) % modulus + for i in range(count)] + image = c.linear_combination(hybrid, coefficients, modulus) + c.require(c.recover(f, h, image, modulus) == coefficients, + "mixed coefficient reconstruction") + recovered += 1 + # Every stated kernel basis has all coefficients enumerated explicitly. + for a in range(1, order): + coefficients = [0] * count + for b in range(f.size): + coefficients[b] = -1 + coefficients[a * f.size + b] = 1 + c.require(not any(flatten(c.linear_combination(natural, coefficients, + modulus))), + "natural kernel basis is not null") + c.require(any(flatten(c.linear_combination(hybrid, coefficients, modulus))), + "hybrid lost a natural kernel direction") + return {"field": f.name, "subgroup_order": order, "characteristic": modulus, + "regular_dimension": count, "carrier_dimension": len(hybrid[0]), + "ranks_natural_augmentation_hybrid": list(observed), + "coefficient_vectors_recovered": recovered, + "kernel_basis_vectors": order - 1} + + +def rejects(function, expected): + try: + function() + except ValueError as error: + c.require(str(error) == expected, "unexpected rejection reason") + return 1 + raise ValueError("missing rejection: " + expected) + + +def rational_lines(f, h, group, natural): + """Separate uncompressed rational oracle for the affine line inverse.""" + for seed in range(4): + coefficients = [Fraction(i * i - seed, seed + 1) + for i in range(len(group))] + matrix = [[sum(coefficient * m[y][x] + for coefficient, m in zip(coefficients, natural)) + for x in range(f.size)] for y in range(f.size)] + sums = {a: sum(coefficients[i] for i, (t, _) in enumerate(group) if t == a) + for a in h} + total = sum(coefficients) + for i, (a, b) in enumerate(group): + line = sum(matrix[f.add[f.mul[a][x]][b]][x] for x in range(f.size)) + recovered = (line - total + sums[a]) / f.size + c.require(recovered == coefficients[i], "rational line inverse") + return 4 * len(group) + + +def controls(): + f, h = c.field("F3"), (1, 2) + group = c.elements(f, h) + bank = [c.matrices(f, h, g)[2] for g in group] + # The excluded translation characteristic actually destroys this construction. + modular_rank = c.rank([flatten(m) for m in bank], 3) + c.require(modular_rank < len(group), "excluded characteristic control") + total = 1 + total += rejects(lambda: c.field("F6"), "unsupported finite field") + total += rejects(lambda: c.subgroup(f, 3), "invalid subgroup order") + total += rejects(lambda: c.subgroup(f, True), "invalid subgroup order") + total += rejects(lambda: c.recover(f, h, bank[0], 3), + "unsupported coefficient characteristic") + total += rejects(lambda: c.recover(f, h, [[1]], 2), + "wrong carrier matrix shape") + bad = [row[:] for row in bank[0]] + bad[0][2] = 1 + total += rejects(lambda: c.recover(f, h, bad, 2), "mixed carrier blocks") + bad = [row[:] for row in bank[0]] + bad[2][3] = 1 + total += rejects(lambda: c.recover(f, h, bad, 2), + "matrix is outside the carrier algebra") + total += rejects(lambda: c.linear_combination(bank, [1], 2), + "coefficient length mismatch") + return total, modular_rank + + +def run(): + rows, group_pairs, field_triples, rational_coefficients = [], 0, 0, 0 + for name in c.SPECS: + f = c.field(name) + field_triples += check_field(f) + for order in range(1, f.size): + if (f.size - 1) % order: + continue + h = c.subgroup(f, order) + group = c.elements(f, h) + triples = [c.matrices(f, h, g) for g in group] + natural, aug, hybrid = ([t[i] for t in triples] for i in range(3)) + group_pairs += check_group(f, h, group, hybrid) + rational_coefficients += rational_lines(f, h, group, natural) + for modulus in (2, 3, 5, 7): + if modulus != f.prime: + rows.append(check_context(f, h, group, natural, aug, + hybrid, modulus)) + control_count, excluded_rank = controls() + package = Path(__file__).resolve().parent + hashes = {name: hashlib.sha256((package / name).read_bytes()).hexdigest() + for name in PACKAGE_FILES} + return {"status": "PASS_AFFINE_ALGEBRA_MINIMAL_CARRIER", "errors": 0, + "contexts": len(rows), "group_product_pairs": group_pairs, + "field_triples": field_triples, "controls": control_count, + "rational_coefficients_recovered": rational_coefficients, + "excluded_F3_S3_rank": excluded_rank, "results": rows, + "package_sha256": hashes} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--receipt", type=Path) + args = parser.parse_args() + if args.receipt is not None: + destination = args.receipt.resolve() + checkout = Path(__file__).resolve().parents[2] + c.require(not destination.is_relative_to(checkout), + "receipt must be outside the checkout") + result = run() + rendered = json.dumps(result, sort_keys=True, indent=2) + "\n" + if args.receipt is not None: + with destination.open("x", encoding="utf-8") as stream: + stream.write(rendered) + print(rendered, end="") + print("PASS_AFFINE_ALGEBRA_MINIMAL_CARRIER") + + +if __name__ == "__main__": + main()