From aed06c8f8d60ce97b7eb3a7c6c17ad12cbe1e863 Mon Sep 17 00:00:00 2001 From: commdata2338 <199849969+commdata2338@users.noreply.github.com> Date: Thu, 15 Oct 2026 02:17:47 -0500 Subject: [PATCH] Research: adaptive QQ16 reads still need 66 ports; 45 optimal sets Takes PR #2354's excluded adaptive-coordinate premise. On PR #2354's rational QQ16 hidden-input family, every exact deterministic reader needs at least 66 distinct source-port reads on every input, whatever its adaptive choices, nonlinear computation or stopping rule; for input-independent random seeds the same bound holds almost surely. The source geometry classifies all 45 optimal read sets: each contains 22 mandatory ports and 44 of the 45 coordinates in one relation, every one omits the same 29 ports, and port 77 can replace 44 specific ports of PR #2354's attaining set. Explicit rational decoders attain all 45. Information-access counts only; no supplier or kappa change. Adds research/qq16-adaptive-coordinate-reads/ only. Submitted by @commdata2338 with substantial AI assistance (OpenAI Codex research and implementation; packaged with Claude Code). Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01X86sCSXdoDd61SDFfC1PKG --- .../qq16-adaptive-coordinate-reads/README.md | 330 ++++++++++ .../RESULT.json | 609 ++++++++++++++++++ .../SOURCES.json | 42 ++ .../qq16-adaptive-coordinate-reads/TASK.json | 136 ++++ .../VERIFY.json | 45 ++ .../test_artifacts.py | 83 +++ .../qq16-adaptive-coordinate-reads/verify.py | 378 +++++++++++ 7 files changed, 1623 insertions(+) create mode 100644 research/qq16-adaptive-coordinate-reads/README.md create mode 100644 research/qq16-adaptive-coordinate-reads/RESULT.json create mode 100644 research/qq16-adaptive-coordinate-reads/SOURCES.json create mode 100644 research/qq16-adaptive-coordinate-reads/TASK.json create mode 100644 research/qq16-adaptive-coordinate-reads/VERIFY.json create mode 100644 research/qq16-adaptive-coordinate-reads/test_artifacts.py create mode 100644 research/qq16-adaptive-coordinate-reads/verify.py diff --git a/research/qq16-adaptive-coordinate-reads/README.md b/research/qq16-adaptive-coordinate-reads/README.md new file mode 100644 index 0000000000..08adbb1af1 --- /dev/null +++ b/research/qq16-adaptive-coordinate-reads/README.md @@ -0,0 +1,330 @@ +# QQ16: adaptive coordinate reads still need 66 ports + +**Scoped proof and exact finite premises; no supplier or new κ.** +On the rational hidden-input family of +[PR2354](https://github.com/CrocSwap/integer-mult-bounds/pull/2354), every +deterministic reader that always recovers the original selected A defect +needs **at least 66 distinct source-port reads on every input**, even when +its port choices and stopping time depend arbitrarily on earlier reads. +The same statement holds almost surely for a randomized reader that +terminates and is exact with probability one for each rational input. + +There are **exactly 45 possible read sets at a successful 66-read leaf**. +All contain these 22 ports: + +```text +1,2,3,4,5,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109. +``` + +The other 44 reads choose all but one of 45 explicitly listed ports. +PR2354's attaining set is one choice. Port 77 can replace any of 44 +specified members of that set. The sets and the exact recovery relation +are in [RESULT.json](RESULT.json), fields `eligible_optimal_ports`, +`optimal_omissions`, and `coordinate_relation`. + +The fixed-set threshold and underlying rank-66 family are credited +predecessor results. The new delta is the adaptive/zero-error implication, +the complete classification of optimal terminal read sets, and explicit +family decoders for all 45 sets. Exact rechecking of the rank is a premise +check, not a claim to have discovered that rank independently. The claim +is in [discussion #2205](https://github.com/CrocSwap/integer-mult-bounds/discussions/2205#discussioncomment-18942816). + +## Exact observation contract + +Use the actual 8-by-112 rational centre matrix R, selected sets A and T, +and ordinary 96-port set U from the retained +[QQ16 packet](../joint-query/README.md). Let r_p be column p of R and +b_p the first local chart axis of port p. For an owner d in the finite +regular cover group G, put + +```text +f_b(d) = bit_0(d b), interpreted in Q, +V = ker(R_U) subset Q^96, +h_p(d) = c_p f_(b_p)(d), c in V, +H(c)(d) = sum_(p in U) r_p c_p f_(b_p)(d). +``` + +The fields are constant in payload coordinates. This is the exact +first-axis family of PR2093/PR2326/PR2354. The actual routes obey +`rho_s(p)b_p=e_(9+8(s-1))`, so `B_s h=0` for every s=1,...,8 and every +owner whenever `R_U c=0`. The original selected input is +`X_A=-P_(0,A)H(c)`, with `Y_A=-X_A`, `X_U=h`, `Y_U=0` and all other +fields zero. The selected section is invertible: the packet has +`R_A R_A^T=4I`. Recovering this original A defect is equivalent to +recovering H(c). + +Under the credited ordered F0/B1 maps, F0 leaves `X_U=Y_U=h` and all +selected fields zero. B1 leaves only `Y_U=h`. The retained ordinary tail +has zero selected/completed-X/history observations and finally places h +in the former-Y endpoint, which is outside the permitted observation +contract. This inherited family argument is explained in this account's +[PR2326](https://github.com/CrocSwap/integer-mult-bounds/pull/2326) and +PR2354; this package rechecks the route and rank premises but does not +replay their full native schedule. + +Here a reader can request any **complete initial ordinary array** h_p, +one port at a time, without modifying it. It can retain all responses, +perform arbitrary computations, choose the next port adaptively, and +stop based on its transcript. The unmodified QQ16 observations above may +be supplied for free; they are zero throughout this family. Repeated +reads count only once. No other input-dependent information, header, +dense query, source preprocessing, or changed physical call is available. +In particular, this theorem does not assume that a complete dense +`B0 h` array has one scalar's information. + +For each p the function f_(b_p) is nonzero at a certified actual owner. +Thus h_p is equivalent to the one rational scalar c_p: the complete +array is determined by c_p, and reading a nonzero entry recovers it. +The oracle model grants that scalar for free. It is a favorable +information relaxation, with no charge for native access or retention. +The claim concerns this side-effect-free reader, not arbitrary physical +adaptive interventions inside the QQ16 word. + +## Transcript-fiber theorem + +Let V be a finite-dimensional vector space over a field F. Let H be a +linear target and let q_1,...,q_N be scalar linear query functionals on V. +An exact deterministic oracle algorithm receives no input-dependent +information except answers to adaptively selected q_i. It terminates +with H(c) for every c in V. Its internal computations and output map +need not be linear, continuous, or bounded in cost. + +Fix any input c and its finite terminal transcript, and let S be the set +of queried indices. Write `Q_S=(q_i)_(i in S)` and `K_S=ker(Q_S|V)`. +For every v in K_S, the run on c+v has exactly the same transcript. +Indeed, its first query is the same; if the histories agree through a +step, its next query or stopping decision is the same. Every query on +the fixed path lies in S and has the same answer on c and c+v. Induction +reaches the same leaf and output. + +Exactness on both inputs therefore gives + +```text +H(K_S)=0, ker(Q_S|V) subset ker(H|V). (1) +``` + +Consequently H factors through Q_S and + +```text +|S| >= rank(Q_S|V) >= rank(H|V). (2) +``` + +This holds for **every terminal path**, not only the zero-input branch +or the worst case. Conversely, a fixed S satisfying (1) admits a linear +decoder for H; define it on Q_S(V) using H(c), which is well-defined by +(1). Adaptive choice cannot manufacture information about a direction +in the terminal query kernel. + +For QQ16 the checked rank is 66, so (2) excludes every path with fewer +than 66 distinct port reads. The original fixed 66-port set attains +family decoding, proving a sharp threshold in this oracle contract. + +### Zero-error randomization + +Assume one input-independent probability space of random seeds. For +each c in the **countable** rational space V, the reader terminates and +returns H(c) with probability one. Intersect these full-measure events +over all c in V. Countability gives a common full-measure set of seeds +for which the deterministic seeded reader is total and exact on all V. +The preceding theorem applies to each such seed and every input. +Thus at least 66 distinct reads are required almost surely, and the +expected count on each input is at least 66. + +The statement includes the optimal-set classification below on every +66-read path for these seeds. It makes no bounded-error assertion and +does not silently interchange an uncountable family of probability-one +events. Input-dependent advice or side channels violate the contract. +The all-input assertion is for V over Q; it does not claim the same +pathwise minimum on an arbitrary finite, bounded coefficient promise. + +## Source-bound finite premises + +Group the ports by their first axes. If C_b is one group, let +`L_b(c)=sum_(p in C_b) r_p c_p`. H factors through the direct sum L of +these group maps. The actual source has 47 groups. The axis-2 group C +has 30 columns and rank eight; all other groups have independent +columns, 66 columns in total. Hence `rank L=74`. + +Vectors supported on C with `R_C c_C=0` form a 22-dimensional subspace +K of V and have H(c)=f_2 R_C c_C=0. Also `dim V=96-8=88`. Therefore +`rank(H|V)<=88-22=66` for the **whole owner array**. + +For a matching lower bound, the verifier constructs an integer basis +N of V and evaluates H on the 17 actual owners used by PR2354: +identity and `rho_1(p)` for p=0,...,15. The resulting 136-by-88 matrix +has a 66-by-66 integer minor with determinant + +```text +174085318024506601157689344. +``` + +The receipt includes the minor, its original row and basis-column +indices, and a digest of the reproducibly constructed basis N. Exact +rational elimination selects it; fraction-free integer elimination +checks the determinant with every division checked. This is a direct +certificate on V, complementary to the predecessor's rank-74 certificate +on the whole coefficient space. A nonzero evaluation minor proves a +lower bound for the complete owner map; the matching upper bound is the +all-owner factorization above. No independence of formal bit functions +or sampled-owner extrapolation is assumed. We have proved + +```text +rank(H|V)=66, ker(H|V)=K. (3) +``` + +## All 45 optimal terminal sets + +If an exact leaf has |S|=66, (1), (3), and rank-nullity imply +`ker(Q_S|V)=K`: both kernels have dimension 22. In particular, every +queried coordinate must vanish on K. The exact source census gives: + +* Every coordinate outside C vanishes on K, since K is supported on C. +* Each of the 29 coordinates in `C minus {77}` varies on K. The receipt + supplies a kernel vector with that coordinate nonzero, and deleting + its R_C column leaves rank eight. +* Coordinate 77 vanishes on K. Deleting that column reduces rank to seven. + +Thus every optimal S is a 66-subset of the 67-element set +`J=(U minus C) union {77}`. The single dependence among these 67 +coordinate functionals on V is particularly simple. Set + +```text +w=(-1,0,1,0,1,0,1,0), +alpha_p=(w r_p)/(-4), p in U minus C. +``` + +The checker verifies that w annihilates `R_(C minus {77})`, while +`w r_77=-4`. Therefore `R_U c=0` gives + +```text +c_77 + sum_(p in U minus C) alpha_p c_p = 0. (4) +``` + +Exactly 44 of the 66 alpha_p are nonzero, all in `{1/2,-1/2}`. The +original 66 coordinates `U minus C` are independent on V: H factors +through them and has rank 66. Thus (4) spans the entire dependence +space on J. Removing one coordinate q from J leaves an independent +66-set exactly when its coefficient in (4) is nonzero. This gives +**45 sets**: omit 77, or omit one of those 44 ports. Omitting one of +the other 22 ports leaves query rank 65 and cannot recover H. + +The verifier checks all 67 candidate ranks separately. Any 66-read +adaptive leaf outside J is already excluded by its explicit nuisance +vector in K. Together these arguments exhaust all `choose(96,66)` +possible read sets without enumerating them. Adaptivity may choose +among the 45 successful leaves, but cannot reduce the count or use a +29-coordinate nuisance direction at an optimal leaf. + +### Explicit attaining decoders + +Let S0=U minus C. Since all unread first axes equal 2 and R_U c=0, + +```text +H(c)(d) = sum_(p in S0) r_p c_p [f_(b_p)(d)-f_2(d)]. (5) +``` + +This is an all-owner identity. It reconstructs H from the 66 scalars in +S0, without reconstructing the 30 unread coefficients. If a successful +set omits q in S0 and reads 77 instead, use (4) to obtain + +```text +c_q = [-c_77 - sum_(p in S0 minus {q}) alpha_p c_p]/alpha_q +``` + +and apply (5). Every division is by a nonzero rational. The verifier +checks (5) on all 88 kernel-basis vectors and all 136 evaluation rows, +and checks every exchanged decoder on all 88 basis vectors. Its formal +proof covers every owner. Finally apply `-P_(0,A)` if the requested +output is the original selected A input rather than H. + +These are family decoders only. They do not establish recovery on a +different hidden family or arbitrary QQ16 inputs, legal native final +reads, a restored physical controller, or any favorable recursive bill. + +## Reproduction and evidence boundary + +Python 3.12 and the standard library suffice: + +```sh +python3 -I -B scripts/research_package.py --package research/qq16-adaptive-coordinate-reads +python3 -I -O -B research/qq16-adaptive-coordinate-reads/verify.py +``` + +The direct replay prints: + +```text +PASS_QQ16_ADAPTIVE_READS defect=66 optimum=66 optimal_sets=45 nuisance_coordinates=29 controls=11 no_new_kappa +``` + +The replay is read-only. `--emit NEW_PATH` creates a receipt exclusively. +The whole canonical receipt, including JSON scalar types, must agree. +Source bytes and the consumed archive member are authenticated before +arithmetic; main-file pins and Git blobs are in [SOURCES.json](SOURCES.json). +No pending-PR executable is required or imported. + +The 11 rejecting controls include a singular minor, wrong determinant, +identity-owner/routing shortcuts, an omitted attaining coordinate, +wrong decoder sign, the false 65-read and unique-set claims, a wrong +kernel-constant assertion, a singular exchanged read set, and a JSON +type mutation. A separate exhaustive decision-tree control over 16 +binary inputs considers every adaptive branch choice (147 distinct +cells): two pair-parity targets with five scalar queries require three +reads even on average. A dense vector query reduces that toy count to +one; a nonlinear OR target permits shorter paths. These controls expose +the observation and linear-target hypotheses; they do not prove the +rational infinite-domain theorem. + +All results are author-checked, with substantial AI assistance. The +proof is written mathematics, not proof-assistant formalization. The +rank, route and decoder checks do not reexecute native QQ16 children, +the full selected supplier, all-size precision or the outer multiplier. +The count 66 is neither per owner nor a recursive-rank/native-line +tariff. No selected-frontier change or independent human review is claimed. + +## Open next questions + +1. **Which of the 45 family-optimal sets has a favorable native access + bill, and does it detect other hidden families?** The new classification + narrows that search to a finite list. All 45 sets omit the same 29 + ports `C minus {77}`. A separate hidden-input witness supported there + would defeat all 45 sets at once. First check that precise support + and the full ordered observations, then price any surviving change. + Family sufficiency is the blocker; the complementary second-axis + investigation tests the original set. That separate witness is not + checked or incorporated into a stronger bound by this package. +2. **What quantitative bound holds for bounded-error readers?** The + zero-error countable-intersection argument does not answer it. First + specify an input distribution and success criterion and derive a + distributional decision-tree bound. Arbitrary rational inputs have no + preferred uniform distribution, so an unstated average-case model + would not be meaningful. + +Structured questions and the task card are in [TASK.json](TASK.json). + +## Credit and exact predecessors + +Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. + +* **kyzer1023, PR2354**, head + `308ebc7405303bb7ed91b012bb705949c6091a16`: whole-owner rank 74, + defect 66, the 17-owner certificate idea, and the fixed-set family + threshold. Its exclusion of adaptive reads is the changed premise here. +* **commdata2338, PR2326**, head + `fb7d64cd4a51c49bc56920305b0aca64011a420c`: coordinate-access contract, + eight-dimensional identity-owner defect, and the threshold handoff. +* **Adam Gall, PR2093**, head + `8b21a900eb520e4f11ea177b310f66316f8e8983`: common-axis rational + bit-function family, initial A cancellation and retained-tail argument. +* **Ali Romman, PR1969**: local QQ16 contracts, actual route packet, + native frame conventions and original lost-query witness. +* **Cinna Davis, PR2216/PR2268**, and **EdDiboi's parallel fixed-set + parity-subspace work**: the shear/tap question and complementary + fixed-coordinate threshold evidence. The selected-shear acts trivially + on this family and is not charged as a new construction here. + +Scientific base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`, priority +revision 4. The selected result and all frozen inputs are unchanged. +Retain the QQ16 [NOTICE.md](../joint-query/NOTICE.md) and original +construction lineage. New proof and code are Apache-2.0. OpenAI Codex +did the derivation, implementation, checking and writing; no independent +human review is claimed. diff --git a/research/qq16-adaptive-coordinate-reads/RESULT.json b/research/qq16-adaptive-coordinate-reads/RESULT.json new file mode 100644 index 0000000000..7e5fa1531a --- /dev/null +++ b/research/qq16-adaptive-coordinate-reads/RESULT.json @@ -0,0 +1,609 @@ +{ + "H_kernel_dimension": 22, + "H_on_V_rank": 66, + "V_basis_sha256": "aa6f9152067a4b3fbee1b72c6ed3eab2124ab393bde3111b4259d487c4bcb4b8", + "V_dimension": 88, + "adaptive_tree_control": { + "dense_vector_query_optimum": 1, + "domain": "F2^4, five scalar linear queries", + "nonlinear_OR_mean_queries": "3/2", + "optimal_mean_queries": "3", + "optimal_worst_queries": 3, + "states": 147 + }, + "axis_groups": 47, + "candidate_read_ranks": [ + { + "omitted_port": 1, + "rank": 65 + }, + { + "omitted_port": 2, + "rank": 65 + }, + { + "omitted_port": 3, + "rank": 65 + }, + { + "omitted_port": 4, + "rank": 65 + }, + { + "omitted_port": 5, + "rank": 65 + }, + { + "omitted_port": 6, + "rank": 66 + }, + { + "omitted_port": 8, + "rank": 66 + }, + { + "omitted_port": 9, + "rank": 66 + }, + { + "omitted_port": 10, + "rank": 66 + }, + { + "omitted_port": 11, + "rank": 66 + }, + { + "omitted_port": 12, + "rank": 66 + }, + { + "omitted_port": 13, + "rank": 66 + }, + { + "omitted_port": 14, + "rank": 66 + }, + { + "omitted_port": 15, + "rank": 66 + }, + { + "omitted_port": 16, + "rank": 66 + }, + { + "omitted_port": 17, + "rank": 66 + }, + { + "omitted_port": 18, + "rank": 66 + }, + { + "omitted_port": 19, + "rank": 66 + }, + { + "omitted_port": 22, + "rank": 66 + }, + { + "omitted_port": 23, + "rank": 66 + }, + { + "omitted_port": 24, + "rank": 66 + }, + { + "omitted_port": 25, + "rank": 66 + }, + { + "omitted_port": 26, + "rank": 66 + }, + { + "omitted_port": 28, + "rank": 66 + }, + { + "omitted_port": 29, + "rank": 66 + }, + { + "omitted_port": 30, + "rank": 66 + }, + { + "omitted_port": 31, + "rank": 66 + }, + { + "omitted_port": 32, + "rank": 66 + }, + { + "omitted_port": 33, + "rank": 66 + }, + { + "omitted_port": 34, + "rank": 66 + }, + { + "omitted_port": 35, + "rank": 66 + }, + { + "omitted_port": 38, + "rank": 66 + }, + { + "omitted_port": 39, + "rank": 66 + }, + { + "omitted_port": 40, + "rank": 66 + }, + { + "omitted_port": 41, + "rank": 66 + }, + { + "omitted_port": 42, + "rank": 66 + }, + { + "omitted_port": 43, + "rank": 66 + }, + { + "omitted_port": 77, + "rank": 66 + }, + { + "omitted_port": 78, + "rank": 66 + }, + { + "omitted_port": 79, + "rank": 66 + }, + { + "omitted_port": 80, + "rank": 66 + }, + { + "omitted_port": 82, + "rank": 66 + }, + { + "omitted_port": 83, + "rank": 66 + }, + { + "omitted_port": 84, + "rank": 66 + }, + { + "omitted_port": 85, + "rank": 66 + }, + { + "omitted_port": 86, + "rank": 66 + }, + { + "omitted_port": 88, + "rank": 66 + }, + { + "omitted_port": 89, + "rank": 66 + }, + { + "omitted_port": 90, + "rank": 66 + }, + { + "omitted_port": 91, + "rank": 66 + }, + { + "omitted_port": 93, + "rank": 65 + }, + { + "omitted_port": 94, + "rank": 65 + }, + { + "omitted_port": 95, + "rank": 65 + }, + { + "omitted_port": 96, + "rank": 65 + }, + { + "omitted_port": 97, + "rank": 65 + }, + { + "omitted_port": 98, + "rank": 65 + }, + { + "omitted_port": 99, + "rank": 65 + }, + { + "omitted_port": 100, + "rank": 65 + }, + { + "omitted_port": 101, + "rank": 65 + }, + { + "omitted_port": 102, + "rank": 65 + }, + { + "omitted_port": 103, + "rank": 65 + }, + { + "omitted_port": 104, + "rank": 65 + }, + { + "omitted_port": 105, + "rank": 65 + }, + { + "omitted_port": 106, + "rank": 65 + }, + { + "omitted_port": 107, + "rank": 65 + }, + { + "omitted_port": 108, + "rank": 65 + }, + { + "omitted_port": 109, + "rank": 65 + } + ], + "claim": "Exact side-effect-free coordinate-oracle recovery on the credited rational family; not full controller recovery or a physical cost.", + "coloop_ports": [77], + "coordinate_relation": { + "1": "0", + "10": "1/2", + "100": "0", + "101": "0", + "102": "0", + "103": "0", + "104": "0", + "105": "0", + "106": "0", + "107": "0", + "108": "0", + "109": "0", + "11": "1/2", + "12": "-1/2", + "13": "-1/2", + "14": "-1/2", + "15": "-1/2", + "16": "-1/2", + "17": "1/2", + "18": "1/2", + "19": "1/2", + "2": "0", + "22": "1/2", + "23": "1/2", + "24": "1/2", + "25": "1/2", + "26": "1/2", + "28": "1/2", + "29": "1/2", + "3": "0", + "30": "1/2", + "31": "1/2", + "32": "1/2", + "33": "1/2", + "34": "1/2", + "35": "1/2", + "38": "1/2", + "39": "1/2", + "4": "0", + "40": "1/2", + "41": "-1/2", + "42": "-1/2", + "43": "-1/2", + "5": "0", + "6": "-1/2", + "77": "1", + "78": "-1/2", + "79": "1/2", + "8": "-1/2", + "80": "-1/2", + "82": "-1/2", + "83": "-1/2", + "84": "-1/2", + "85": "1/2", + "86": "1/2", + "88": "1/2", + "89": "1/2", + "9": "1/2", + "90": "1/2", + "91": "1/2", + "93": "0", + "94": "0", + "95": "0", + "96": "0", + "97": "0", + "98": "0", + "99": "0" + }, + "data_member_sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "decoder_basis_equalities": 11968, + "defect_minor": { + "basis_columns": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 37, 40, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87], + "determinant": "174085318024506601157689344", + "matrix": [ + [-1, -1, -1, 1, 1, 1, 1, -2, -2, -2, -2, -2, -2, -3, -3, -3, -3, -3, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, -1, -3, -1, -1, -1, -1, -1, -5, 3, -1, 1, 1, 1, 1, -1, -1, -1, -2, -2, -2, -1, 1, -1, -1, -1, 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, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, -1, 1, 1, 1, 0, 0, 0, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], + [1, 1, 1, -1, -1, -1, 0, 1, 1, 1, 2, 2, 2, 3, 1, 1, 1, 1, 3, 3, 3, 3, 1, 1, 1, 1, -1, -1, -1, 3, 3, -1, -1, -1, 1, -1, 3, -1, 3, -1, -1, -1, -1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], + [-1, 0, 0, 1, 0, 0, 1, -2, -1, -1, -1, -1, 0, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 2, 2, 2, 0, -2, -2, 0, 0, 0, -2, -2, 2, -2, 2, 2, 2, 2, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, -1, 1, 0, 1, -1, 0, 0, -1, 1, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, -1, -1, 0, 1, 1, 1, -1, -2, -2, -1, -1, -2, -6, -4, -4, -4, -4, -4, -4, -4, -4, -2, -2, -2, -2, 2, 2, 2, 0, -2, 0, -2, -2, 0, 0, -4, 4, -4, 2, 2, 2, 2, -1, -1, -1, -1, -2, -2, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0], + [1, 0, 0, -1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 4, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 2, 2, -2, 2, 0, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -5, -3, -3, -3, -3, -3, -3, -3, -3, -1, -1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -3, 3, -1, 1, 1, 1, 1, -1, -1, -1, -2, -2, -2, -1, 0, -1, -1, -1, -1, 0, -1, -1, -1, -1, 0, 0, 0, -1, -1, -1], + [0, 0, 0, 0, 0, 0, -1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, -2, 2, -2, -2, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, -1, -1, -1, -1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, -1, -1, -1, 0, 0, 0], + [0, 0, 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, -2, 0, 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, 1, 1, 1, -1, -1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1], + [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, -1, -1, -1, 3, 3, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, 1, -1, 1, 0, 1, 1, -1, 0, -1, 0, 0, 0, 1, 0, 1, 1, -1, 0, 1, 1, -1, 0, 0], + [0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, -1, 1, 0, -1, 1], + [0, 0, 0, 0, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -3, -3, -3, -3, 1, -1, 1, 1, -1, -1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -3, 1, -1, -1, 1, -1, -1, 0, -1, 0, 0, -1, -1, -1, 0, 0, -1, -1, 0, 1, 1, 0, 0, -1, 1, 0, 0, 0, -1, -1], + [0, 0, 0, -1, 0, 0, -1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 0, 0, 1, 0, 1, 2, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0], + [0, 0, 0, 0, 0, 0, 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, -1, 0, 0, -1, -1, -1, 0, -1, 0, 0, 0, 0, 0, -1, -1, -1, -1, 0, 0, 0, -1, -1, -1], + [0, 0, 0, 0, 0, 0, 1, -1, -1, -1, 0, 0, 0, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 0, 0, 0, 0, -1, 1, 1, 1, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, 1, 1, 1, 0, -1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1], + [0, 0, 0, 0, 0, 0, -1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, -1, 1, 1, -3, -1, -1, 1, 1, 1, 0, 1, 1, 1, 0, -1, 0, 0, 1, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, -1, 1, 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, -2, 2, 0, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, -1, 1, 0, -1, 1], + [0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, -2, -2, 0, 0, 1, 1, 0, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 0, -1, 1, 0, 0, 0, -1, -1], + [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 0, 1, 0, 0, 1, 1, 0, -1, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, 1, 0, 0], + [1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], + [0, 0, 0, -1, -1, -1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 2, -2, 2, -2, -2, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1], + [0, 0, 0, 1, 1, 1, 0, -1, -1, -1, -1, -1, -1, -3, -3, -3, -3, -3, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -3, 1, -1, 1, -1, -1, -1, 0, 0, -1, -1, -1, -1, 0, 1, -1, -1, -1, 0, 0, -1, -1, -1, 0, -1, -1, -1, 0, 0, 0], + [1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 3, 3, 3, 3, 3, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 3, -3, 3, -3, -1, -1, -1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1], + [-1, -1, -1, 1, 1, 1, 2, -2, -2, -2, -2, -2, -2, -6, -4, -4, -4, -4, -4, -4, -4, -4, 0, 0, -2, -2, 2, 2, 2, -2, -2, 0, 0, 0, 0, 0, -6, 4, -4, 0, 0, 2, 2, 0, 0, -2, -2, -1, -1, -2, 1, -2, -1, -1, -2, -1, -2, -1, -1, 0, 0, 1, 1, -1, 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, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, -1, 1, 0, -1, 1], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, -1, -1, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 0, 0, -1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0], + [-1, -1, -1, 1, 1, 1, 2, -2, -2, -2, -2, -2, -2, -5, -3, -3, -3, -3, -3, -3, -3, -3, -1, -3, -1, -1, 1, 1, 1, -1, -3, -1, -1, -1, -1, -1, -5, 5, -5, 1, 3, 1, 1, 0, 0, -1, -1, -2, -2, -2, 0, -1, -2, -2, -2, 0, -1, -2, -2, -1, 1, 0, 0, 0, -1, -1], + [-1, 0, 0, 0, 0, 0, 0, -1, 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, -1, 0, 0, 0, -1, -1, 0, -1, 0, 0, 0, -1, 0, 0, -1, -1, -1, 0, 0, 0, 0, -1, -1], + [0, 0, 0, 1, 0, 0, 0, -1, 0, 0, -1, -1, 0, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0], + [0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, -2, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, -1, 0, -1, -1, 1, 0, -1, -1, 0, 0, 0], + [-1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 0, -1, -1, 0, 0, 0, 0, -1, 1, 1, -1, -1, -1, 0, 0, 0, -1, 1, 1, -1, 1, 1], + [1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, -3, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 0, 1, 0, 0, -1, 0, 1, 0, 0, -1, 1, 1, 1, 1, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, 0, -1, 1, 0, 0, -1, 1, 0, -1, 1], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 0, 0, 1, -1, 0, 0, 0, -1, -1, 0, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, -1, -1, -1], + [1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, -1, 1, 0, -1, -1, -1, -1, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0], + [0, -1, 0, 0, 0, 0, 0, 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, -1, 0, 0, -1, 0, -1, 0, -1, 0, 0, 0, -1, 0, -1, 0, -1, -1, 0, 0, 0, -1, 0, -1], + [0, 0, 0, 0, 1, 0, 0, 0, -1, 0, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, -1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0], + [0, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, -2, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, -2, 0, -2, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, -1, -1, 0, -1, 1, -1, 0, -1, 0, 0, 0], + [0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 0, -1, 0, -1, 0, 0, 0, 1, -1, 1, -1, -1, 0, -1, 0, 0, 1, -1, 1, 1, -1, 1], + [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -2, 0, 0, 1, 1, 1, 0, 0, 1, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, 1, -1, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, -2, 0, 0, -2, 0, 0, 1, 1, 0, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 0, -1, 1, 0, 0, 0, 0, -1], + [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, 1, 0, 1, 1, 0, -1, 1, 0, 1, -1, -1, -1, 0, 1, -1, 0, 1, 1, 0, 1, 1, 0], + [0, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, -1, 0, 0, -1, -1, 0, 0, -1, 0, 0, 0, -1, 0, -1, -1, 0, -1, 0, 0, 0, -1, -1, 0], + [0, 0, 0, 0, 0, 1, 0, 0, 0, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1], + [0, 0, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, -2, -2, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, -1, -1, -1, 0, 1, -1, -1, 0, 0, 0, 0], + [0, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, -1, 0, -1, 0, 0, -1, 0, 0, 1, 1, -1, -1, -1, 0, 0, -1, 0, 1, 1, -1, 1, 1, -1], + [0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -2, 0, 0, 1, 1, 1, 0, 1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 1, 0, -1, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, -1, 1, 1, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, -1, -1, 0, 0, 0, -1, -1, 0, 0, -1, -1, 0, -1, -1], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, -2, 0, -2, 0, 0, 0, 1, 1, 0, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 0, -1, 1, 0, 0, 0, -1, 0], + [1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 5, 3, 3, 3, 3, 1, 1, 1, 1, 3, 3, 3, 3, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, 3, -3, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1], + [0, 0, 0, 0, 0, 0, -1, 1, 1, 1, 1, 1, 1, 5, 1, 1, 1, 1, 3, 3, 3, 3, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 3, -1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, -1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 3, -3, 1, -1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, -1, 1, 1, 1, 0, 1, 1, 1, 1, -1, 1, 1, 1, 0, 0, 0], + [-1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -3, -1, -1, -1, -1, -3, -3, -3, -3, -3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -3, 1, -3, 3, 1, 1, 1, 0, 0, -1, -1, -1, -1, 0, 0, -1, -1, -1, 0, 0, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1], + [1, 0, 0, -1, 0, 0, -2, 2, 2, 2, 2, 2, 2, 6, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 2, 2, 0, 0, -2, 2, 2, 0, 0, 0, 0, 0, 6, -4, 4, 0, 0, -2, -2, 0, 0, 2, 2, 2, 2, 2, -1, 2, 1, 1, 2, 1, 2, 1, 1, 1, 0, -1, -1, 1, 0, 0], + [0, 1, -1, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 1, -1, 0, 0, 1, -1, 0, 1, -1], + [1, 0, 0, 0, 0, 0, 1, 0, -1, -1, 0, 0, 0, -2, -2, -2, -2, -2, 2, -2, 0, 0, 2, -2, 0, 0, 2, 2, 0, 0, -2, 0, 0, 0, 2, -2, 0, 2, 0, -2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -2, 1, 0, -1, -1, -1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0], + [0, 1, -1, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 2, 0, 0, -2, 2, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 1, -1, 0, 0, 1, -1, 0, 1, -1], + [0, 0, 0, -1, 0, 0, -1, 0, 1, 1, 0, 0, 0, 0, 0, 2, 0, 0, -2, 0, 0, 0, 0, 2, 0, 0, -2, -2, 0, -2, 0, 0, 0, 0, -2, 2, 2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, 0], + [0, 0, 0, 0, -1, 0, -1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 2, 0, -2, 0, 0, 0, 0, 0, 2, 0, -2, 0, -2, -2, 0, 0, 0, 0, -2, 2, 2, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0], + [0, 0, 0, 0, 0, -1, -1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 0, 0, 2, 0, -2, -2, -2, 0, 0, 0, 0, -2, 2, 2, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0] + ], + "rows": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 56, 57, 58, 59, 60, 61, 68, 69, 114, 122, 130] + }, + "dual_normalizer": -4, + "dual_vector": [-1, 0, 1, 0, 1, 0, 1, 0], + "eligible_optimal_ports": [1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 38, 39, 40, 41, 42, 43, 77, 78, 79, 80, 82, 83, 84, 85, 86, 88, 89, 90, 91, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109], + "nuisance_witnesses": [ + { + "coordinate_value": -1, + "kernel_vector": [-1, 1, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 44 + }, + { + "coordinate_value": 1, + "kernel_vector": [-1, 1, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 45 + }, + { + "coordinate_value": -1, + "kernel_vector": [-1, 1, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 48 + }, + { + "coordinate_value": -1, + "kernel_vector": [-1, 1, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 49 + }, + { + "coordinate_value": -1, + "kernel_vector": [-1, 1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 50 + }, + { + "coordinate_value": 1, + "kernel_vector": [-1, 1, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 51 + }, + { + "coordinate_value": 1, + "kernel_vector": [-1, 1, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 52 + }, + { + "coordinate_value": 1, + "kernel_vector": [-1, 1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 53 + }, + { + "coordinate_value": -1, + "kernel_vector": [0, 0, 0, 1, -1, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 54 + }, + { + "coordinate_value": 1, + "kernel_vector": [0, 0, 0, 1, -1, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 55 + }, + { + "coordinate_value": 1, + "kernel_vector": [0, 0, 1, 0, -1, 0, 0, 0, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 56 + }, + { + "coordinate_value": -1, + "kernel_vector": [0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 58 + }, + { + "coordinate_value": 1, + "kernel_vector": [0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 59 + }, + { + "coordinate_value": 1, + "kernel_vector": [0, 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 60 + }, + { + "coordinate_value": 1, + "kernel_vector": [1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 61 + }, + { + "coordinate_value": 1, + "kernel_vector": [1, -1, -1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 62 + }, + { + "coordinate_value": 1, + "kernel_vector": [1, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 63 + }, + { + "coordinate_value": 1, + "kernel_vector": [0, 0, 1, 0, 0, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 64 + }, + { + "coordinate_value": 1, + "kernel_vector": [0, 0, 1, 1, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 65 + }, + { + "coordinate_value": 1, + "kernel_vector": [0, 0, 2, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 66 + }, + { + "coordinate_value": 1, + "kernel_vector": [-2, 1, -1, -1, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 67 + }, + { + "coordinate_value": 1, + "kernel_vector": [-2, 1, 0, -2, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], + "port": 68 + }, + { + "coordinate_value": 1, + "kernel_vector": [-2, 1, 0, -1, -1, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], + "port": 69 + }, + { + "coordinate_value": 1, + "kernel_vector": [-1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], + "port": 70 + }, + { + "coordinate_value": 1, + "kernel_vector": [-1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], + "port": 71 + }, + { + "coordinate_value": 1, + "kernel_vector": [-1, 0, 1, -1, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], + "port": 72 + }, + { + "coordinate_value": 1, + "kernel_vector": [-2, 1, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], + "port": 73 + }, + { + "coordinate_value": 1, + "kernel_vector": [-2, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], + "port": 74 + }, + { + "coordinate_value": 1, + "kernel_vector": [-2, 1, 1, -1, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], + "port": 75 + } + ], + "optimal_omissions": [6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 38, 39, 40, 41, 42, 43, 77, 78, 79, 80, 82, 83, 84, 85, 86, 88, 89, 90, 91], + "optimal_read_set_count": 45, + "ordinary_dimension": 96, + "original_attaining_read_set": [1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 38, 39, 40, 41, 42, 43, 78, 79, 80, 82, 83, 84, 85, 86, 88, 89, 90, 91, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109], + "owner_evaluations": 17, + "registered_nonzero_routes": 896, + "rejecting_controls": [ + "singular defect minor", + "wrong determinant", + "identity owner substituted for whole array", + "identity substituted as stage-one route", + "one attaining port omitted", + "wrong f2 decoder sign", + "65 scalar queries claimed enough", + "C coordinate declared constant on invisible kernel", + "unique optimal set claimed", + "zero relation coefficient used for exchange", + "JSON Boolean substituted for integer" + ], + "schema": "qq16-adaptive-coordinate-reads-v1", + "source_hashes": { + "research/community-frontier1042-audit/selected-replay.tar.gz": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "research/joint-query/certificate.json.gz": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4" + }, + "status": "PASS_QQ16_ADAPTIVE_READS", + "unread_axis2_group": [44, 45, 48, 49, 50, 51, 52, 53, 54, 55, 56, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 77] +} diff --git a/research/qq16-adaptive-coordinate-reads/SOURCES.json b/research/qq16-adaptive-coordinate-reads/SOURCES.json new file mode 100644 index 0000000000..30b80ff300 --- /dev/null +++ b/research/qq16-adaptive-coordinate-reads/SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/community-frontier1042-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "6f4dc6fe7631d8aacf8081fcaecf32197181685b", + "sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754" + }, + { + "path": "research/joint-query/certificate.json.gz", + "usage": "input", + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" + }, + { + "path": "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "usage": "input", + "git_blob": "a6805c58f23132f9420efebf90f5b7e863c2e179", + "sha256": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75" + }, + { + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json", + "usage": "input", + "git_blob": "5082d791d0b993492cbc5bf61ac3b69e82c96f3f", + "sha256": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4" + } + ] +} diff --git a/research/qq16-adaptive-coordinate-reads/TASK.json b/research/qq16-adaptive-coordinate-reads/TASK.json new file mode 100644 index 0000000000..b6375a4994 --- /dev/null +++ b/research/qq16-adaptive-coordinate-reads/TASK.json @@ -0,0 +1,136 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "joint-query-controller", + "question": "Can one explicitly changed QQ16 interface recover the missing chart query and close a two-call controller within a favorable full budget?", + "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" + ], + "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." + ], + "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.", + "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." + }, + "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.", + "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." + ], + "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." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969" + ] + }, + "scope_status": "refined", + "actual_scope": "Exact adaptive coordinate-oracle recovery on the PR2354 rational QQ16 common-first-axis family: sharp 66 distinct reads on every input, zero-error randomized extension, and classification of all 45 optimal terminal read sets.", + "scope_change_reason": "Take the live central coordinate-access boundary in PR2354, which explicitly excludes adaptivity. This is a scoped lower bound for that repair, not a completed controller or native-cost construction.", + "bottleneck_link": "The QQ16 controller loses selected input information. Adaptive choices of ordinary reads are a possible interface change; this proof excludes fewer than 66 ports on the credited family even with free reads, computation and retention, and lists the family-optimal sets to screen before native pricing.", + "budget_minutes": 60, + "stop_rule": "Stop after the quantified transcript-fiber proof, exact source-bound finite premises and complete optimal-set classification. No search for a full controller, new family, or supplier bill.", + "outcome": "completed", + "evidence": "README.md contains the scoped proof. RESULT.json contains a 66x66 integer minor with determinant 174085318024506601157689344, 29 kernel-coordinate witnesses, all 67 candidate read-set ranks (45 of rank 66), all 44 exchange decoders, 11968 owner/basis equalities, 11 rejecting controls and exhaustive finite adaptive-tree controls. VERIFY.json registers normal, optimized and artifact-integrity replays.", + "author": "commdata2338", + "ai_assistance": "Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. OpenAI Codex did the derivation, implementation, checking and writing. No independent human review is claimed.", + "open_questions": [ + { + "question": "Which of the 45 family-optimal sets survives other hidden-input families and has a favorable complete native access bill?", + "why_it_matters": "Family decoding alone cannot restore an arbitrary QQ16 input; the classification makes the remaining fixed-set choices explicit.", + "first_step": "All 45 sets omit C minus {77}. First test a different hidden-input witness supported on those same 29 ports against the complete ordered observations; a successful witness would screen all optimal sets at once.", + "blocked_by": "No full controller injectivity or native implementation is established here; complementary second-axis work tests the original set." + }, + { + "question": "What distributional lower bound holds for bounded-error adaptive readers?", + "why_it_matters": "The zero-error countability proof does not apply to algorithms permitted a positive failure probability.", + "first_step": "Specify a finite rational input distribution and exact-output success criterion, then prove a decision-tree success bound.", + "blocked_by": "There is no uniform distribution on all rational inputs; the input and error model must be explicit." + } + ], + "scope_key": "22e535909f1d243e7553", + "refined_scope_key": "QQ16/PR2354-first-axis-family/adaptive-coordinate-decision-trees/exact-recovery", + "selection": { + "mode": "central-interface-followup override", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/2354", + "reason": "The predecessor explicitly excludes adaptive coordinate choices; the dense old-chart and full dispatch handoffs are already active. This takes a distinct QQ16 access-contract question.", + "task_retrieval_nonce": "68a7f11a97c2e55fc020480ffc2b66fd", + "track": "recursive-interfaces", + "scope_key": "22e535909f1d243e7553" + }, + "predecessors": [ + { + "pr": 2354, + "head": "308ebc7405303bb7ed91b012bb705949c6091a16", + "author": "kyzer1023", + "use": "Fixed-set threshold, whole-owner rank and 17-owner lower-certificate construction; source read, no executable imported." + }, + { + "pr": 2326, + "head": "fb7d64cd4a51c49bc56920305b0aca64011a420c", + "author": "commdata2338", + "use": "Coordinate-access contract and hidden-family trajectory." + }, + { + "pr": 2093, + "head": "8b21a900eb520e4f11ea177b310f66316f8e8983", + "author": "Adam Gall", + "use": "Common-axis bit-function family and cancellation argument." + } + ], + "coordination": { + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2205#discussioncomment-18942816", + "nearest_parallel": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2205#discussioncomment-18942783", + "difference": "The parallel investigation changes the first-axis family to a second-axis witness against the original fixed attaining set. This package retains the first-axis family, changes the query rule to adaptive, and classifies all optimal terminal sets." + }, + "refresh_checkpoint": { + "utc": "2026-10-15T07:03:27Z", + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "changes_from_base": "none; main, guidance, selected record and retained source inputs unchanged", + "decision": "continue on frozen base; exact PR2354 and PR2326 heads re-fetched unchanged" + }, + "overlap": { + "entry_open_prs_fetched_at": "2026-10-15T06:28:56.749233+00:00", + "entry_discussions_fetched_at": "2026-10-15T06:31:18.032505+00:00", + "final_open_prs_fetched_at": "2026-10-15T06:55:23.240869+00:00", + "final_discussions_fetched_at": "2026-10-15T06:57:32.010338+00:00", + "final_open_prs": 583, + "final_discussion_records": 1111, + "complete_pagination": true, + "queries": [ + "QQ16 adaptive", + "adaptive coordinate", + "adaptive tap", + "optimal read set", + "66-port" + ], + "limits": "Cached metadata coverage; excludes arbitrary code diffs. Exact predecessor heads checked separately. No novelty guarantee.", + "nearest_distinct_new_result": { + "pr": 2368, + "head": "e5d4d78dcfdd55d323fcbc60df477b9f25c7abff", + "scope": "Different full ordered kernel after the shear plus one dense old-chart record; context only, no proof dependency." + } + } +} diff --git a/research/qq16-adaptive-coordinate-reads/VERIFY.json b/research/qq16-adaptive-coordinate-reads/VERIFY.json new file mode 100644 index 0000000000..f06ec1cf7b --- /dev/null +++ b/research/qq16-adaptive-coordinate-reads/VERIFY.json @@ -0,0 +1,45 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/community-frontier1042-audit/selected-replay.tar.gz", + "research/joint-query/certificate.json.gz", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact rational/integer source premises, all optimal read sets, decoder identities, semantic controls and whole receipt equality." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "The identical acceptance boundary with Python assertions disabled." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/test_artifacts.py" + ], + "timeout_seconds": 300, + "checks": "Relocated read-only positive replay; corrupt optimal-set receipt, source bytes and missing source pin reject under optimized Python." + } + ] +} diff --git a/research/qq16-adaptive-coordinate-reads/test_artifacts.py b/research/qq16-adaptive-coordinate-reads/test_artifacts.py new file mode 100644 index 0000000000..34228395b9 --- /dev/null +++ b/research/qq16-adaptive-coordinate-reads/test_artifacts.py @@ -0,0 +1,83 @@ +"""Artifact-level positive and rejecting controls, with frozen inputs untouched.""" +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +class ArtifactTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.temp = tempfile.TemporaryDirectory(prefix="qq16-adaptive-") + cls.root = Path(cls.temp.name) + cls.package = cls.root / "research" / HERE.name + shutil.copytree(HERE, cls.package, ignore=shutil.ignore_patterns("__pycache__")) + source = json.loads((HERE / "SOURCES.json").read_text()) + for row in source["files"]: + if row["usage"] == "input": + target = cls.root / row["path"] + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(ROOT / row["path"], target) + + @classmethod + def tearDownClass(cls): + cls.temp.cleanup() + + def invoke(self): + return subprocess.run([sys.executable, "-I", "-O", "-B", str(self.package / "verify.py")], + cwd=self.root, capture_output=True, text=True, timeout=120) + + def test_1_relocated_positive_is_read_only(self): + before = {p.relative_to(self.root): p.read_bytes() for p in self.root.rglob("*") if p.is_file()} + result = self.invoke() + self.assertEqual(result.returncode, 0, result.stderr) + self.assertIn("optimal_sets=45", result.stdout) + after = {p.relative_to(self.root): p.read_bytes() for p in self.root.rglob("*") if p.is_file()} + self.assertEqual(before, after) + + def test_2_corrupted_optimal_set_is_rejected(self): + path = self.package / "RESULT.json" + original = path.read_bytes() + data = json.loads(original) + data["optimal_omissions"][0] = 1 # A port required by every optimal set. + path.write_text(json.dumps(data)) + try: + result = self.invoke() + self.assertNotEqual(result.returncode, 0) + self.assertIn("complete receipt equality", result.stderr) + finally: + path.write_bytes(original) + + def test_3_changed_source_is_rejected(self): + path = self.root / "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md" + original = path.read_bytes() + path.write_bytes(original + b"\nchanged source\n") + try: + result = self.invoke() + self.assertNotEqual(result.returncode, 0) + self.assertIn("source hash", result.stderr) + finally: + path.write_bytes(original) + + def test_4_dropped_input_pin_is_rejected(self): + path = self.package / "SOURCES.json" + original = path.read_bytes() + data = json.loads(original) + data["files"] = [r for r in data["files"] if r["path"] != "research/joint-query/certificate.json.gz"] + path.write_text(json.dumps(data)) + try: + result = self.invoke() + self.assertNotEqual(result.returncode, 0) + self.assertIn("complete declared source set", result.stderr) + finally: + path.write_bytes(original) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/qq16-adaptive-coordinate-reads/verify.py b/research/qq16-adaptive-coordinate-reads/verify.py new file mode 100644 index 0000000000..7bee2c5eeb --- /dev/null +++ b/research/qq16-adaptive-coordinate-reads/verify.py @@ -0,0 +1,378 @@ +#!/usr/bin/env python3 +"""Exact premises for the QQ16 adaptive-coordinate theorem. + +Prepared for commdata2338 with substantial OpenAI Codex assistance. +Apache-2.0. No predecessor executable is imported. Checks survive Python -O. +""" +import argparse +from collections import defaultdict +from fractions import Fraction +from functools import lru_cache +from hashlib import sha256 +import gzip +import json +from math import gcd, lcm +from pathlib import Path +import tarfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +ARCHIVE = "research/community-frontier1042-audit/selected-replay.tar.gz" +PACKET = "research/joint-query/certificate.json.gz" +DATA_MEMBER = "t16/global/base/work/complex-nine-native/DATA-PHASES.json" +DATA_SHA = "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(x): + return json.dumps(x, sort_keys=True, separators=(",", ":")) + + +def digest(x): + return sha256(canonical(x).encode()).hexdigest() + + +def rref(rows): + a = [list(map(Fraction, row)) for row in rows] + need(a and a[0] and all(len(r) == len(a[0]) for r in a), "matrix dimensions") + pivots = [] + for col in range(len(a[0])): + k = len(pivots) + choice = next((i for i in range(k, len(a)) if a[i][col]), None) + if choice is None: + continue + a[k], a[choice] = a[choice], a[k] + v = a[k][col] + a[k] = [x / v for x in a[k]] + for i in range(len(a)): + if i != k and a[i][col]: + v = a[i][col] + a[i] = [x - v * y for x, y in zip(a[i], a[k])] + pivots.append(col) + if len(pivots) == len(a): + break + return a, pivots + + +def rank(rows): + return len(rref(rows)[1]) + + +def nullspace(rows): + """Primitive integer vectors forming a basis of a rational kernel.""" + a, pivots = rref(rows) + result = [] + for j in range(len(a[0])): + if j in pivots: + continue + v = [Fraction(0) for _ in a[0]] + v[j] = 1 + for i, p in enumerate(pivots): + v[p] = -a[i][j] + multiple = lcm(*(x.denominator for x in v)) + integers = [int(x * multiple) for x in v] + divisor = gcd(*integers) + result.append([x // divisor for x in integers]) + return result + + +def dot(a, b): + return sum(x * y for x, y in zip(a, b)) + + +def determinant(rows): + """Fraction-free determinant with checked exact divisions.""" + a = [r[:] for r in rows] + n = len(a) + need(n and all(len(r) == n for r in a), "square determinant") + previous, sign = 1, 1 + for k in range(n - 1): + i = next((i for i in range(k, n) if a[i][k]), None) + if i is None: + return 0 + if i != k: + a[k], a[i] = a[i], a[k] + sign = -sign + pivot = a[k][k] + for i in range(k + 1, n): + for j in range(k + 1, n): + value, rem = divmod(a[i][j] * pivot - a[i][k] * a[k][j], previous) + need(rem == 0, "nonexact determinant division") + a[i][j] = value + a[i][k] = 0 + previous = pivot + return sign * a[-1][-1] + + +def certify_nonzero_minor(matrix, claimed): + actual = determinant(matrix) + need(actual != 0 and actual == claimed, "nonzero exact minor") + + +def act(columns, v): + answer = 0 + for i, column in enumerate(columns): + if v >> i & 1: + answer ^= column + return answer + + +def swap_axes(basis, stage, v): + """Simultaneous orthogonal swaps, evaluated on the original vector.""" + result = v + for i, b in enumerate(basis): + difference = b ^ (1 << (9 + 8 * (stage - 1) + i)) + if (v & difference).bit_count() % 2: + result ^= difference + return result + + +def load(): + sources = json.loads((HERE / "SOURCES.json").read_text()) + pins = {r["path"]: r["sha256"] for r in sources["files"] if r["usage"] == "input"} + need(set(pins) == {ARCHIVE, PACKET, + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json"}, "complete declared source set") + for path, expected in pins.items(): + need(sha256((ROOT / path).read_bytes()).hexdigest() == expected, "source hash: " + path) + with tarfile.open(ROOT / ARCHIVE) as archive: + members = [m for m in archive.getmembers() if m.name == DATA_MEMBER] + need(len(members) == 1 and members[0].isfile(), "unique data member") + raw = archive.extractfile(members[0]).read() + need(sha256(raw).hexdigest() == DATA_SHA, "data member hash") + data = json.loads(raw) + packet = json.loads(gzip.decompress((ROOT / PACKET).read_bytes())) + return packet, data, pins + + +def decision_tree_controls(): + """Enumerate every adaptive choice on finite, exact oracle problems.""" + inputs = tuple(range(16)) + queries = tuple(tuple((x >> i) & 1 for x in inputs) for i in range(4)) + queries += (tuple(x.bit_count() % 2 for x in inputs),) + target = tuple(((x & 1) ^ ((x >> 1) & 1), + ((x >> 2) & 1) ^ ((x >> 3) & 1)) for x in inputs) + + def solve(qs, labels): + @lru_cache(None) + def rec(cell): + if len({labels[x] for x in cell}) == 1: + return (0, Fraction(0)) + candidates = [] + for q in qs: + parts = defaultdict(list) + for x in cell: + parts[q[x]].append(x) + if len(parts) == 1: + continue + children = [(len(v), rec(tuple(v))) for v in parts.values()] + worst = 1 + max(cost[0] for _, cost in children) + mean = 1 + sum(Fraction(n, len(cell)) * cost[1] for n, cost in children) + candidates.append((worst, mean)) + need(candidates, "oracle cannot distinguish target") + return min(c[0] for c in candidates), min(c[1] for c in candidates) + result = rec(inputs) + return result, rec.cache_info().currsize + + exact, states = solve(queries, target) + need(exact == (3, Fraction(3)), "adaptive parity oracle optimum") + dense, _ = solve(queries + (target,), target) + need(dense == (1, Fraction(1)), "one dense vector query escapes scalar count") + nonlinear = tuple((x & 1) or ((x >> 1) & 1) for x in inputs) + nonlin, _ = solve(queries[:4], nonlinear) + need(nonlin == (2, Fraction(3, 2)), "nonlinear target permits early leaves") + cell = [x for x in inputs if queries[0][x] == queries[1][x] == 0] + need(len({target[x] for x in cell}) > 1, "false two-query decoder refuted") + return {"domain": "F2^4, five scalar linear queries", "states": states, + "optimal_worst_queries": exact[0], "optimal_mean_queries": str(exact[1]), + "dense_vector_query_optimum": dense[0], + "nonlinear_OR_mean_queries": str(nonlin[1])} + + +def build(): + packet, data, pins = load() + U, A = packet["U_ports"], packet["A_ports"] + need(len(U) == 96 and len(set(U)) == 96 and len(A) == 8, "port partition") + R = [[Fraction(row.get(str(p), "0")) for p in range(112)] for row in packet["R_rows"]] + need(len(R) == 8 and all(x.denominator == 1 for row in R for x in row), "integer R") + R = [[int(x) for x in row] for row in R] + RU = [[r[p] for p in U] for r in R] + RA = [[r[p] for p in A] for r in R] + need([[dot(x, y) for y in RU] for x in RU] == + [[48 * int(i == j) for j in range(8)] for i in range(8)], "ordinary Gram") + need([[dot(x, y) for y in RA] for x in RA] == + [[4 * int(i == j) for j in range(8)] for i in range(8)], "selected section") + basis = [recipe["idle_children"][0]["orthogonal_axes"][:8] for recipe in data["recipes"]] + need(len(basis) == 112 and [r["port"] for r in data["recipes"]] == list(range(112)), "chart order") + registry = {tuple(m["owner_right_matrix_columns"]) for m in packet["map_registry"].values()} + identity = tuple(1 << i for i in range(73)) + need(identity in registry, "identity registry entry") + routes = [] + for bs in basis: + need(all(0 < b < 512 for b in bs), "chart axes in first nine coordinates") + need([[(x & y).bit_count() % 2 for y in bs] for x in bs] == + [[int(i == j) for j in range(8)] for i in range(8)], "orthonormal chart") + port_routes = [] + for s in range(1, 9): + route = tuple(swap_axes(bs, s, v) for v in identity) + need(route in registry, "registered route") + need([act(route, b) for b in bs] == [1 << (9 + 8 * (s - 1) + i) for i in range(8)], "common axes") + port_routes.append(route) + routes.append(port_routes) + owners = [identity] + [routes[p][0] for p in range(16)] + E = [[R[k][p] * (act(owner, basis[p][0]) & 1) for p in U] + for owner in owners for k in range(8)] + need(all(any(act(owner, basis[p][0]) & 1 for owner in owners) for p in U), "nonzero coordinate functions") + groups = defaultdict(list) + for p in U: + groups[basis[p][0]].append(p) + group_ranks = {b: rank([[r[p] for p in ps] for r in R]) for b, ps in groups.items()} + C = groups[2] + S = [p for p in U if p not in C] + need(len(C) == 30 and len(S) == 66 and group_ranks[2] == 8, "30/66 decomposition") + need(all(group_ranks[b] == len(ps) for b, ps in groups.items() if b != 2), "outside groups independent") + need(sum(group_ranks.values()) == 74, "group upper bound") + + V = nullspace(RU) + need(len(V) == 88 and all(dot(r, v) == 0 for r in RU for v in V), "kernel basis") + EV = [[dot(row, v) for v in V] for row in E] + # A certificate directly on V; the predecessor instead certifies rank + # 74 on the full coefficient space. Both describe the same family. + row_ids = rref(list(map(list, zip(*EV))))[1] + col_ids = rref([EV[i] for i in row_ids])[1] + need(len(row_ids) == len(col_ids) == 66, "defect rank") + minor = [[EV[i][j] for j in col_ids] for i in row_ids] + det = determinant(minor) + certify_nonzero_minor(minor, det) + + RC = [[r[p] for p in C] for r in R] + K = nullspace(RC) + need(len(K) == 22 and all(dot(r, v) == 0 for r in RC for v in K), "invisible kernel") + # Exactly one coordinate of C vanishes on ker(H). Classify optimal + # leaves instead of presuming that the original attaining set is unique. + nuisance = [] + coloops = [] + for j, p in enumerate(C): + v = next((v for v in K if v[j]), None) + deletion_rank = rank([[x for i, x in enumerate(row) if i != j] for row in RC]) + if v is None: + need(deletion_rank == 7, "coloop deletion rank") + coloops.append(p) + else: + need(deletion_rank == 8, "non-coloop deletion rank") + nuisance.append({"port": p, "kernel_vector": v, "coordinate_value": v[j]}) + need(coloops == [77] and len(nuisance) == 29, "exact nuisance/coloop classification") + duals = nullspace([[R[k][p] for k in range(8)] for p in C if p != 77]) + need(len(duals) == 1, "one-dimensional dual space") + w = duals[0] + beta = dot(w, [r[77] for r in R]) + need(beta != 0, "coloop dual normalization") + alpha = {p: Fraction(dot(w, [r[p] for r in R]), beta) for p in S} + eligible = sorted(S + [77]) + relation = {p: alpha.get(p, Fraction(1)) for p in eligible} + need(all(v[U.index(77)] + sum(alpha[p] * v[U.index(p)] for p in S) == 0 for v in V), + "coordinate relation on V") + optimal_omissions = [p for p in eligible if relation[p] != 0] + need(len(optimal_omissions) == 45, "45 candidate optimal sets") + candidate_ranks = [] + for omitted_port in eligible: + read = [p for p in eligible if p != omitted_port] + QV = [[v[U.index(p)] for v in V] for p in read] + actual_rank = rank(QV) + remaining = [p for p in U if p not in read] + restriction_rank = 66 + rank([[r[p] for p in remaining] for r in R]) - 8 + need(actual_rank == restriction_rank, "independent coordinate restriction rank") + need(actual_rank == (66 if omitted_port in optimal_omissions else 65), "optimal-set classification") + candidate_ranks.append({"omitted_port": omitted_port, "rank": actual_rank}) + if omitted_port != 77 and omitted_port in optimal_omissions: + for v in V: + recovered = (-v[U.index(77)] - sum(alpha[p] * v[U.index(p)] + for p in S if p != omitted_port)) / alpha[omitted_port] + need(recovered == v[U.index(omitted_port)], "exchange decoder") + # Explicit all-owner decoder: sum_{p in S} r_p c_p (f_bp - f_2). + reconstructed = [[R[k][p] * ((act(owner, basis[p][0]) & 1) - (act(owner, 2) & 1)) + if p in S else 0 for p in U] + for owner in owners for k in range(8)] + need(all(dot(e, v) == dot(d, v) for e, d in zip(E, reconstructed) for v in V), + "attaining decoder on complete kernel basis") + # The all-owner identity follows formally from grouping by the first + # axis and R_U c=0; no independence of arbitrary bit functions is used. + for i, owner in enumerate(owners): + for k in range(8): + need([x - y for x, y in zip(E[8*i+k], reconstructed[8*i+k])] == + [(act(owner, 2) & 1) * x for x in RU[k]], "decoder difference factors through R_U") + + rejected = [] + def reject(label, f): + try: + f() + except ValueError: + rejected.append(label) + else: + raise ValueError("control accepted: " + label) + bad = [r[:] for r in minor] + bad[-1] = bad[0][:] + reject("singular defect minor", lambda: certify_nonzero_minor(bad, det)) + reject("wrong determinant", lambda: certify_nonzero_minor(minor, det + 1)) + reject("identity owner substituted for whole array", lambda: need(rank(E[:8]) == 66, "owner rank")) + reject("identity substituted as stage-one route", lambda: need(act(identity, basis[1][0]) == 1 << 9, "route")) + omitted = [r[:] for r in reconstructed] + q = U.index(S[0]) + for row in omitted: + row[q] = 0 + reject("one attaining port omitted", lambda: need(all(dot(e, v) == dot(d, v) + for e, d in zip(E, omitted) for v in V), "65-port decoder")) + wrong_sign = [[R[k][p] * ((act(owner, basis[p][0]) & 1) + (act(owner, 2) & 1)) + if p in S else 0 for p in U] for owner in owners for k in range(8)] + reject("wrong f2 decoder sign", lambda: need(all(dot(e, v) == dot(d, v) + for e, d in zip(E, wrong_sign) for v in V), "decoder sign")) + reject("65 scalar queries claimed enough", lambda: need(65 >= len(row_ids), "rank budget")) + reject("C coordinate declared constant on invisible kernel", lambda: need(all(v[0] == 0 for v in K), "nuisance")) + reject("unique optimal set claimed", lambda: need(len(optimal_omissions) == 1, "45 optimal sets")) + zero_relation_port = next(p for p in eligible if relation[p] == 0) + reject("zero relation coefficient used for exchange", lambda: need( + next(row["rank"] for row in candidate_ranks if row["omitted_port"] == zero_relation_port) == 66, + "singular exchanged read set")) + reject("JSON Boolean substituted for integer", lambda: need(canonical({"rank": True}) == canonical({"rank": 1}), "type")) + toy = decision_tree_controls() + return {"schema": "qq16-adaptive-coordinate-reads-v1", "status": "PASS_QQ16_ADAPTIVE_READS", + "source_hashes": pins, "data_member_sha256": DATA_SHA, + "ordinary_dimension": 96, "V_dimension": 88, "H_on_V_rank": 66, + "H_kernel_dimension": 22, "axis_groups": len(groups), + "registered_nonzero_routes": 896, "owner_evaluations": 17, + "V_basis_sha256": digest(V), + "defect_minor": {"rows": row_ids, "basis_columns": col_ids, + "determinant": str(det), "matrix": minor}, + "original_attaining_read_set": S, "unread_axis2_group": C, + "eligible_optimal_ports": eligible, "optimal_omissions": optimal_omissions, + "optimal_read_set_count": len(optimal_omissions), "candidate_read_ranks": candidate_ranks, + "coloop_ports": coloops, "dual_vector": w, "dual_normalizer": beta, + "coordinate_relation": {str(p): str(a) for p, a in relation.items()}, + "nuisance_witnesses": nuisance, + "decoder_basis_equalities": len(V) * len(E), + "adaptive_tree_control": toy, "rejecting_controls": rejected, + "claim": "Exact side-effect-free coordinate-oracle recovery on the credited rational family; not full controller recovery or a physical cost."} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--emit", type=Path, help="Create a new deterministic receipt exclusively") + args = parser.parse_args() + result = build() + if args.emit: + with args.emit.open("x") as f: + json.dump(result, f, indent=2, sort_keys=True) + f.write("\n") + else: + expected = json.loads((HERE / "RESULT.json").read_text()) + need(canonical(result) == canonical(expected), "complete receipt equality") + print("PASS_QQ16_ADAPTIVE_READS defect=66 optimum=66 optimal_sets=45 " + "nuisance_coordinates=29 controls=" + str(len(result["rejecting_controls"])) + " no_new_kappa") + + +if __name__ == "__main__": + main()