diff --git a/research/qq16-affine-helper-mix-seed98c45/PROOF.md b/research/qq16-affine-helper-mix-seed98c45/PROOF.md new file mode 100644 index 0000000000..536be8ae13 --- /dev/null +++ b/research/qq16-affine-helper-mix-seed98c45/PROOF.md @@ -0,0 +1,134 @@ +# One mixed affine QQ16 helper cannot recover the lost input + +## Statement and scope + +Fix the source-bound QQ16 `F0/B1` pair, retained ordinary schedule, and +standard observations (selected outputs, completed-X descendants, and all five +forward-query histories). On a finite regular cover `G`, let +`B_s : Q^(96|G|) -> Q^(8|G|)` be the actual ordinary-source query operators +for `s=0,1,2`. + +Allow exactly one additional eight-coordinate helper, immediately before +`F0`, with response + +```text +H' = H + B0 X_U + (M lifted cover-wise) B2 X_U + c, +``` + +where `M` is any rational 8x8 matrix, `H` is an arbitrary but common dirty +pre-state, and `c` is any fixed 8-vector lifted identically at each cover +location. For every `M`, `H`, and `c`, the augmented observation map is +noninjective. More precisely, +`dim B2(ker[B0+M B2; B1]) >= 32|G|/7`. This is an information obstruction, +not a native cost or new `kappa` result. + +## Pinned rank input + +The exact three-query rank bound used here is the source-checked result in +[PR #2104](https://github.com/CrocSwap/integer-mult-bounds/pull/2104), head +`4bdc574da394a39f955e8cf4637075649c43a632`, exact base +`0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. Its `PROOF.md` SHA-256 is +`9c2ad4600d65dd3354db4bae5ac78d13fedf2da6e500224fafaeed596846c887`. +That proof pins the QQ16 source/certificate and checks, for each pair +`(0,1),(0,2),(1,2)`, that the 96 relative route labels are distinct and the +cross-Gram identity coefficient is `192 I_8`; it also checks the actual +ordinary column norms and Gram. The local source-specific verifier from that +exact PR head was run read-only against this base with Python 3.14. It printed +`PASS_QQ16_EXTRA_QUERY_RESIDUAL rank_stack>=144|G|/7 missing_A>=ceil(32|G|/7) no_new_kappa`. +At the last successful hosted-status check at 19:52Z, PR #2104 was open and +its checks were pending. A later status refresh hit the GitHub API rate limit, +so its current hosted status is unverified. + +For `N=|G|`, those exact route facts imply + +```text +B_s B_s* = 48 I_(8N), +tr((B_s B_s*)^2) = 18432 N, +tr(B_s B_t* B_t B_s*) = 1536 N (s != t). +``` +For `S=[B0;B1;B2]` and `K=S* S`, + +```text +tr(K) = 1152 N, +tr(K^2) = 64512 N, +rank(S) >= tr(K)^2/tr(K^2) = (144/7) N. (1) +``` +The rank bound is Cauchy--Schwarz on the nonzero eigenvalues of `K`. The +current package uses this exact predecessor lemma; it does not rederive the +route labels. + +## All-matrix kernel argument + +Let `A_M = B0 + (M lifted cover-wise) B2` and `T_M=[A_M;B1]`. Both query +blocks have `8N` rows, so `rank(T_M) <= 16N`. Appending `B2` recovers exactly +the row space of `S`, since + +```text +A_M = B0 + M B2, B0 = A_M - M B2, +row([A_M;B1;B2]) = row([B0;B1;B2]). +``` +This holds for every rational `M`, including singular `M`. Therefore (1) +gives + +```text +rank([T_M;B2]) - rank(T_M) + >= (144/7)N - 16N = (32/7)N > 0. (2) +``` +The left side is `dim B2(ker T_M)`. Rationality of all maps means the +rational nullspace spans the real nullspace. Thus some rational `h` satisfies + +```text +B1 h = 0, B0 h + M B2 h = 0, B2 h != 0. (3) +``` +Clearing denominators preserves (3). + +Use the same `H,c` for inputs `h` and `0`. Equation (3) makes their new +helper records equal. The affine offset and dirty pre-state cancel in the +difference. + +## Existing selected-value witness + +For any `h` satisfying (3), use the source-pinned QQ16 input compensation on +pair 0: + +```text +X_U = h, Y_U = 0, +X_A = -P_(0,A) B0 h - P_(2,A) B2 h, Y_A = -X_A, +X_T = P_(0,T) ell_(0,A) P_(2,A) B2 h, Y_T = -X_T. +``` + +The formulas are linear in `h`. The selected pair sums vanish; the ordered +`F0/B1` equations use only `B1h=0`, `B2h!=0`, and the pinned two-sided +selected-section identities. They leave a nonzero initial selected value +`X_(0,T)` but zero selected outputs, completed-X descendants and all five +forward histories, as detailed in +`research/joint-query/evidence/QQ16-SELECTED-WITNESS.md`. By (3), the mixed +affine helper also agrees with the zero input. No decoder from these +observations can restore every original selected input. + +The zero-cost relaxation grants every potentially relevant expense for free: + +| Expense | Favorable charge | +|---|---:| +| Source access and query arithmetic | 0 | +| Helper storage and output hosting | 0 | +| Helper update, inverse, and dirty-state restoration | 0 | +| Frame and address transitions | 0 | +| Local calls and recursive child operations | 0 | +| Recursive precision | 0 | + +It still fails injectivity, so there is no implementable cost or moment gain +to invoice for this interface. + +## Limits + +The theorem allows all rational 8x8 mixers and fixed offsets on one helper. +It keeps the actual `F0/B1` maps, ordinary tail, observation set and source +cut fixed. It does not cover a second independent helper, an input-dependent +offset, another source field, a changed first pair or tail, or a later read of +other ordinary banks. `32|G|/7` is an information dimension, not a paid +recursive-child rank. + +`verify.py` checks the rank/row-space corollary on exact rational controls and +checks the exact trace arithmetic. It does not replace the pinned route +verification of (1) or replay the full inherited native trajectory. diff --git a/research/qq16-affine-helper-mix-seed98c45/README.md b/research/qq16-affine-helper-mix-seed98c45/README.md new file mode 100644 index 0000000000..7eb4cfd093 --- /dev/null +++ b/research/qq16-affine-helper-mix-seed98c45/README.md @@ -0,0 +1,49 @@ +# QQ16 mixed affine helper obstruction + +**Scoped negative result; no supplier or kappa claim.** One added 8-coordinate +affine helper `H + B0 X_U + M B2 X_U + c` cannot restore all original +selected inputs under the fixed QQ16 `F0/B1` pair and retained schedule, for +any rational 8x8 mixer `M`. The proof converts the exact three-query rank +bound from PR #2104 into an all-mixer kernel bound. The helper and every +operation needed to implement or restore it are granted free, yet the +observations remain noninjective. + +## Reproduce + +From the repository root: + +```sh +python3 -I -O -B research/qq16-affine-helper-mix-seed98c45/verify.py +python3 scripts/research_package.py --package research/qq16-affine-helper-mix-seed98c45 --check-only +``` + +Expected direct result: `PASS_QQ16_AFFINE_HELPER_MIX cases=4 positives=4 controls=3 no_new_kappa`. +Expected metadata result: `PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check)`. +Registered replay uses Python 3.12; hosted CI is the runtime check if that +interpreter is unavailable locally. + +The exact route lemma is pinned to PR #2104 head +`4bdc574da394a39f955e8cf4637075649c43a632`, `PROOF.md` SHA-256 +`9c2ad4600d65dd3354db4bae5ac78d13fedf2da6e500224fafaeed596846c887`. +Its source-specific verifier ran locally on Python 3.14 against the exact +base. At the last successful status check at 19:52Z, that PR was open with +hosted checks pending; the later refresh hit the GitHub API rate limit, so +current hosted status is unverified. Full argument and scope limits are in +[PROOF.md](PROOF.md); original source and selected witness remain unchanged. + +## Attribution and limits + +Credit Ali Romman and PR #1969 for the QQ16 maps and selected witness; Cinna +Davis PR #2104 for the source-bound three-query rank result; Cinna Davis PR +#2079 for the B2-only observation this result extends. Adam Gall PR #2093 and +#2086 address related but different observation/logger cases. Prepared with +substantial OpenAI Codex assistance. No independent human or formal-kernel +review is claimed. + +## Open next questions + +- **Can a second independent ordinary-to-selected record restore injectivity?** + The row-count cap used here would no longer apply. Specify the second source + and compute the joint kernel before native synthesis. +- **Can one changed ordinary-tail map retain the erased selected value?** + Derive its inverse and observations before expanding the controller. diff --git a/research/qq16-affine-helper-mix-seed98c45/RESULT.json b/research/qq16-affine-helper-mix-seed98c45/RESULT.json new file mode 100644 index 0000000000..ea634fe918 --- /dev/null +++ b/research/qq16-affine-helper-mix-seed98c45/RESULT.json @@ -0,0 +1,24 @@ +{ + "dimension_bound": "dim B2(ker[B0+M B2;B1]) >= 32|G|/7 for every rational 8x8 M", + "no_kappa_change": true, + "outcome": "negative-result", + "remaining_limits": [ + "Uses the exact route-rank theorem in open PR #2104; its hosted checks were pending at 19:52Z and the later status refresh failed on API rate limit.", + "No native helper implementation, complete physical cost, supplier admission, precision proof, or global controller." + ], + "reproduction": "python3 -I -O -B research/qq16-affine-helper-mix-seed98c45/verify.py", + "schema_version": 1, + "source_rank_predecessor": { + "git_blob": "388bca8797d90d385d984ad8bfa72af20cf80123", + "head": "4bdc574da394a39f955e8cf4637075649c43a632", + "local_check": "Downloaded exact-head verifier run against pinned base on Python 3.14; PASS_QQ16_EXTRA_QUERY_RESIDUAL.", + "name": "QQ16 three-query route-rank proof", + "path": "research/qq16-extra-query-residual/PROOF.md", + "sha256": "9c2ad4600d65dd3354db4bae5ac78d13fedf2da6e500224fafaeed596846c887", + "status_at_claim": "open; hosted checks pending", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2104", + "verifier_path": "research/qq16-extra-query-residual/verify.py", + "verifier_sha256": "68e3c1c8c044a9b7ae245b189ef2154b6cfe6c96faca87349cd336ebf731fd2e" + }, + "status": "SCOPED_NEGATIVE_RESULT" +} diff --git a/research/qq16-affine-helper-mix-seed98c45/SOURCES.json b/research/qq16-affine-helper-mix-seed98c45/SOURCES.json new file mode 100644 index 0000000000..61bd8e090f --- /dev/null +++ b/research/qq16-affine-helper-mix-seed98c45/SOURCES.json @@ -0,0 +1,100 @@ +{ + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "catalog_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "external_dependencies": [ + { + "git_blob": "388bca8797d90d385d984ad8bfa72af20cf80123", + "head": "4bdc574da394a39f955e8cf4637075649c43a632", + "local_check": "Downloaded exact-head verifier run against pinned base on Python 3.14; PASS_QQ16_EXTRA_QUERY_RESIDUAL.", + "name": "QQ16 three-query route-rank proof", + "path": "research/qq16-extra-query-residual/PROOF.md", + "sha256": "9c2ad4600d65dd3354db4bae5ac78d13fedf2da6e500224fafaeed596846c887", + "status_at_claim": "open; hosted checks pending", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2104", + "verifier_path": "research/qq16-extra-query-residual/verify.py", + "verifier_sha256": "68e3c1c8c044a9b7ae245b189ef2154b6cfe6c96faca87349cd336ebf731fd2e" + } + ], + "files": [ + { + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "path": "docs/research/agent-task-catalog.json", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "usage": "provenance" + }, + { + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "usage": "provenance" + }, + { + "git_blob": "9b6cbfef0fb725f28c177038d32f482706e12c94", + "path": "autoresearch.md", + "sha256": "79d0c8be61d90dd6c46b6e7250e0c88713d29854128d8d1361b6343682dad1d8", + "usage": "provenance" + }, + { + "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "path": "CONTRIBUTING.md", + "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a", + "usage": "provenance" + }, + { + "git_blob": "fc9704487ccf5fbf0472950117741c219fe98151", + "path": "docs/research/community-efficient1000-review.md", + "sha256": "bac19ca28be781e7ac444e0666320ef77c0ac159467eafa3198e07b7c280442e", + "usage": "provenance" + }, + { + "git_blob": "3e66629292d42f592a0d73a4a42f7f3a02bd62a5", + "path": "research/joint-query/SOURCES.json", + "sha256": "fabc6686e5d3ac0e4bb4397c147037b9285abfa671614590dad6d4e16b4dc0fc", + "usage": "provenance" + }, + { + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "path": "research/joint-query/certificate.json.gz", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7", + "usage": "input" + }, + { + "git_blob": "4639583c1be02c2fb60ed8a8072c9969ef1569ce", + "path": "research/joint-query/evidence/CONSERVED-QQ16.md", + "sha256": "60f0de3a7205ba5046b5ae7ffa8bf2b1ea42ea46b498face0a77966b59e7f3fb", + "usage": "provenance" + }, + { + "git_blob": "7a155a27dcf7f1ccd48e40d57a2c5d2724016e9b", + "path": "research/joint-query/evidence/CONSERVED-QQ16.json", + "sha256": "b91eb8599c403db55c889bb225a1cd93f46fdb83eb339f101d18843d52b1c920", + "usage": "provenance" + }, + { + "git_blob": "307650f45e37c28d14fe913958efa4fb429242b7", + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "sha256": "52f2ee565320f05282c637aa79eee100606c24240b1b5866f0c8d62e7913c9fc", + "usage": "input" + }, + { + "git_blob": "5082d791d0b993492cbc5bf61ac3b69e82c96f3f", + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json", + "sha256": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4", + "usage": "input" + }, + { + "git_blob": "ede9e7e42744dd0c96790516a9acdfe07d180018", + "path": "research/joint-query/verify_native.py", + "sha256": "1c58e7b6e8e1cde4df455c2129601c145ed763fc63a3ab427eb1058d1fc08bd2", + "usage": "provenance" + }, + { + "git_blob": "3e85a06d1848e94a4eb0908d6ec6c0bccde16b2f", + "path": "research/joint-query/replay.py", + "sha256": "61a3c2ddc3e62f965bfc9ee47b6a1e8c03b0071c5021feb6612ebbdd9561038e", + "usage": "provenance" + } + ], + "schema_version": 1, + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" +} diff --git a/research/qq16-affine-helper-mix-seed98c45/TASK.json b/research/qq16-affine-helper-mix-seed98c45/TASK.json new file mode 100644 index 0000000000..b6f663331a --- /dev/null +++ b/research/qq16-affine-helper-mix-seed98c45/TASK.json @@ -0,0 +1,187 @@ +{ + "actual_scope": "For every rational 8x8 M and fixed affine offset, the fixed QQ16 F0/B1 observation map remains noninjective after adding exactly one pre-F0 8-coordinate helper H + B0 X_U + M B2 X_U, with common arbitrary dirty H and the retained ordinary tail.", + "ai_assistance": "Substantial OpenAI Codex assistance in selecting the changed interface, deriving the all-mixer kernel argument, and preparing the exact rational replay.", + "author": "Cinna Davis", + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "bottleneck_link": "Tests whether one compressed ordinary-to-selected observation can repair the fixed QQ16 lost-input bottleneck even when its operation and restoration costs are made free.", + "catalog_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2074#discussioncomment-18933023", + "entry_overlap": { + "decision": "Proceed as a compressed one-helper family; the first-pair catalogue explicitly leaves affine helper state outside its scope.", + "live_check": "GraphQL latest 100 updated discussions and exact QQ16/B0 PR search; relevant current thread #2074 latest comment at 19:35Z was the 252 first-pair catalogue finding. PR #2104 and #2079 heads checked directly. No matching one-affine-helper claim found.", + "offline_cache": { + "complete_pagination": true, + "discussion_fetched_at": "2026-10-14T19:47:48Z", + "discussions": 778, + "fetched_at": "2026-10-14T19:48:48Z", + "open_prs": 380, + "warnings": [ + "offline; cache may miss current changes" + ] + } + }, + "evidence": "PROOF.md proves rank([B0+M B2;B1;B2])=rank([B0;B1;B2]) and rank([B0+M B2;B1])<=16|G|, leaving dim B2(ker[B0+M B2;B1])>=32|G|/7. The source-pinned QQ16 witness then hides a nonzero selected input while the affine helper response is zero. verify.py checks exact row-space, kernel, affine-cancellation controls and trace arithmetic.", + "external_dependencies": [ + { + "git_blob": "388bca8797d90d385d984ad8bfa72af20cf80123", + "head": "4bdc574da394a39f955e8cf4637075649c43a632", + "local_check": "Downloaded exact-head verifier run against pinned base on Python 3.14; PASS_QQ16_EXTRA_QUERY_RESIDUAL.", + "name": "QQ16 three-query route-rank proof", + "path": "research/qq16-extra-query-residual/PROOF.md", + "sha256": "9c2ad4600d65dd3354db4bae5ac78d13fedf2da6e500224fafaeed596846c887", + "status_at_claim": "open; hosted checks pending", + "status_at_last_successful_check": "open; hosted checks pending", + "status_at_submission": "unverified; GitHub API rate limit prevented refresh", + "status_checked_at": "2026-10-14T19:52Z", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2104", + "verifier_path": "research/qq16-extra-query-residual/verify.py", + "verifier_sha256": "68e3c1c8c044a9b7ae245b189ef2154b6cfe6c96faca87349cd336ebf731fd2e" + } + ], + "final_overlap": { + "coverage": { + "discussions": { + "cached_records": 786, + "last_complete_cache_at": "2026-10-14T19:47:48Z", + "live_recent_window": "GraphQL latest 100 updated discussions queried at 19:58Z; #2074 was the only current QQ16 helper-related thread.", + "refresh_complete": false + }, + "open_prs": { + "complete_pagination": true, + "fetched_at": "2026-10-14T19:58:51Z", + "records": 378 + } + }, + "decision": "No separate all-rational mixed B0/M B2 helper claim appeared in the live recent discussion window or refreshed open-PR results. The result remains distinct from B2-only, residual-kernel, logger, and fixed first-pair catalogue scopes.", + "relevant_matches": [ + { + "discussion": 2074, + "role": "B2 observation thread; our changed one-mixed-helper claim posted at 19:51Z; prior 252-pair finding leaves affine helper outside scope." + }, + { + "head": "49df8190b158e3028e702b2c6b798117006f7249", + "pr": 2079, + "role": "B2-only observation." + }, + { + "head": "4bdc574da394a39f955e8cf4637075649c43a632", + "pr": 2104, + "role": "B2-only residual and rank lemma." + }, + { + "head": "8b21a900eb520e4f11ea177b310f66316f8e8983", + "pr": 2093, + "role": "all-nonzero-chart qualitative witness." + }, + { + "head": "68dcf180ce3918a9ee1998bfc5455f42516c6009", + "pr": 2086, + "role": "changed-A-logger boundary." + } + ], + "searched_at": "2026-10-14T19:58:51Z", + "warnings": [ + "Discussion refresh hit GitHub API rate limit and fell back to the complete 19:47:48Z cache." + ] + }, + "open_questions": [ + { + "blocked_by": "A complete controller still needs legal read, hosting, restoration, endpoint and precision costs.", + "first_step": "Specify the exact added source and derive the full joint observation kernel before native synthesis.", + "question": "Can a second independent ordinary-to-selected observation restore injectivity?", + "why_it_matters": "A second independent record exceeds the 16|G|-row limit behind this one-helper obstruction." + }, + { + "blocked_by": "The changed schedule and full operation invoice are not derived.", + "first_step": "Change one ordered map and compute its inverse and observation kernel.", + "question": "Can one changed ordinary-tail map retain the erased selected value?", + "why_it_matters": "The current proof fixes the ordinary tail and first pair." + } + ], + "original_card": { + "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.", + "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." + ], + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "first_experiment": "Apply the existing witness to one proposed extra observation or changed first pair. If it still loses the required record, stop. Otherwise derive one ordered two-call identity and charge the added read, chart maps and restoration before extending to more stages.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the fixed-first-pair QQ16 witness before designing a controller. The checked #1969 local words do not evade that witness or supply global placement.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "id": "joint-query-controller", + "methods": [ + "Add one explicitly priced ordinary-to-selected observation and derive the ordered two-call map and inverse.", + "Change the first local pair or retained state, then test the existing lost-observation witness and price all new operations." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969" + ], + "question": "Can one explicitly changed QQ16 interface recover the missing chart query and close a two-call controller within a favorable full budget?", + "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." + ], + "starting_points": [ + "research/joint-query/README.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "docs/research/community-efficient1000-review.md" + ] + }, + "outcome": "negative-result", + "predecessors": [ + { + "head": "4bdc574da394a39f955e8cf4637075649c43a632", + "pr": 2104, + "role": "exact three-query route-rank bound used as lemma; hosted CI pending at local check" + }, + { + "head": "49df8190b158e3028e702b2c6b798117006f7249", + "pr": 2079, + "role": "B2-only pre-F0 observation predecessor" + }, + { + "head": "a6e6ad3936f67b8f63b5b68c5e75d540610a65e7", + "pr": 1969, + "role": "QQ16 maps and selected witness lineage" + }, + { + "head": "8b21a900eb520e4f11ea177b310f66316f8e8983", + "pr": 2093, + "role": "related qualitative all-nonzero-chart obstruction; distinct witness" + }, + { + "head": "68dcf180ce3918a9ee1998bfc5455f42516c6009", + "pr": 2086, + "role": "adjacent changed-A-logger scope" + } + ], + "priority_revision": 4, + "schema_version": 1, + "scope_change_reason": "The catalogue method was refined from a generic extra ordinary-to-selected observation to a compressed affine helper mixing the B0 and B2 query blocks in one eight-coordinate register. The question is whether this lower-dimensional interface can preserve information; the proof handles every rational mixer, not a finite menu.", + "scope_key": "af861a56b365ef79f151", + "scope_status": "changed", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selection_nonce": "98c45ff6de908e57187a43e63c8d80e3", + "selection_override": "Excluded three nonconstruction selector draws per prompt, then accepted the eligible recursive-interfaces draw; no catalogue allocation or seed was changed.", + "selection_track": "recursive-interfaces", + "stop_rule": "Stop after the all-M row-space/kernel proof, exact rational controls, and pinned predecessor route-rank check. Do not enumerate mixers, change maps, or price a controller after the zero-cost interface already fails.", + "submission_checkpoint": { + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + "task_id": "joint-query-controller" +} diff --git a/research/qq16-affine-helper-mix-seed98c45/TASK.md b/research/qq16-affine-helper-mix-seed98c45/TASK.md new file mode 100644 index 0000000000..4ed3778621 --- /dev/null +++ b/research/qq16-affine-helper-mix-seed98c45/TASK.md @@ -0,0 +1,39 @@ +# Cycle 23 task card + +- Track: `recursive-interfaces` +- Accepted OS seed: `98c45ff6de908e57187a43e63c8d80e3` +- Task ID: `joint-query-controller` +- Catalogue method: `Add one explicitly priced ordinary-to-selected observation and derive the ordered two-call map and inverse.` +- Selector scope key: `22e535909f1d243e7553` +- Refined scope: one affine 8-coordinate helper `H' = H + (B0 + M B2) X_U + c`, with arbitrary rational `M` (8x8), offset `c`, and common dirty pre-state `H`; fixed QQ16 `F0/B1` pair and existing standard observation set. +- Refined scope key: `af861a56b365ef79f151` +- Scope status: changed. The candidate replaces an isolated B2 read or a separate B0 read with one compressed mixed B0/B2 helper; arbitrary matrix mixing and a shared affine offset are allowed. This asks whether the proposed cheaper 8-coordinate interface can preserve injectivity. +- Priority revision: 4 +- Catalogue SHA-256: `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7` +- Exact base commit: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2` +- Selected-record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32` +- Selected-result reproduction: `make frontier1094-verify` + +## Question and bounded method + +For every `M in Q^(8x8)`, does the fixed-controller observation map become injective when its standard observations are augmented by only `H'` above? Use the exact QQ16 route operators `B0,B1,B2` and the already-reviewed witness/trajectory. The bounded domain is the complete rational 8x8 matrix family, arbitrary rational offset, and arbitrary shared helper pre-state; fixed `F0/B1`, schedule, and observation cut. + +Use the source-pinned stack-rank inequality `rank[B0;B1;B2] >= 144|G|/7`. Since `rank[B0+M B2;B1] <= 16|G|` and adjoining `B2` recovers the same row span as `[B0;B1;B2]`, an exact kernel dimension argument should either produce a lost direction with `B2 h != 0` for all `M`, or expose a failed premise. Apply the selected-output witness to that direction. Stop after exact derivation and source-pinned checks; do not enumerate matrices or broaden to multiple helpers/changed maps. + +## Optimistic full cost and outcome gate + +Grant the one 8-coordinate helper, the mixed source read, frame and address conversion, forward update, inverse/restoration, dirty-state handling, hosting, and recursive precision all for free. This zero-paid-cost envelope is deliberately more favorable than any implementable invoice. If injectivity still fails, stop and report no cost improvement or `kappa` change. If it succeeds for any `M`, derive the exact map and inverse and then invoice every operation before considering a controller claim. + +## Overlap and predecessors + +- PR #2079, head `49df8190b158e3028e702b2c6b798117006f7249`: B2-only pre-F0 observation of the eight-direction witness family. +- PR #2104, head `4bdc574da394a39f955e8cf4637075649c43a632`, exact base current: quantitative residual after the B2-only read, including the stack-rank bound. +- PR #2093, head `8b21a900eb520e4f11ea177b310f66316f8e8983`: qualitative three-port witness across nonzero charts. +- PR #2086, head `68dcf180ce3918a9ee1998bfc5455f42516c6009`: changed A-logger boundary. +- Discussion #2074 also contains the completed 252-pair first-forward catalogue, which leaves affine helper state outside its scope. + +This scope is the exact one-helper mixed `B0+M B2` interface; it adds a dimension bound over all rational `M`, rather than repeating the B2-only query or first-pair catalogue. + +## Deliverable and stopping rule + +A small proof package with the all-`M` rank argument, exact pinned dependencies, a standard-library replay of the dimension/corollary arithmetic, positive and mutation controls, and an explicit statement that the result is a scoped obstruction rather than a native cost or `kappa` result. Recheck board overlap before submission. Claim expiry: `2026-10-14T21:50:00Z`. diff --git a/research/qq16-affine-helper-mix-seed98c45/VERIFY.json b/research/qq16-affine-helper-mix-seed98c45/VERIFY.json new file mode 100644 index 0000000000..ca4bad3d77 --- /dev/null +++ b/research/qq16-affine-helper-mix-seed98c45/VERIFY.json @@ -0,0 +1,27 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "checks": "Exact Fraction controls for four rational mixers, row-space recovery, nonzero residual kernel vectors, affine offset/dirty-state cancellation, and the rank/trace arithmetic; three deliberate mutations are rejected.", + "timeout_seconds": 60 + } + ], + "inputs": [ + "research/qq16-affine-helper-mix-seed98c45/verify.py", + "research/qq16-affine-helper-mix-seed98c45/PROOF.md", + "research/qq16-affine-helper-mix-seed98c45/SOURCES.json", + "research/joint-query/certificate.json.gz", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json" + ], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/qq16-affine-helper-mix-seed98c45/verify.py b/research/qq16-affine-helper-mix-seed98c45/verify.py new file mode 100644 index 0000000000..8df16bd3f9 --- /dev/null +++ b/research/qq16-affine-helper-mix-seed98c45/verify.py @@ -0,0 +1,146 @@ +#!/usr/bin/env python3 +"""Exact rational controls for the QQ16 mixed-affine-helper rank corollary.""" +from fractions import Fraction as Q +from hashlib import sha256 +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def rank(matrix): + if not matrix: + return 0 + a = [[Q(x) for x in row] for row in matrix] + ncols = len(a[0]) + r = 0 + for col in range(ncols): + pivot = next((i for i in range(r, len(a)) if a[i][col]), None) + if pivot is None: + continue + a[r], a[pivot] = a[pivot], a[r] + scale = a[r][col] + a[r] = [x / scale for x in a[r]] + for i in range(len(a)): + if i != r and a[i][col]: + factor = a[i][col] + a[i] = [x - factor*y for x, y in zip(a[i], a[r])] + r += 1 + if r == len(a): + break + return r + + +def stack(*blocks): + return [list(row) for block in blocks for row in block] + + +def matmul(a, b): + need(bool(a) and bool(b) and len(a[0]) == len(b), "matrix dimensions") + return [[sum((Q(a[i][k])*Q(b[k][j]) for k in range(len(b))), Q(0)) + for j in range(len(b[0]))] for i in range(len(a))] + + +def add(a, b): + need(len(a) == len(b) and all(len(x) == len(y) for x, y in zip(a, b)), + "addition dimensions") + return [[Q(x)+Q(y) for x, y in zip(rx, ry)] for rx, ry in zip(a, b)] + + +def matvec(a, x): + return [sum((Q(v)*Q(t) for v, t in zip(row, x)), Q(0)) for row in a] + + +def nullspace(a): + if not a: + return [] + work = [[Q(x) for x in row] for row in a] + ncols, r, pivots = len(work[0]), 0, [] + for col in range(ncols): + pivot = next((i for i in range(r, len(work)) if work[i][col]), None) + if pivot is None: + continue + work[r], work[pivot] = work[pivot], work[r] + scale = work[r][col] + work[r] = [x/scale for x in work[r]] + for i in range(len(work)): + if i != r and work[i][col]: + factor = work[i][col] + work[i] = [x-factor*y for x, y in zip(work[i], work[r])] + pivots.append(col) + r += 1 + free = [j for j in range(ncols) if j not in pivots] + basis = [] + for col in free: + vector = [Q(0)] * ncols + vector[col] = Q(1) + for i, pivot in enumerate(pivots): + vector[pivot] = -work[i][col] + basis.append(vector) + return basis + + +def authenticate_inputs(): + manifest = json.loads((HERE / "SOURCES.json").read_text(encoding="utf-8")) + for row in manifest["files"]: + if row["usage"] == "input": + raw = (ROOT / row["path"]).read_bytes() + need(sha256(raw).hexdigest() == row["sha256"], "pinned input drift: " + row["path"]) + + +def main(): + authenticate_inputs() + # A full-row-rank three-query analogue with a two-coordinate helper. + # The proof is symbolic; these exact controls exercise the row-space step. + b0 = [[1,0,0,0,0], [0,1,0,0,0]] + b1 = [[0,1,1,0,0], [1,0,1,0,0]] + b2 = [[0,0,0,1,0], [0,0,0,0,1]] + identity = [[1,0],[0,1]] + zero = [[0,0],[0,0]] + mixers = [zero, identity, + [[2,Q(1,2)],[Q(-1,3),3]], + [[Q(1,3),2],[-4,Q(5,2)]]] + full_rank = rank(stack(b0, b1, b2)) + need(full_rank == 5, "positive-control source stack") + for index, mixer in enumerate(mixers): + mixed = add(b0, matmul(mixer, b2)) + observed = stack(mixed, b1) + restored_stack = stack(observed, b2) + need(rank(restored_stack) == full_rank, f"row-space recovery case {index}") + need(rank(observed) <= 4, f"two-query row cap case {index}") + need(rank(restored_stack)-rank(observed) > 0, f"nonzero residual case {index}") + witness = next((h for h in nullspace(observed) if any(matvec(b2, h))), None) + need(witness is not None, f"kernel witness case {index}") + need(not any(matvec(observed, witness)) and any(matvec(b2, witness)), + f"kernel equations case {index}") + dirty, offset = [Q(13), Q(-5)], [Q(2), Q(7)] + response_h = [dirty[i] + matvec(mixed, witness)[i] + offset[i] for i in range(2)] + response_zero = [dirty[i] + offset[i] for i in range(2)] + need(response_h == response_zero, f"affine cancellation case {index}") + + # Exact trace arithmetic in the source-pinned predecessor lemma. + need(Q(1152**2, 64512) == Q(144, 7), "trace ratio") + need(Q(144, 7)-16 == Q(32, 7) and Q(32, 7) > 0, "residual dimension") + + # Negative controls: omitting B2 breaks reconstruction; a plus sign in the + # inverse identity is wrong for nonzero M; a corrupted trace fails exactly. + base_observed = stack(b0, b1) + need(rank(stack(base_observed, b0)) < full_rank, "omitted-B2 control") + nonzero_m = mixers[2] + nonzero_m_b2 = matmul(nonzero_m, b2) + mixed = add(b0, nonzero_m_b2) + wrong_reconstruction = add(mixed, nonzero_m_b2) + need(wrong_reconstruction != b0, "sign-mutation control") + need(Q(1152**2, 64513) != Q(144, 7), "trace-mutation control") + + print("PASS_QQ16_AFFINE_HELPER_MIX cases=4 positives=4 controls=3 no_new_kappa") + + +if __name__ == "__main__": + main()