Prove prime-exponent group labels need one rank unit per target (no new κ)

research/prime-exponent-rank-cut/PROOF.md

@@ -0,0 +1,141 @@
+# A representation rank cut for diagonal group-label targets
+
+Nick Petalas. Apache-2.0.
+
+## 1. Model
+
+Use the model of Ali Romman's `research/group-subproduct-cover` (PR #5394),
+section 1, unchanged. K is any field and G any group with identity e. A
+circuit has finitely many registers. Free operations are fixed scalar
+matrices over K. They may be rectangular or singular, and they may copy,
+clear or discard registers. A paid gate on R registers is
+
+    D(N,g) = (I_R - N)[e] + N[g],      N in M_R(K).
+
+The rank-charged cost of a word is sum_j rank(N_j). The rank-one count is
+the number of gates when every N_j has rank at most one. The idempotent
+condition is allowed but not used. The target is the data block
+diag([t_1],...,[t_d]). Repeated entries are allowed. For the lower bound,
+workspace may change arbitrarily, with clean or dirty initial values.
+
+## 2. The cut
+
+For a matrix representation rho: G -> GL_m(K') over an extension field
+K' of K, put
+
+    r_rho(g) = rank_{K'}(rho(g) - I_m).
+
+**Theorem 1.** Let C_0 D(N_1,g_1) C_1 ... D(N_k,g_k) C_k realize the
+data block diag([t_1],...,[t_d]). Then
+
+    sum_i r_rho(t_i)  <=  sum_j rank(N_j) * r_rho(g_j).
+
+*Proof.* Extend rho linearly to an algebra homomorphism K[G] -> M_m(K').
+Apply it entrywise to a matrix over K[G]. This map is multiplicative on
+block matrices and commutes with taking the data-row/data-column submatrix.
+A scalar matrix C becomes C (x) I_m. The gate becomes
+
+    I (x) I_m + N_j (x) (rho(g_j) - I_m).
+
+Its second term has rank rank(N_j) * r_rho(g_j). Write A_j for the image of
+C_j and B_j for that second term. Then the image of the circuit is
+A_0 (I + B_1) A_1 ... (I + B_k) A_k. Expand it one gate at a time,
+replacing (I + B_j) by I from the left:
+
+    image - A_0 A_1 ... A_k = sum_j A_0 ... A_{j-1} B_j A_j (I+B_{j+1}) ... A_k,
+
+where gates 1..j-1 have already been replaced by I. Each summand has rank
+at most rank(B_j). Rank is subadditive, so the left side has rank at most
+sum_j rank(N_j) r_rho(g_j).
+
+Apply the augmentation map [g] -> 1 entrywise. Every gate maps to I, so the
+circuit maps to C_0 C_1 ... C_k. The target maps to I_d. Its data block is
+therefore I_d, and the data block of A_0 ... A_k is I_d (x) I_m. The data
+block of the image is diag(rho(t_1),...,rho(t_d)). The data block of the
+difference has rank sum_i r_rho(t_i). A submatrix has rank at most the
+rank of the whole matrix. QED.
+
+The telescoping step is not new. This account's PR #5202
+(`research/order21-normal-tariff`) used it for one F2 representation of
+the order-21 group, and `research/cut58-separable-query-floor` uses a
+character twist. Theorem 1 states it for an arbitrary representation, an
+arbitrary field and projectors of any rank.
+
+## 3. The regular representation over K itself
+
+Let G be finite and let rho be the left regular permutation representation
+over K. A permutation matrix P has (P - I)v = 0 exactly when v is constant
+on every cycle. In every characteristic the kernel has dimension equal to
+the number of cycles. Left multiplication by g has |G|/ord(g) cycles, each
+of length ord(g). Hence
+
+    r_reg(g) = |G| (1 - 1/ord(g))      over every field.
+
+**Corollary 2.** Over every field, for every finite group and alphabet,
+
+    sum_i (1 - 1/ord(t_i))  <=  sum_j rank(N_j) (1 - 1/ord(g_j)).
+
+In particular, the rank-charged cost is at least
+sum_i (1 - 1/ord(t_i)) / (1 - 1/M), where M is the largest order of a paid
+label.
+
+## 4. Prime exponent
+
+**Corollary 3.** Let G have prime exponent p: every nonidentity element
+has order p. G may be nonabelian. Let K be any field and take any
+finite clean or dirty scalar workspace. Any diagonal target with d
+nonidentity entries, repetitions allowed and identity entries ignored,
+has
+
+    rank-charged cost >= d,      rank-one count >= d.
+
+If every target label is allowed, d direct rank-one coordinate gates attain
+both bounds. The exact rank-one count and the exact rank-charged cost are
+then both d.
+
+*Proof.* Identity entries and identity labels contribute zero to both sides
+of Corollary 2. Every other term is 1 - 1/p. Divide by 1 - 1/p. The direct
+word puts N = E_ii with label t_i on data role i and touches nothing else. QED.
+
+**Answer for these groups.** By Ali Romman's cover theorem, the
+arbitrary-rank unit-cost count is the cover cost c_L(T). In a group of prime
+exponent, with every target label allowed, the rank-one count is d.
+Thus the rank-one count exceeds the relaxed cover cost exactly when
+c_L(T) < d. The gap can be exponential. Take G = (C_p)^n and all
+p^n - 1 nonidentity targets. Any word of length k has at most 2^k ordered
+subproducts. Words covering all of G exist, for example each basis
+vector repeated p-1 times, so c(T) <= n(p-1). For p = 2 the cover cost is
+exactly n and the rank-one count is 2^n - 1. The verifier computes the
+exact cover costs 2, 3 and 4 for (C2)^2, (C2)^3 and (C3)^2, with rank-one
+counts 3, 7 and 8. It also realizes the length-four basis cover of all 15
+nonidentity labels of (C2)^4 over F2.
+
+The nonabelian Heisenberg group of order p^3 (p odd) has exponent p, so
+Corollary 3 applies to it over every field. The verifier checks the order-27
+case.
+
+## 5. Relation to predecessors
+
+Wentao Li's `research/elementary-abelian-diagonal-minimum` proves the exact
+rank-one count t for F2[(C2)^k], using a graded image in m/m^2. Corollary 3
+contains that statement. It also adds every field, every prime p,
+nonabelian groups of prime exponent, repeated and rank-charged projectors,
+rectangular or singular free maps, and arbitrary workspace changes. Ali
+Romman's corollary for three distinct labels holds in every group. Corollary
+3 recovers it only for groups of prime exponent. Its two-call rank argument
+is not reused here.
+
+## 6. Scope limits
+
+Corollary 2 is the regular cut only. It is weaker when the labels have mixed
+orders. For three copies of a^2 in C4 it gives only 2 < 3; a different
+argument is needed there. In Q8, targets {i,j,k,-1} still get the bound 4.
+Other representations can do better. A faithful character of C_m over an
+extension of K with char K not dividing m gives r = 1 at every nonidentity
+element. Theorem 1 then gives rank-charged cost >= d for cyclic groups in
+those characteristics. That remark is proved by the same theorem but has no
+separate finite check here.
+
+The proved bill is an abstract gate count in the relaxed model. Physical
+group gates, scalar maps, source reads, precision, recursive children,
+hosting and cleanup are not priced. No complete kappa calculation changes.

research/prime-exponent-rank-cut/README.md

@@ -0,0 +1,109 @@
+# Prime-exponent group labels cost one rank unit per target
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+**Scoped proof with exact finite corroboration; no new κ.** This uses Ali
+Romman's relaxed group-gate model ([PR #5394](https://github.com/CrocSwap/integer-mult-bounds/pull/5394),
+`research/group-subproduct-cover`), unchanged. Let G be a group of prime
+exponent and K any field. Any diagonal target with d nonidentity entries,
+repetitions allowed, needs total projector rank at least d. Arbitrary
+finite clean or dirty scalar workspace and singular or rectangular free
+maps do not change this. The rank-one count is therefore exactly d whenever
+every target label is allowed.
+
+This answers that package's Open next question for these groups. The
+rank-one count exceeds the relaxed subproduct-cover cost exactly when the
+cover is shorter than d. The gap can be exponential: in (C2)^n, the
+2^n − 1 nonidentity labels have cover cost n and rank-one count 2^n − 1.
+
+## Method
+
+[PROOF.md](PROOF.md) proves a representation rank cut. For any
+representation ρ over an extension field,
+
+    Σ_i rank(ρ(t_i) − I)  ≤  Σ_j rank(N_j) · rank(ρ(g_j) − I).
+
+The left regular permutation representation over K itself has
+rank(ρ(g) − I) = |G|(1 − 1/ord g) in every characteristic. In a group of
+prime exponent every nonidentity label gives the same value, and the
+bound becomes d.
+
+## Evidence
+
+[verify.py](verify.py) uses only the standard library. It is read-only and
+uses no network or Git. It checks:
+
+- the regular defect rank formula for all 405 element/field pairs in
+  (C2)^2, (C2)^3, (C2)^4, (C3)^2, C5, the order-27 Heisenberg group, C4 and
+  Q8, over Q, F2, F3, F5 and F7;
+- 206 seeded random circuits with rectangular and singular free maps,
+  projectors of every rank, and any labels. Each circuit checks the
+  augmentation identity and multiplicativity of the entrywise regular image,
+  and that the cut holds;
+- exact cover costs 2, 3 and 4 for all nonidentity targets of (C2)^2, (C2)^3
+  and (C3)^2. For those groups, over Q, F2 and F3, it checks the attaining
+  cover word and the direct d-gate word, both with an untouched dirty role.
+  It also checks the length-4 basis cover of all 15 labels in (C2)^4 over F2;
+- five controls: a dropped cover letter, the C4 case where the regular cut
+  alone is weaker, Q8 with mixed orders, a zero identity defect, and a
+  rank-two projector.
+
+The finite checks corroborate the written proof. They do not replace its
+all-group, all-field argument.
+
+## Reproduce
+
+From the repository root, with CPython 3.12 (here
+`/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12`; any CPython 3.12
+works):
+
+```sh
+python3.12 -I -B -W error research/prime-exponent-rank-cut/verify.py
+python3.12 -I -O -B -W error research/prime-exponent-rank-cut/verify.py
+python3.12 -B scripts/research_package.py --package research/prime-exponent-rank-cut
+python3.12 -B scripts/check_research_commit.py --package research/prime-exponent-rank-cut --check-source-history
+```
+
+The verifier ends with
+`PASS_PRIME_EXPONENT_RANK_CUT regular_checks=405 random_circuits=206 separations=4 controls=5 no_new_kappa`.
+It runs in under a second locally. No receipt file is written. The printed
+JSON summary is the run record.
+
+## Limits
+
+This is an abstract count in an optimistic relaxed model. It does not price
+physical group gates, scalar maps, source reads, precision, recursive
+children, hosting or cleanup. The selected frontier and κ are unchanged.
+Groups without prime exponent are not settled. For three copies of a² in C4
+the regular cut alone gives 2, not 3. PROOF.md section 6 notes that
+faithful characters give the same d bound for cyclic groups when the
+characteristic does not divide the order; that remark has no separate
+finite check here. No independent human or formal proof-kernel review is
+claimed.
+
+## Credit and overlap
+
+- Ali Romman, [PR #5394](https://github.com/CrocSwap/integer-mult-bounds/pull/5394)
+  (`research/group-subproduct-cover`): model, cover theorem, the question,
+  and the all-group three-label rank-one floor. It is cited, not re-verified.
+- Wentao Li, `research/elementary-abelian-diagonal-minimum`: the rank-one
+  minimum t in F2[(C2)^k]. Corollary 3 contains that statement and extends
+  it to every field, every prime, nonabelian prime-exponent groups,
+  projectors of any rank and singular free maps.
+- Rank telescoping through a representation: this account's
+  [PR #5202](https://github.com/CrocSwap/integer-mult-bounds/pull/5202)
+  (`research/order21-normal-tariff`) and the character twist in
+  `research/cut58-separable-query-floor`.
+
+## Open next questions
+
+1. For groups without prime exponent, is the rank-one count always at least
+   the number of nonidentity entries? The first case is three copies of a²
+   in C4. The regular cut gives 2, and a top-coefficient argument may give 3.
+2. Which positive combination of permutation representations gives the
+   best cut for a fixed group and target, for example in D8 or Q8 over F2?
+   This is a finite linear program over transitive G-sets, and it is valid
+   in every characteristic.
+3. Does any physically realizable label family have prime exponent and a
+   priced native implementation? Without one, these counts do not move a
+   supplier bill.

research/prime-exponent-rank-cut/SOURCES.json

@@ -0,0 +1,42 @@
+{
+  "schema_version": 1,
+  "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8",
+      "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "research/group-subproduct-cover/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "308e63dcc668b0089b4a0c5152dda0733b01fed5",
+      "sha256": "7392dca9e7258dcdb4802a3c9f60cd8e5ccced271950a4ce2e4823f449586c00"
+    },
+    {
+      "path": "research/group-subproduct-cover/README.md",
+      "usage": "provenance",
+      "git_blob": "36faba920c546d36f3a51a026e8e84d925acf723",
+      "sha256": "b9241c29301d2d20af35fe9f09ff2b0e7e7aca0566394b8e4c7708924e59d161"
+    },
+    {
+      "path": "research/elementary-abelian-diagonal-minimum/README.md",
+      "usage": "provenance",
+      "git_blob": "32337254f5eb7f941d044ed08c3a815c75d685c0",
+      "sha256": "c6ec7fbe9848ba0c9fa0a914b0fbd8b40ce8d56ffff996ea61c6b7d3b57eeee4"
+    },
+    {
+      "path": "research/order21-normal-tariff/README.md",
+      "usage": "provenance",
+      "git_blob": "eaa7bb551ea8f212ac08d373cfd6602d39edd6ab",
+      "sha256": "bcf01e91ac59b3393479b70ddda9122f9848a26577fc0a4d35654e3b56af2786"
+    }
+  ]
+}

research/prime-exponent-rank-cut/TASK.json

@@ -0,0 +1,83 @@
+{
+  "schema_version": 1,
+  "task_id": "bit-new-register-model",
+  "priority_revision": 8,
+  "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810",
+  "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": "Answer Open next question 1 of PR #5394 (research/group-subproduct-cover) for groups of prime exponent: prove a representation rank cut in its relaxed group-gate model and show that any d nonidentity diagonal entries need total projector rank d over every field, with arbitrary finite scalar workspace.",
+  "scope_change_reason": "The card asks whether a larger or nonabelian register model escapes the three-register obstruction. This package takes the explicitly open four-or-more-target question of the arbitrary-rank group-gate model from PR #5394 and settles it for every group of prime exponent, including nonabelian ones.",
+  "bottleneck_link": "Side result. It closes multi-target sharing below one rank unit per target for prime-exponent labels in the relaxed model, before any native compiler search. No supplier bill changes.",
+  "budget_minutes": 60,
+  "stop_rule": "Ship the written cut and the prime-exponent corollary with finite corroboration; do not search non-prime-exponent groups or build a native supplier.",
+  "outcome": "completed",
+  "evidence": "PROOF.md gives the all-field, all-group representation rank cut and the prime-exponent corollary. verify.py checks 405 regular defect ranks over Q, F2, F3, F5 and F7, 206 random circuits with rectangular and singular free maps, exact cover costs 2/3/4 with attaining words, the 15-label (C2)^4 basis cover and five controls.",
+  "author": "Nick Petalas",
+  "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.",
+  "open_questions": [
+    {
+      "question": "For groups without prime exponent, is the rank-one count always at least the number of nonidentity diagonal entries?",
+      "why_it_matters": "The regular cut is weaker with mixed element orders; three copies of a^2 in C4 get only 2.",
+      "first_step": "Prove or refute rank-one count 3 for diag([a^2],[a^2],[a^2]) in C4 over F2 with arbitrary workspace, using top subproduct coefficients.",
+      "blocked_by": "No cut stronger than the permutation-representation cut is proved for mixed orders."
+    },
+    {
+      "question": "Which positive combination of permutation representations gives the best cut for a fixed group and target?",
+      "why_it_matters": "Permutation cuts are valid in every characteristic, including p-groups in characteristic p.",
+      "first_step": "Solve the finite linear program over transitive G-sets for D8 or Q8 and compare with exact small-workspace counts.",
+      "blocked_by": "The linear program and matching constructions are not computed here."
+    },
+    {
+      "question": "Does a physically realizable prime-exponent label family have a priced native implementation?",
+      "why_it_matters": "Only a physical implementation could change a supplier bill.",
+      "first_step": "Specify the address action, routing and restoration of one producer/consumer pair and charge every operation.",
+      "blocked_by": "No native boundary contract or complete cost model is supplied."
+    }
+  ],
+  "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19227703",
+  "claim_type": "scoped proof with exact finite corroboration",
+  "environment": {
+    "python": "CPython 3.12.15",
+    "platform": "macOS arm64",
+    "dependencies": "standard library only"
+  }
+}