From efc8f93d1d3c911f61784c70a4feb6ed7b372b43 Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Sat, 24 Oct 2026 15:29:36 -0500 Subject: [PATCH] Prove a shared-D controller rank loss with helper reuse --- .../PORTABILITY.json | 23 + research/reused-d-helper-rank-bound/PROOF.md | 183 +++++++ research/reused-d-helper-rank-bound/README.md | 96 ++++ .../reused-d-helper-rank-bound/RESULT.json | 479 ++++++++++++++++++ .../reused-d-helper-rank-bound/SOURCES.json | 42 ++ research/reused-d-helper-rank-bound/TASK.json | 96 ++++ .../reused-d-helper-rank-bound/VALIDATION.md | 59 +++ .../reused-d-helper-rank-bound/VERIFY.json | 35 ++ research/reused-d-helper-rank-bound/verify.py | 233 +++++++++ 9 files changed, 1246 insertions(+) create mode 100644 research/reused-d-helper-rank-bound/PORTABILITY.json create mode 100644 research/reused-d-helper-rank-bound/PROOF.md create mode 100644 research/reused-d-helper-rank-bound/README.md create mode 100644 research/reused-d-helper-rank-bound/RESULT.json create mode 100644 research/reused-d-helper-rank-bound/SOURCES.json create mode 100644 research/reused-d-helper-rank-bound/TASK.json create mode 100644 research/reused-d-helper-rank-bound/VALIDATION.md create mode 100644 research/reused-d-helper-rank-bound/VERIFY.json create mode 100644 research/reused-d-helper-rank-bound/verify.py diff --git a/research/reused-d-helper-rank-bound/PORTABILITY.json b/research/reused-d-helper-rank-bound/PORTABILITY.json new file mode 100644 index 0000000000..098745d6ae --- /dev/null +++ b/research/reused-d-helper-rank-bound/PORTABILITY.json @@ -0,0 +1,23 @@ +{ + "status": "PASS_READ_ONLY_GIT_FREE_EXPORT", + "python": "Python 3.12.14", + "files": 11, + "all_hashes_unchanged": true, + "empty_path": true, + "checks": [ + { + "optimized": false, + "exit_code": 0, + "seconds": 0.23, + "stdout": "PASS_SHARED_D_HELPER_REUSE_RANK_BOUND {\"attaining_examples\": 13, \"controls\": 4, \"source_gap\": 1617}", + "stderr": "" + }, + { + "optimized": true, + "exit_code": 0, + "seconds": 0.33, + "stdout": "PASS_SHARED_D_HELPER_REUSE_RANK_BOUND {\"attaining_examples\": 13, \"controls\": 4, \"source_gap\": 1617}", + "stderr": "" + } + ] +} diff --git a/research/reused-d-helper-rank-bound/PROOF.md b/research/reused-d-helper-rank-bound/PROOF.md new file mode 100644 index 0000000000..31afa79e16 --- /dev/null +++ b/research/reused-d-helper-rank-bound/PROOF.md @@ -0,0 +1,183 @@ +# A shared-D rank obstruction with productive helper reuse + +## Exact alphabet and endpoint + +Work over a field of characteristic two and in the ring +`F[q,d]/(q^2,d^2)`. Both symbols commute with all scalar matrices. Put +`Q=I+q` and `D=I+d`. The required endpoint on n main fields is +`I_n+q I_n+d I_n+qd I_n`. The theorem requires equality of all four +coefficients. It also applies to an operator representation in which those +four coefficients are independent. It does not assume that an arbitrary +representation has that property. + +There are f FULL calls. A source FULL has v main pairs. FULL i also reuses +s_i autonomous full-rank helper fields, and has normalized coefficients + +```text +I + d E_i + q N_i + qd N_i. +``` + +The exact hypotheses are: + +```text +E_i^2=E_i, rank(E_i)=2v+s_i, +E_i N_i=N_i E_i=N_i, rank(E_i+N_i)=2v. +``` + +They hold for a main block made of v nilpotent two-by-two query blocks and +s_i independent QD helper directions, after any constant scalar conjugation. +The full proof below only needs the displayed support and rank conditions. +It permits mixing across ports, rather than requiring separate port matrices. + +Each thin letter is `I+q T_j`. Let h be the total paid H1 count of these letters, +with `sum_j rank(T_j)<=h`. A usual v-port thin packet has rank at most v and +costs v H1 calls. General thin matrices with that funded rank condition are +allowed. They give no additional productive targets. + +Ordinary scalar changes of basis independent of q and d can occur between +calls. At q=d=0 their total product must be identity. Moving those constants +to the boundary conjugates the displayed matrices and preserves every rank +hypothesis. Operator-valued free changes of basis are outside the alphabet. + +## Rank theorem + +Write `s=sum_i s_i` and `M=2vf+s`. Comparing the d and q coefficients gives + +```text +sum_i E_i = I_n, +sum_i N_i + sum_j T_j = I_n. +``` + +Thus `M>=n`. Factor each projector as `E_i=U_i V_i`, where U_i has +`2v+s_i` columns and `V_i U_i=I_(2v+s_i)`. Put +`B_i=V_i(E_i+N_i)U_i`. The support identity gives +`E_i+N_i=U_i B_i V_i`, and `rank(B_i)=2v`. + +Stack all U_i horizontally into U, all V_i vertically into V, and all B_i +as diagonal blocks in B. Then + +```text +UV=I_n, rank(U)=rank(V)=n, rank(B)=2vf. +``` + +The rank inequality for a product through the M-dimensional middle space gives + +```text +rank(U B V) >= rank(U)+rank(B)+rank(V)-2M + = 2n-2vf-2s. +``` + +In characteristic two, the coefficient equations also give + +```text +U B V = sum_i(E_i+N_i) = sum_j T_j. +``` + +The last sum has rank at most h. Therefore every word in the stated alphabet +satisfies both necessary inequalities + +```text +M=2vf+s >= n, h >= 2n-2vf-2s. (1) +``` + +This proof is independent of word order, a simplex construction, a search size +or the mixed qd equation. It does not say that (1) is sufficient for a word. +It is an application of the classical rank inequality, not a new rank theorem +for arbitrary matrix products. + +When no helper is reused and n=v n0, divide (1) by v to get +`2f>=n0` and `h/v>=2n0-2f`. The proposed family +`n0=2p`, `f=p+2`, `h/v=p-1` can therefore exist only for `p<=3`. +Its favorable unrestrained rank surplus is `48p-3123`, positive only for +`p>=66`. The two necessary conditions have no common value. A positive price +for that unrestrained family does not supply a controller. + +## Complete rank-mass consequence + +Assume each FULL source has paid rank mass equal to its autonomous helper +rank mass plus `2va+delta`, where `a>=1` and `delta>0`. A main target has +rank a+1. The integer a is distinct from the formal nilpotent d. +Each reused helper was a productive target of rank a+1, so it must +be debited once. Thin letters cost h rank-one jobs. All other source helper +credits remain. The complete target-minus-paid rank surplus is + +```text +Delta_1 = (a+1)n - (2va+delta)f - (a+1)s - h + <= (a-1)(n-M) - delta f + <= -delta f < 0. (2) +``` + +The last strict inequality holds for a nonempty target, which forces f>0. +The loss holds for unequal s_i, partial-port helper reuse, and arbitrary +constant scalar coupling. It does not require s_i to be a multiple of v. +Added ordinary work cannot remove this raw invoice loss. + +For the retained compact BIT profile, the authenticated source receipt gives + +```text +v=111, a=7, +paid={1:1319,2:1342,3:78,4:39,5:102,6:10,7:18}, mass=5089, +helpers={4:4,8:432}, mass=3472, +5089-3472=1617=2*111*7+63. +``` + +Thus delta=63. Reuse is limited to the 432 autonomous H8 fields of each source +call. The four H4 helpers stay productive. The theorem remains a favorable +relaxation of any more restrictive physical matching or chart rules. +The source's actual controller uses distinct fresh D blocks and has positive +rank surplus 753. It is outside this theorem. The verifier checks that source +invoice as a control against applying the conclusion to the retained caller. + +## Every retained power moment loses + +Let `0<=t<=1` and let `Delta_t=T_t-P_t`, where an H_r job costs r^t. +Every paid job has rank at most eight. All targets have rank eight except +exactly four H4 helper targets per FULL. Therefore + +```text +P_t >= 8^(t-1) P_1, +T_t = 8^(t-1) T_1 + 4f(4^t-4*8^(t-1)). +``` + +Combining this with (2) gives + +```text +Delta_t <= -f*8^(t-1)*(79-32*2^(-t)) + <= -47f*8^(t-1) < 0. (3) +``` + +This uses the exact inequality `2^(-t)<=1`, not numerical root samples. +It handles the four partial helper targets rather than treating them as H8. +It rules out a favorable raw power moment for this source and alphabet even +before ordinary, storage, precision, compiler or outer costs are added. +It gives no new multiplication exponent and no claim about all BIT callers. + +## Attaining examples and checks + +For one port and one FULL, take a block of size r+2. Let E be identity. +Let N be `J2(0)` on the first pair and identity on the other r directions. +Use two thin nilpotents, `[[0,0],[1,0]]` and `[[1,1],[1,1]]`, on that pair. +The first pair of N is `[[0,1],[0,0]]`. The three query coefficients sum to E. +The chronological word FULL, first thin, second thin has all four endpoint +coefficients equal to identity. It has `M=n=r+2` and two thin calls, so both +rank inequalities are equalities. Direct sums give unequal r values and any +number of FULL blocks. Taking v parallel copies gives the native port count; +the target and debit scale together. These are exact alphabet examples, not +new physical native suppliers. + +The standard-library checker tests 13 such words, including direct sums up to +256 streams per port and r=1,2,3 productive-helper examples. It checks projector, +support, defect and thin ranks before multiplying all four coefficients. +Removing any one call from the r=1 word fails its endpoint; dropping the FULL +qd coefficient also fails. Omitting 111 recycled-H8 debits would turn the +true surplus -63 into a false +825, so the productive debit is material. +Integer relaxations also check non-multiple-of-111 helper counts against (2). +The source's local paid/helper profile is joined to its complete retained +18-FULL invoice. The shared signed-invoice checker confirms that the attaining +examples cost more than direct evaluation under every increasing concave tariff. +The written proof establishes (1)-(3); finite examples do not replace it. + +Changed native calls, productive thin jobs, uncharged helper losses, several +fresh D variables, operator-valued free codes and different coefficient +algebras require new arguments. Neither a universal circuit obstruction nor +formal verification of the multiplication theorem is claimed. diff --git a/research/reused-d-helper-rank-bound/README.md b/research/reused-d-helper-rank-bound/README.md new file mode 100644 index 0000000000..9c39d92fde --- /dev/null +++ b/research/reused-d-helper-rank-bound/README.md @@ -0,0 +1,96 @@ +# Shared-D controllers lose after productive helper reuse is charged + +This scoped proof rules out a favorable raw power moment for one exact +characteristic-two FULL/THIN alphabet built from the retained compact BIT +source. It permits arbitrary scalar coupling, every call order, and reuse of +full-rank productive helpers. It does not use a fixed query simplex or a finite +search exclusion. No new kappa or supplier is constructed. + +The required endpoint is QD on n fields with a single shared D. If f FULL calls +have v source main pairs each, s is the total number of reused H_(a+1) helpers, +and h is the funded thin H1 count, the proof gives + +```text +M=2vf+s >= n, +h >= 2n-2vf-2s, +Delta_1 <= (a-1)(n-M)-delta*f < 0. +``` + +Here delta is the source's paid rank mass minus its helper mass and 2va. +The integer a is distinct from the formal nilpotent d. +The FULL coefficient conditions and permitted scalar bases are explicit in +[PROOF.md](PROOF.md). For the retained source, v=111, a=7 and delta=63. +The four partial H4 helpers are retained exactly. For every `0<=t<=1`, + +```text +Delta_t <= -47*f*8^(t-1) < 0. +``` + +This is the complete target-minus-paid moment in the stated model, including +every reused helper debit. It cannot justify an improved multiplication +exponent. The retained positive source caller uses distinct fresh D blocks +and is outside the theorem; its rank surplus 753 is checked as a control. + +## Evidence and reproduction + +The proof uses the classical rank inequality for U B V after factoring the +FULL projectors. It is not a new general matrix rank theorem. The new result +is the complete source-bound controller and helper-reuse consequence. +[RESULT.json](RESULT.json) records 13 exact four-coefficient attaining words, +omitted-call controls, a missing-mixed-term control, the helper-debit example, +integer invoice relaxations and exact moment constants. The favorable old +family `n/v=2p, f=p+2, h/v=p-1` needs p<=3 for its endpoint, while its unrestrained +price needs p>=66. Increasing that search cannot resolve the conflict. + +Python 3.12 or later and the standard library suffice: + +```sh +python3 -B scripts/research_package.py --package research/reused-d-helper-rank-bound +python3 -I -O -B research/reused-d-helper-rank-bound/verify.py +``` + +Expected token: `PASS_SHARED_D_HELPER_REUSE_RANK_BOUND`. +The default verifier is read-only; `--emit` writes the receipt for authors. +It authenticates all declared source bytes before use and compares the complete +typed result. [SOURCES.json](SOURCES.json) pins the source receipt, proof, readme +and shared invoice checker. No solver, network or pending Git object is needed. +[VALIDATION.md](VALIDATION.md) records actual runs and limits. + +The theorem is a written proof supported by exact examples, not a proof-assistant +certificate. The retained native source is not replayed here. Its authenticated +receipt supplies the local profile; the checker independently joins it to the +saved complete caller invoice. No physical realization of the attaining alphabet +words, selected cold replay, compiler or outer admission is claimed. + +## Open next questions + +A new controller must change a stated hypothesis: distinct D variables, a +FULL with a different supported defect rank, productive thin outputs, or a +separately justified operator-valued code. Start with its exact coefficient +contract and full invoice. [TASK.json](TASK.json) gives these first steps and +blockers. This package closes the shared-D investigation and does not start +a new search. + +## Source and credit + +The compact partial-helper source is retained in +[bit-compact-productive-controller](../bit-compact-productive-controller/README.md). +ai-nanachi supplied that productive interface and the compact436 lineage from +[PR #4326](https://github.com/CrocSwap/integer-mult-bounds/pull/4326). +The current controller and its partial-helper jobs are not new work here. +Keep its source notice and full credit to Cinna Davis, zxv, Jacob Alan Sussman, +Mark/Matarener and the PR589, geometry, framing, COPY, compiler and analytic +contributors. The shared invoice checker retains the classical concave-order +method and its credited predecessors. + +The initial two-dimensional factorization was developed by this campaign's +BIT worker and checked by the exact-coefficient worker. The branching worker +supplied the productive-helper extension. This package gives their common +field-count formulation and the complete partial-helper power bound. Prepared +for Ali Romman with substantial OpenAI Codex assistance. These are author-side +AI checks, not independent human acceptance. Apache-2.0. + +Publication base: `32890bc5de034ab8fc93ac88ead7279a6a416d04`, priority revision 7. +The selected conditional kappa at that checkpoint is 0.003027288235 and is +unchanged. The original local experiment began at +`1ec1119972c9aefe42525172d07b332fcff81cb4`. diff --git a/research/reused-d-helper-rank-bound/RESULT.json b/research/reused-d-helper-rank-bound/RESULT.json new file mode 100644 index 0000000000..96338bac14 --- /dev/null +++ b/research/reused-d-helper-rank-bound/RESULT.json @@ -0,0 +1,479 @@ +{ + "attaining_examples": [ + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 1, + "main_fields": 222, + "rank_mass_surplus": -63, + "recycled_H8_fields": 0, + "reused_helpers_per_port": [ + 0 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 2, + "thin_H1_calls": 222, + "thin_packets": 2 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 2, + "main_fields": 444, + "rank_mass_surplus": -126, + "recycled_H8_fields": 0, + "reused_helpers_per_port": [ + 0, + 0 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 4, + "thin_H1_calls": 444, + "thin_packets": 4 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 4, + "main_fields": 888, + "rank_mass_surplus": -252, + "recycled_H8_fields": 0, + "reused_helpers_per_port": [ + 0, + 0, + 0, + 0 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 8, + "thin_H1_calls": 888, + "thin_packets": 8 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 8, + "main_fields": 1776, + "rank_mass_surplus": -504, + "recycled_H8_fields": 0, + "reused_helpers_per_port": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 16, + "thin_H1_calls": 1776, + "thin_packets": 16 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 16, + "main_fields": 3552, + "rank_mass_surplus": -1008, + "recycled_H8_fields": 0, + "reused_helpers_per_port": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 32, + "thin_H1_calls": 3552, + "thin_packets": 32 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 32, + "main_fields": 7104, + "rank_mass_surplus": -2016, + "recycled_H8_fields": 0, + "reused_helpers_per_port": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 64, + "thin_H1_calls": 7104, + "thin_packets": 64 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 64, + "main_fields": 14208, + "rank_mass_surplus": -4032, + "recycled_H8_fields": 0, + "reused_helpers_per_port": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 128, + "thin_H1_calls": 14208, + "thin_packets": 128 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 128, + "main_fields": 28416, + "rank_mass_surplus": -8064, + "recycled_H8_fields": 0, + "reused_helpers_per_port": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 256, + "thin_H1_calls": 28416, + "thin_packets": 256 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 1, + "main_fields": 333, + "rank_mass_surplus": -63, + "recycled_H8_fields": 111, + "reused_helpers_per_port": [ + 1 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 3, + "thin_H1_calls": 222, + "thin_packets": 2 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 1, + "main_fields": 444, + "rank_mass_surplus": -63, + "recycled_H8_fields": 222, + "reused_helpers_per_port": [ + 2 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 4, + "thin_H1_calls": 222, + "thin_packets": 2 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 1, + "main_fields": 555, + "rank_mass_surplus": -63, + "recycled_H8_fields": 333, + "reused_helpers_per_port": [ + 3 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 5, + "thin_H1_calls": 222, + "thin_packets": 2 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 3, + "main_fields": 1110, + "rank_mass_surplus": -189, + "recycled_H8_fields": 444, + "reused_helpers_per_port": [ + 0, + 1, + 3 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 10, + "thin_H1_calls": 666, + "thin_packets": 6 + }, + { + "endpoint": "I+qI+dI+qdI", + "full_calls": 4, + "main_fields": 1554, + "rank_mass_surplus": -252, + "recycled_H8_fields": 666, + "reused_helpers_per_port": [ + 3, + 2, + 1, + 0 + ], + "signed_invoice_preflight": "uniformly_worse", + "streams_per_port": 14, + "thin_H1_calls": 888, + "thin_packets": 8 + } + ], + "controls": [ + { + "mutation": "omit_call_0", + "result": "REJECT_ENDPOINT" + }, + { + "mutation": "omit_call_1", + "result": "REJECT_ENDPOINT" + }, + { + "mutation": "omit_call_2", + "result": "REJECT_ENDPOINT" + }, + { + "mutation": "omit_full_qd_coefficient", + "result": "REJECT_ENDPOINT" + } + ], + "debit_counterfactual": { + "false_rank_surplus": 825, + "honest_rank_surplus": -63, + "omitted_recycled_H8_debits": 111 + }, + "integer_relaxations_checked": 75, + "new_kappa": false, + "new_supplier": false, + "scope": "Characteristic-two common-D formal FULL/THIN alphabet; ordinary constant scalar bases; recycle only autonomous H8 helpers. Distinct D blocks, changed native operations and general callers are outside this result.", + "source": { + "centre_debt": 63, + "gap": 1617, + "helper_rank_mass": 3472, + "paid_rank_mass": 5089, + "source_distinct_D_surplus": 753 + }, + "status": "PASS_SHARED_D_HELPER_REUSE_RANK_BOUND", + "theorem": { + "compact_power_bound": "Delta_t<=-f*8^(t-1)*(79-32*2^(-t))<=-47*f*8^(t-1)<0 for 0<=t<=1", + "rank_mass_bound": "Delta_1<=(a-1)*(n-M)-delta*f<=-delta*f", + "thin_bound": "h>=2*n-2*v*f-2*s", + "total_width": "M=2*v*f+s>=n" + } +} diff --git a/research/reused-d-helper-rank-bound/SOURCES.json b/research/reused-d-helper-rank-bound/SOURCES.json new file mode 100644 index 0000000000..69549e7595 --- /dev/null +++ b/research/reused-d-helper-rank-bound/SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446", + "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/bit-compact-productive-controller/PROOF.md", + "usage": "input", + "git_blob": "fef2f895259c327df5c7b0f97e1333e627eb57a5", + "sha256": "f53d19d97d8f72a5c6408b392f80387d5fabfef16e37aee10f015e147f2698e4" + }, + { + "path": "research/bit-compact-productive-controller/README.md", + "usage": "input", + "git_blob": "d574ae72dbbd462adfc5a1f2fd840a2b2c3c8070", + "sha256": "45a9a339da16971fc3c3dddadc295654ea498ecbf7cdce30520c55d4c6fd17aa" + }, + { + "path": "research/bit-compact-productive-controller/RESULT.json", + "usage": "input", + "git_blob": "0005dc4ec33a22dd8b84e54eb8f334686484625a", + "sha256": "d94a490c1936a6453dcad68fea7c85b33f93cadbd2e394adddd301c50a938af0" + }, + { + "path": "scripts/compare_recursive_invoices.py", + "usage": "input", + "git_blob": "fda2a852e9937e42fe40df0707694465ca7c1b48", + "sha256": "3930c22c11da7bc6042cfeb6e459ecb06e4478430037bee3469d034353855fc6" + } + ] +} diff --git a/research/reused-d-helper-rank-bound/TASK.json b/research/reused-d-helper-rank-bound/TASK.json new file mode 100644 index 0000000000..ad0e1c13f3 --- /dev/null +++ b/research/reused-d-helper-rank-bound/TASK.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 7, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "original_card": { + "id": "joint-query-controller", + "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/qq16-caller-install/README.md" + ], + "methods": [ + "Derive the matched whole-caller physical bill for installed and baseline protocols.", + "Change the actual demanded observations and prove a cheaper legal producer/consumer contract." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. 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_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.", + "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.", + "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer", + "4166", + "qq16-caller-install" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "A general characteristic-two rank obstruction for a common-D FULL/THIN controller, including arbitrary reuse of full-rank productive helpers and the retained compact BIT invoice.", + "scope_change_reason": "The donor authorized publication of useful saved proofs after the broader kappa search. This closes the exact shared-D alphabet investigated by the research workers; it does not reroll the assignment or claim the original complete-caller gate.", + "bottleneck_link": "Reusing one D block appeared to remove idle calls, but FULL projector support and the coefficient of Q force enough thin work to consume the complete surplus.", + "budget_minutes": null, + "stop_rule": "Finish the scoped all-size proof, exact attaining coefficient examples, source-bound invoice consequence and meaningful controls. Do not resume the excluded search.", + "outcome": "partial", + "evidence": "PROOF.md gives the rank factorization for every word in the stated alphabet. RESULT.json records four-coefficient attaining examples, omitted-call controls, complete source-invoice checks, helper-debit accounting and exact all-power constants.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance. The BIT worker supplied the initial Sylvester proof; the branching worker supplied productive-helper reuse; the exact-coefficient worker checked and extended the complete invoice argument. No independent human or formal-kernel review.", + "open_questions": [ + { + "question": "Can a different native call class escape the rank-two defect after all productive helper losses are charged?", + "why_it_matters": "The theorem fixes the defect rank of each FULL and shares one D across the word.", + "first_step": "Specify a changed coefficient matrix and complete native cost, then test the rank/price inequalities before a caller search.", + "blocked_by": "No changed native source or funded call class is supplied." + }, + { + "question": "Can a distinct-fresh-D caller close a larger exact endpoint with all ordinary and precision costs funded?", + "why_it_matters": "Distinct D blocks are outside this proof and are used by the retained positive controller.", + "first_step": "Use a released nonoverlapping caller handoff and give its exact target and invoice.", + "blocked_by": "This package is a proof closeout and does not construct that caller." + } + ] +} diff --git a/research/reused-d-helper-rank-bound/VALIDATION.md b/research/reused-d-helper-rank-bound/VALIDATION.md new file mode 100644 index 0000000000..37ef66a4f8 --- /dev/null +++ b/research/reused-d-helper-rank-bound/VALIDATION.md @@ -0,0 +1,59 @@ +# Validation record + +The publication base is `32890bc5de034ab8fc93ac88ead7279a6a416d04`. +Every consumed source file is already present at that base. No predecessor +input was edited. The source receipt and signed-invoice checker are inputs; +the selected record and task catalogue are provenance only. + +## Executed checks + +Python 3.12.14 on macOS ran these commands successfully: + +```sh +python3 -I -B research/reused-d-helper-rank-bound/verify.py --emit +python3 -B scripts/research_package.py --package research/reused-d-helper-rank-bound --check-only +python3 -B scripts/research_package.py --package research/reused-d-helper-rank-bound +``` + +The registered normal and optimized runs both produced +`PASS_SHARED_D_HELPER_REUSE_RANK_BOUND` and matched the complete typed +`RESULT.json`. Each run checked 13 exact attaining words, four failed endpoint +mutations, the separate helper-debit calculation and 75 integer relaxations. +The source rank gap is 1617. Its existing distinct-D caller has surplus 753; +this positive source control remains outside the obstruction. + +A separate temporary export contained seven scientific package files and four +declared live inputs. It had no Git directory, an empty PATH and read-only +files and directories. The absolute Python 3.12.14 interpreter ran the verifier +normally and with `-O`. Both passed. All 11 source file hashes stayed unchanged. +[PORTABILITY.json](PORTABILITY.json) records the two executions. These tests +preceded addition of the portability and validation records. The scientific +files match the registered replay. No network, solver or external executable +was used by the direct verifier. + +Two other campaign AI workers reviewed the rank factorization and the complete +power bound. The complex-geometry worker also ran both direct modes and made +an independent cross-port fixture. It has v=111, two FULL calls, helper counts +1 and 3, n=448 and h=444. A prefix-sum change of scalar basis mixes the ports. +The projector ranks are 223 and 225; each defect rank is 222. All four endpoint +coefficients equal identity. Its paid and target rank masses are 10622 and +10496, giving the proved surplus -126. These are author-side AI checks, not +independent human acceptance or a proof-assistant certificate. + +## Coverage and limits + +The written proof is the all-size argument. Finite examples check the formal +alphabet, product convention and sharpness; they are not new physical native +suppliers. All new checks use explicit errors and remain active under `-O`. +The signed-invoice comparison is evaluated for every attaining example. It +returns `uniformly_worse` against direct evaluation in its declared contract. + +The authenticated compact native source itself was not replayed. Its retained +receipt supplies the local paid/helper profile, which this checker joins to the +complete saved caller invoice. No selected-construction cold replay, physical +compiler, Lean proof, Docker build, hosted CI or full multiplication theorem +was checked. No kappa improvement or selected-frontier change follows. + +The shared repository has shallow Git history. The strict source-history +preflight therefore needs a separate full-history checkout. Source-byte and +standalone replay checks do not require that history. diff --git a/research/reused-d-helper-rank-bound/VERIFY.json b/research/reused-d-helper-rank-bound/VERIFY.json new file mode 100644 index 0000000000..b48663e3cd --- /dev/null +++ b/research/reused-d-helper-rank-bound/VERIFY.json @@ -0,0 +1,35 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/bit-compact-productive-controller/PROOF.md", + "research/bit-compact-productive-controller/README.md", + "research/bit-compact-productive-controller/RESULT.json", + "scripts/compare_recursive_invoices.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Authenticate retained source files; reconstruct local and complete invoice joins; evaluate exact four-coefficient attaining words, omitted-call controls and helper debit; check arbitrary-helper integer relaxations and exact all-power constants." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Repeat every exact check under optimized Python; explicit errors preserve the checks." + } + ] +} diff --git a/research/reused-d-helper-rank-bound/verify.py b/research/reused-d-helper-rank-bound/verify.py new file mode 100644 index 0000000000..5e26043dbb --- /dev/null +++ b/research/reused-d-helper-rank-bound/verify.py @@ -0,0 +1,233 @@ +#!/usr/bin/env python3 +"""Check shared-D rank-bound fixtures and the retained compact BIT invoice. + +Ali Romman, substantial OpenAI Codex assistance; Apache-2.0. +The all-size result is the written rank proof, not a finite search conclusion. +""" +from collections import Counter +from hashlib import sha256 +from pathlib import Path +import argparse +import importlib.util +import json +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def authenticate(): + manifest = json.loads((HERE / 'SOURCES.json').read_text()) + for record in manifest['files']: + if record['usage'] == 'input': + need(sha256((ROOT / record['path']).read_bytes()).hexdigest() == record['sha256'], + 'Changed live source: ' + record['path']) + + +def multiply(a, b): + out = [] + for row in a: + value = 0 + while row: + bit = row & -row + row ^= bit + value ^= b[bit.bit_length() - 1] + out.append(value) + return out + + +def plus(a, b): + return [x ^ y for x, y in zip(a, b)] + + +def rank(rows): + pivots = {} + for row in rows: + while row: + key = row.bit_length() - 1 + if key in pivots: + row ^= pivots[key] + else: + pivots[key] = row + break + return len(pivots) + + +def product(a, b): + # Support masks 0,1,2,3 denote I,q,d,qd. Repeated q or d gives zero. + n = len(a[0]) + out = [[0] * n for _ in range(4)] + for i in range(4): + for j in range(4): + if not i & j: + out[i | j] = plus(out[i | j], multiply(a[i], b[j])) + return out + + +def source_profile(): + source = json.loads((ROOT / 'research/bit-compact-productive-controller/RESULT.json').read_text()) + local, invoice = source['local']['forward'], source['invoice'] + paid = Counter({int(r): count for r, count in local['paid'].items()}) + helpers = Counter({int(r): count for r, count in local['helper_ranks'].items()}) + need(paid == {1:1319, 2:1342, 3:78, 4:39, 5:102, 6:10, 7:18}, 'Retained compact paid profile') + need(helpers == {4:4, 8:432}, 'Retained compact helper profile') + need(invoice['thick_calls'] == 18 and invoice['thin_queries'] == 15 * 111, 'Retained caller counts') + expected = Counter({r: 18 * count for r, count in paid.items()}) + expected[1] += invoice['thin_queries'] + for width, count in ((14,444),(21,444),(28,444),(35,444),(42,444),(49,444),(56,444),(63,222)): + expected[width] += count + need(expected == {int(r): count for r, count in invoice['paid'].items()}, 'Join to complete retained paid invoice') + targets = Counter({int(r): count for r, count in invoice['targets'].items()}) + need(targets[4] == 18 * helpers[4] and targets[8] == 18 * helpers[8], 'Join every retained helper target') + mass = lambda values: sum(r * count for r, count in values.items()) + need(mass(targets) - mass(expected) == invoice['rank_surplus'] == 753, 'Distinct-fresh-D source positive control') + gap = mass(paid) - mass(helpers) + need(gap == 2 * 111 * 7 + 63, 'Source centre debt after all helper credits') + need(max(paid) == 7 and set(helpers) == {4,8}, 'Power-moment rank bounds') + return paid, helpers, {'paid_rank_mass': mass(paid), 'helper_rank_mass': mass(helpers), + 'gap': gap, 'centre_debt': 63, 'source_distinct_D_surplus': 753} + + +def word(reused): + n = sum(r + 2 for r in reused) + eye, zero = [1 << i for i in range(n)], [0] * n + letters, start = [], 0 + for r in reused: + need(type(r) is int and 0 <= r <= 3, 'Available full-rank helper banks') + e, query = list(zero), list(zero) + for j in range(start, start + r + 2): + e[j] = 1 << j + query[start] = 1 << (start + 1) + for j in range(start + 2, start + r + 2): + query[j] = 1 << j + first, second = list(zero), list(zero) + first[start + 1] = 1 << start + second[start] = second[start + 1] = (1 << start) | (1 << (start + 1)) + need(multiply(e,e) == e and rank(e) == r + 2, 'FULL projector') + need(multiply(e,query) == multiply(query,e) == query, 'FULL support') + need(rank(plus(e,query)) == 2, 'FULL defect rank') + for thin in (first, second): + need(rank(thin) == 1 and not any(multiply(thin,thin)), 'THIN rank-one nilpotent') + letters += [[eye,query,e,query], [eye,first,zero,zero], [eye,second,zero,zero]] + start += r + 2 + return letters, eye, zero + + +def evaluate(letters, eye, zero): + value = [eye,zero,zero,zero] + for letter in letters: + value = product(letter,value) + return value + + +def invoice(n, reused, thin, paid, helpers): + f = len(reused) + need(all(111 * r <= helpers[8] for r in reused), 'Per-call productive helper debit') + children = Counter({r: f * count for r, count in paid.items()}) + children[1] += 111 * thin + targets = Counter({r: f * count for r, count in helpers.items()}) + targets[8] += 111 * (n - sum(reused)) + contract = {'model':'mixed-target-unnormalized-power-v1', + 'rank_semantics':'H_r costs r^(1-C); every recycled rank-eight helper is debited once', + 'ambient_rank':8, + 'boundary':'Complete formal shared-D FULL/THIN unit on all original fields; independent direct Gaussian evaluation is the comparison'} + return {'schema':'integer-mult-recursive-invoice/v1', 'contract':contract, + 'paid':dict(sorted((str(r),count) for r,count in children.items())), + 'targets':dict(sorted((str(r),count) for r,count in targets.items()))} + + +def comparator(): + path = ROOT / 'scripts/compare_recursive_invoices.py' + spec = importlib.util.spec_from_file_location('shared_d_invoice',path) + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + exec(compile(path.read_bytes(),str(path),'exec',optimize=0),module.__dict__) + return module + + +def produce(): + authenticate() + paid, helpers, source = source_profile() + compare = comparator() + examples = [] + families = [[0] * (n // 2) for n in (2,4,8,16,32,64,128,256)] + families += [[1],[2],[3],[0,1,3],[3,2,1,0]] + for reused in families: + letters, eye, zero = word(reused) + n, f, h = len(eye), len(reused), 2 * len(reused) + need(evaluate(letters,eye,zero) == [eye,eye,eye,eye], 'Complete four-coefficient endpoint') + total_width = sum(r + 2 for r in reused) + need(total_width == n and h == 2*n - 2*sum(r+1 for r in reused), 'Attained rank inequalities') + bill = invoice(n,reused,h,paid,helpers) + mass = lambda side: sum(int(r)*count for r,count in bill[side].items()) + need(mass('targets') - mass('paid') == -63 * f, 'Sharp complete rank-mass loss') + direct = dict(bill,paid=dict(bill['targets'])) + comparison = compare.compare_invoices(direct,bill) + need(comparison['classification'] == 'uniformly_worse', 'Direct evaluation costs less at every concave tariff') + examples.append({'streams_per_port':n, 'main_fields':111*n, 'full_calls':f, 'thin_packets':h, + 'thin_H1_calls':111*h, 'recycled_H8_fields':111*sum(reused), 'reused_helpers_per_port':reused, + 'endpoint':'I+qI+dI+qdI', 'rank_mass_surplus':-63*f, + 'signed_invoice_preflight':comparison['classification']}) + controls = [] + letters, eye, zero = word([1]) + for omitted in (0,1,2): + need(evaluate([letter for i,letter in enumerate(letters) if i != omitted],eye,zero) != [eye,eye,eye,eye], + 'Omitted call control must fail') + controls.append({'mutation':'omit_call_'+str(omitted), 'result':'REJECT_ENDPOINT'}) + bad = [[list(row) for row in letter] for letter in letters] + bad[0][3] = list(zero) + need(evaluate(bad,eye,zero) != [eye,eye,eye,eye], 'Missing mixed coefficient control') + controls.append({'mutation':'omit_full_qd_coefficient', 'result':'REJECT_ENDPOINT'}) + honest = invoice(3,[1],2,paid,helpers) + false_targets = dict(honest['targets']); false_targets['8'] += 111 + false_surplus = sum(int(r)*c for r,c in false_targets.items()) - sum(int(r)*c for r,c in honest['paid'].items()) + need(false_surplus == 825 and examples[8]['rank_mass_surplus'] == -63, 'Missing debit creates a false positive') + debit_counterfactual = {'omitted_recycled_H8_debits':111, + 'honest_rank_surplus':-63, 'false_rank_surplus':false_surplus} + relaxation_checks = 0 + for f in range(1,5): + for each in (0,1,431,432): + recycled = f * each + width = 222 * f + recycled + for n in sorted({1,111*f,222*f,width-1,width}): + thin = max(0,2*n-222*f-2*recycled) + surplus = 8*n - 1617*f - 8*recycled - thin + upper = 6*(n-width)-63*f + need(surplus <= upper <= -63*f, 'Arbitrary helper-count rank-mass relaxation') + relaxation_checks += 1 + # The all-moment proof uses 2**(-t)<=1, not floating-point root samples. + coefficient = source['centre_debt'] + 4 * helpers[4] - 8 * helpers[4] + need(coefficient == 47 > 0, 'Positive exact all-power loss coefficient') + return {'status':'PASS_SHARED_D_HELPER_REUSE_RANK_BOUND', 'source':source, + 'theorem':{'total_width':'M=2*v*f+s>=n', 'thin_bound':'h>=2*n-2*v*f-2*s', + 'rank_mass_bound':'Delta_1<=(a-1)*(n-M)-delta*f<=-delta*f', + 'compact_power_bound':'Delta_t<=-f*8^(t-1)*(79-32*2^(-t))<=-47*f*8^(t-1)<0 for 0<=t<=1'}, + 'attaining_examples':examples, 'controls':controls, 'debit_counterfactual':debit_counterfactual, + 'integer_relaxations_checked':relaxation_checks, + 'scope':'Characteristic-two common-D formal FULL/THIN alphabet; ordinary constant scalar bases; recycle only autonomous H8 helpers. Distinct D blocks, changed native operations and general callers are outside this result.', + 'new_supplier':False, 'new_kappa':False} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--emit',action='store_true',help='Write the result for package authors.') + args = parser.parse_args() + result = produce() + payload = json.dumps(result,sort_keys=True,indent=2)+'\n' + target = HERE/'RESULT.json' + if args.emit: + target.write_text(payload) + else: + expected = json.dumps(json.loads(target.read_text()),sort_keys=True,indent=2)+'\n' + need(payload == expected,'Saved typed mathematical receipt differs') + print(result['status'],json.dumps({'attaining_examples':len(result['attaining_examples']), + 'controls':len(result['controls']), 'source_gap':result['source']['gap']},sort_keys=True)) + + +if __name__ == '__main__': + main()