From 97e7cd1f64fe8e1acc462965dc2878cdef2274a2 Mon Sep 17 00:00:00 2001 From: Jason Date: Thu, 15 Oct 2026 00:08:42 -0600 Subject: [PATCH 1/3] Prove a QQ16 transcript floor after invertible selected shears Add an ordered invisible-family argument, exact source-moment replay, retained-tail check, and normal/optimized failure controls. Scope is the stated logical observation interface, not native supplier admission or a new kappa. Prepared for Jason (@jgilfoil) with substantial OpenAI Codex assistance in derivation, implementation, verification, writing, and separate agent review. Credit all pinned predecessor work in the package. --- research/qq16-shear-transcript-floor/PROOF.md | 311 ++++++++ .../qq16-shear-transcript-floor/README.md | 193 +++++ .../qq16-shear-transcript-floor/RESULT.json | 747 ++++++++++++++++++ .../qq16-shear-transcript-floor/SOURCES.json | 102 +++ .../qq16-shear-transcript-floor/TASK.json | 161 ++++ .../qq16-shear-transcript-floor/VERIFY.json | 55 ++ .../qq16-shear-transcript-floor/algebra.py | 281 +++++++ .../source_moments.py | 371 +++++++++ research/qq16-shear-transcript-floor/tail.py | 226 ++++++ .../test_verify.py | 85 ++ .../qq16-shear-transcript-floor/verify.py | 154 ++++ 11 files changed, 2686 insertions(+) create mode 100644 research/qq16-shear-transcript-floor/PROOF.md create mode 100644 research/qq16-shear-transcript-floor/README.md create mode 100644 research/qq16-shear-transcript-floor/RESULT.json create mode 100644 research/qq16-shear-transcript-floor/SOURCES.json create mode 100644 research/qq16-shear-transcript-floor/TASK.json create mode 100644 research/qq16-shear-transcript-floor/VERIFY.json create mode 100644 research/qq16-shear-transcript-floor/algebra.py create mode 100644 research/qq16-shear-transcript-floor/source_moments.py create mode 100644 research/qq16-shear-transcript-floor/tail.py create mode 100644 research/qq16-shear-transcript-floor/test_verify.py create mode 100644 research/qq16-shear-transcript-floor/verify.py diff --git a/research/qq16-shear-transcript-floor/PROOF.md b/research/qq16-shear-transcript-floor/PROOF.md new file mode 100644 index 0000000000..0b22f2cd81 --- /dev/null +++ b/research/qq16-shear-transcript-floor/PROOF.md @@ -0,0 +1,311 @@ +# An observation floor after an invertible selected shear + +This is a rational information obstruction for the specified modified QQ16 +interface. It grants all operations and observations in its contract zero cost. +It is not a native-word lower bound, an exclusion of all changed first pairs, +or a multiplication theorem. + +## Contract and notation + +Fix the actual conserved F0 and B1 maps in +`research/joint-query/evidence/JOINT-QUERY-TRANSFER.md`, the actual selected +minors A and T, and the retained ordinary schedule. Work on fields constant +in every tensor payload coordinate, with arbitrary dependence on the finite +owner group. Let N be the number of owners. A centre-query array therefore +has dimension 8N over the rationals. All maps below act on complete owner +arrays; their factors need not commute. + +Write `B_s = R_s iota_U`, `A_s = ell_(s,A)`, `T_s = ell_(s,T)`, and use +`P_(s,A)` and `P_(s,T)` for their two-sided selected sections. Here A_s and +T_s are restricted to their named selected coordinate spaces. Let + +```text +C = [B0; B1; B2], r = rank_Q(C). +``` + +Between complete F0 and B1, allow a fixed invertible linear map Q from the +raw A array to the raw T array, acting by the paired shear + +```text +X_T += Q X_A; +Y_T -= Q X_A. +``` + +This includes pairing the displayed A/T lists in their displayed order. +No ordinary field is changed. Also allow an added linear transcript of +rank at most d, retained through the endpoint. It may read ordinary fields +at the cut, including dense old-chart queries, and it may drive additional +paired selected updates. The latter must vanish when that entire transcript +is zero. In particular a retained eight-coordinate dense B0 read may be +injected into T with opposite signs on X and Y. The transcript includes +every additional independent retained record or source read allowed to +drive those updates. It cannot include a free, uncounted copy of a +transient selected cut. The input-dependent boundary action, including the +transcript, is linear; fixed parameters are allowed. The transcript is not +allowed to modify F0, B1, or the ordinary schedule. + +Grant the decoder all selected fields immediately after B1, all final +selected fields, all completed-X descendants, all five forward histories, +and the transcript. Subsequent homogeneous selected-only linear controls +are allowed, including controls using that transcript. Arbitrary new +ordinary reads later in the schedule are outside this contract. + +The theorem concerns recovering the original individual selected inputs, +not merely their conserved pair sums. None of those input registers is +assumed initialized. The zero-sum inputs used below form a permitted +subspace of differences between arbitrary inputs. + +## Ordered invisible family + +For an arbitrary ordinary array h define + +```text +K = -(1/11) Q^(-1) P_(1,T) B1, +k = K h, +G = 11 B2 + (A_2 Q^(-1) + T_2) P_(1,T) B1. +``` + +The factors are in execution order from right to left. In particular +`Q^(-1) P_(1,T)` must not be replaced by `P_(1,T) Q^(-1)`. The rational +factor 1/11 is used to describe a witness, not to claim a legal primitive. +One may clear all denominators to obtain integer representatives in this +finite-dimensional rational model. + +Initialize other pairs to zero and pair 0 to + +```text +X_U = h, Y_U = 0, +X_A = -P_(0,A) B0 h - k, Y_A = -X_A, +X_T = P_(0,T) A_0 k, Y_T = -X_T. +``` + +The original selected pair sums and the F0 query are zero, since + +```text +f0 = B0 h + A_0(-P_(0,A) B0 h-k) + T_0 P_(0,T) A_0 k = 0. +``` + +The conserved F0 map therefore gives + +```text +X_U = Y_U = h, +X_A = k, Y_A = -k, +X_T = Y_T = 0. +``` + +Restrict the added transcript to this family. It is a linear map `Lh` +whose rank is at most d, even when the original transcript reads selected +fields as well as ordinary fields. Restriction and substitution cannot +increase rank. On `ker L`, transcript-driven paired updates vanish and +the only boundary change is the fixed shear, so + +```text +X_T = Qk = -(1/11) P_(1,T) B1 h, +Y_T = -Qk. +``` + +At B1 its future query and old target driver are + +```text +q2 = B2 h - A_2 k - T_2 Qk = (1/11) G h, +a1 = T_1 Qk = -(1/11) B1 h. +``` + +If `Gh=0`, the future logger sets its A output to zero. Its current +query is then + +```text +b1 = B1 h - T_1 Qk = B1 h - a1 = (12/11) B1 h. +``` + +Consequently `b1+12a1=0`. The conserved B1 target T output is zero; +its source T output is also zero, since the T pair sum is zero. Both A +outputs are zero for the same reason. The complete first-pair output is + +```text +X = 0, +Y_A = Y_T = 0, +Y_U = g = h -(1/11) K_(1,U) B1 h. +``` + +Thus every `h in ker G intersect ker L` gives zero post-B1 selected +observations and zero retained transcript. This is an ordered identity on +the actual map spaces, not an assumption of scalar or commuting charts. + +The residual map does not discard h. Put `Z=K_(1,U) B1`; the actual +response identity `B1 K_(1,U)=12I` gives `Z^2=12Z`. Hence +`(I-Z/11)(I-Z)=(I-Z)(I-Z/11)=I`. In particular the map sending h to g +is invertible, with inverse `I-K_(1,U) B1`. This observation uses only +products of the same operator Z and commutes no different chart factors. + +## Why the complete retained tail remains invisible + +The original selected-witness tail applies to every ordinary residue g +in the displayed first-pair state. It does not require `B1 g=0`, `B2 g=0`, +or any condition on a later query of g. + +The first positive bridge places `-g` in pair 1's Y ordinary bank, while +pair 0 retains `g`. F2 acts on pair 0 with its entire X source zero, so +its history is zero and it leaves that state unchanged. The subsequent +negative bridge cancels `-g` before B3. Every later active local pair is +zero. The remaining bridges leave g only in pair 0's Y ordinary bank. +At the terminal exchange it becomes named final X0 with the former-Y +native type. It is not a completed-X descendant. All completed-X +descendants, final selected fields, and all five histories are zero. +The selected cuts after B1 and any later homogeneous selected-only +controls also remain zero. The package's source-bound schedule check +tests the required pair binding and the canceling bridge. + +There is no claim that the transient F0 A array k is zero. Giving its +complete value to the decoder for free would change the observation +contract and invalidate the stated observation count. It can instead be +included in the charged transcript. + +## Rank of the lost original selected data + +Let S map h to the original pair-0 X_A and X_T in this family. Since the +selected sections and Q are invertible, + +```text +S h = 0 iff B0 h = 0 and B1 h = 0. +``` + +Moreover, G together with B0 and B1 determines B2, by subtracting the +displayed ordered multiple of B1 and dividing by 11. It follows that + +```text +ker [G;S] = ker [B0;B1;B2], rank [G;S] = r. +``` + +For any finite-dimensional linear maps O and S, + +```text +dim S(ker O) = rank [O;S] - rank O. +``` + +Apply this with `O=[G;L]`. Appending L cannot decrease the combined +rank, while `rank [G;L] <= 8N+d`. Therefore + +```text +dim S(ker G intersect ker L) >= r - 8N - d. (1) +``` + +Every vector counted in (1) has exactly the same allowed observations +as zero, including the full retained tail. Thus a positive right-hand +side rules out every decoder, linear or otherwise, on arbitrary inputs. +The assertion is about the dimension of different required original +selected values, not merely the dimension of irrelevant ordinary inputs. +The same linear kernel also gives indistinguishable pairs about any +background input for the stated linear interface. + +## Applying the separately checked actual-source rank bound + +The following fourth-moment argument and numerical certificate are reused, +with credit, from [commdata2338's PR #2189](https://github.com/CrocSwap/integer-mult-bounds/pull/2189). +That predecessor applies its capacity bound to the unsheared first pair. +The changed-shear implication above is the contribution here. + +Here is the complete spectral implication of the finite source checks. +Let `E_s = B_s* B_s/48` and `H = E_0+E_1+E_2`, where * denotes real +transpose together with inverse owner route. The ordinary Gram identity +`B_s B_s*=48I` makes each E_s an orthogonal projection of rank 8N. +Moreover `H=C*C/48`, so `rank H=rank C=r`. All matrices are rational; +their real and rational ranks agree. + +For completeness, the finite contractions behind the moments are as +follows. Every source column r_p has squared norm four and their outer +products sum to `48 I_8`. Thus +`sum_(p,q)(r_p^T r_q)^2=18432`, with diagonal contribution 1536. +For different stages, the checked relative-route product table has only +the 96 diagonal pairs at the identity and has singleton nonidentity +fibres. Its matrix coefficient at the identity is `192 I_8`. +The two product tables with a common first stage intersect only there. +Under the regular owner action, a route has trace N at the identity and +zero otherwise. These finite facts give the following reduced cyclic +projection-word traces, all divided by N: + +```text +tr E_s = 8, +tr E_s E_t = 2/3, +tr E_s E_t E_u (s,t,u distinct) = 1/18, +tr E_s E_t E_s E_t (s != t) = 23/216, +tr E_s E_t E_s E_u (s,t,u distinct) = 1/18. +``` + +In particular the alternating fourth trace is +`[8*192^2+16*(18432-1536)]/48^4=23/216`, and the mixed fourth +trace is `8*192^2/48^4=1/18`. In the distinct-stage triple the checked +route intersections force its three port indices to coincide, giving +`96*4^3/48^3=1/18`. Cyclic removal of adjacent repeated projections +classifies the fourth-power expansion into respectively +`3,36,24,6,12` words of the five displayed kinds. The lower powers are +expanded in the same way. Consequently the exact source certificate +gives + +```text +(tr H, tr H^2, tr H^3, tr H^4)/N = (24,28,109/3,1823/36). +``` + +Use the rational polynomial + +```text +p(t) = 1-(1-81t/40+9t^2/10)^2 + = (81/20)t-(9441/1600)t^2+(729/200)t^3-(81/100)t^4. +``` + +It satisfies `p(0)=0` and `p(t)<=1` for every real t. By the real +spectral theorem, zero eigenvalues of H contribute zero to `tr p(H)` +and each nonzero eigenvalue contributes at most one. The exact moment +substitution therefore proves + +```text +r = rank H >= tr p(H) = (117/5) N. +``` + +Substitution in (1) gives a lost selected-data dimension of at least +`(77/5)N-d`. In particular: + +- A single eight-coordinate ordinary query has `d <= 8N` and leaves + at least `(37/5)N` lost selected dimensions, even when its record also + drives paired selected updates. +- Any transcript of at most fifteen scalar owner arrays has + `d <= 15N` and leaves at least `(2/5)N` lost selected dimensions. + Hence at least sixteen scalar owner arrays are necessary in this + interface. Sixteen are not proved sufficient. + +For orientation, the weaker source bound `r >= (144/7)N` would already +exclude the eight-coordinate query, with defect at least `(32/7)N`. +The fourth-moment source bound is needed for the stated sixteen-array +floor. An owner-array count is not a recursive rank, native-call count, +or completed supplier bill. + +## Verification boundary + +`algebra.py` verifies the ordered family in two independent finite +rational matrix models with noncommuting selected sections and shears. +It separately constructs the complete first-pair observation matrix on +all arbitrary input coordinates and checks its kernel and selected-data +defect. These are regression fixtures for the ordered proof; they are +not substitutes for binding the actual QQ16 source rank and tail. The +package verifier handles those actual-source obligations separately. + +`tail.py` independently replays the 17 events following B1 on a formal +arbitrary ordinary residue g, checks the exact trajectory against the +retained QQ16 witness, and binds the nine local pair indices to the +literal `expected_pairs` assertion in the inherited replica-prefix +auditor. It reads that assertion as syntax; it does not execute that +auditor or replay its compressed parent template. The final former-Y +classification is inherited explicitly from the QQ16 witness, rather +than established by a fresh native field-type check. Removing the first +negative bridge makes B3's source nonzero. Assigning F2 to pair 1 is a +source-binding rejection: both candidate X sources are zero on this +particular family, so that mutation alone would not change its ordinary +trajectory. Counting the final former-Y hole as completed-X is separately +rejected. + +The local maps, selected sections, and retained tail are credited to +Ali Romman's QQ16 package. The triple-query moment/rank input is +credited to its pinned predecessors. This proof's contribution is the +changed-shear invisible family and the resulting transcript floor, +including dense reads used for paired selected updates. It does not +claim native implementability, a favorable cost, or a changed frontier. diff --git a/research/qq16-shear-transcript-floor/README.md b/research/qq16-shear-transcript-floor/README.md new file mode 100644 index 0000000000..3c531df0bd --- /dev/null +++ b/research/qq16-shear-transcript-floor/README.md @@ -0,0 +1,193 @@ +# A QQ16 shear does not remove the transcript floor + +**Scoped obstruction; no new supplier or multiplication exponent.** +Adding the proposed invertible A-to-T shear between QQ16's F0 and B1 +does not make one dense old-chart query sufficient. Even granting the +shear, observations and all implementation costs for free, an additional +eight-coordinate query leaves at least `ceil(37|G|/5)` dimensions of +original joint A/T input invisible under the contract below. + +More generally, **at least sixteen rational-linear scalar owner arrays +remain necessary** after any fixed invertible paired shear in this class. +Each such array has one scalar per owner. Fifteen leave at least +`ceil(2|G|/5)` hidden dimensions. For an unrestricted nonuniform record, +the necessary total rank is `ceil(77|G|/5)`, not `16|G|`. Sixteen arrays +is a necessary floor, not a sufficiency or cost claim. + +The new result is the ordered shear-kernel construction and its full-tail +implication. The fourth-moment rank certificate is credited to +[commdata2338's PR #2189](https://github.com/CrocSwap/integer-mult-bounds/pull/2189), +which treated the unsheared first pair. Its finite premises are recalculated +here by a separately implemented, exact text-source checker. The proof is +in [PROOF.md](PROOF.md); [TASK.json](TASK.json) records the precise refinement +of priority-revision-4 card `joint-query-controller`. + +## Exact contract + +Keep the retained QQ16 local maps and ordinary bank schedule. At the +complete F0/B1 boundary, apply + +```text +X_T += Q X_A +Y_T -= Q X_A +``` + +where Q is a fixed invertible rational operator from the selected A fields +to T fields on the payload-constant regular-cover subspace. This includes +the displayed-order raw pairing proposed in +[PR #2216](https://github.com/CrocSwap/integer-mult-bounds/pull/2216). +Ordinary fields stay unchanged. Permit an extra rational-linear record of +total rank at most d; a dense `B0 X_U` query has at most `8|G|` coordinates. +Additional paired taps driven only by this record and vanishing when the +record is zero are also harmless to the counterexample. + +Grant selected values **after the complete sheared F0/B1 pair**, all later +selected cuts and selected-only homogeneous controls, all five forward +query histories, and all completed-X descendants. The former-Y final hole +is excluded, exactly as in the retained witness. + +The transient post-F0 A value is generally nonzero. Saving it, or another +pre-B1/within-B1 selected value, is additional information whose rank must +be counted in d. Unlike PR #2326's coordinate-tap witness, this theorem +does not grant all pre-B1 selected cuts for free. The bound concerns the +**joint original A/T input**, not the A input alone. + +## Result and evidence + +Writing `r = rank[B0; B1; B2]` and `N = |G|`, the ordered construction gives + +```text +hidden joint selected-input dimension >= r - 8N - d. +r >= (117/5)N. +``` + +It leaves zero selected state and zero ordinary X after B1, with an +ordinary Y residue `g = (I - K_(1,U) B1/11) h`. The retained tail carries +g only to the former-Y hole. This residue map is invertible, with inverse +`I - K_(1,U) B1`; it is not a discarded zero-input construction. + +Verification covers: + +- The native root order, selected minors and ordinary Gram `48 I`, + reconstructed from exact main-branch source files. +- All 336 stage-0/1/2 owner routes on 73 binary axes, including the 48 + fixed spectator axes; all six tables of 9,216 ordered relative-route + products and their required intersections. +- The exact moments `24, 28, 109/3, 1823/36` and the rational polynomial + rank certificate, without floating-point acceptance. +- The ordered changed-pair algebra, full retained tail and rational + model checks, including deliberately incorrect alternatives. +- Source and receipt integrity in normal and optimized Python execution. + +Local validation passed on Linux x86_64, CPython 3.12.3: registered normal +and optimized replay, all 18 mathematical/schedule failure controls, +and five integration tests (including Git-free read-only relocation, +source drift, receipt type corruption and overwrite refusal). These are +author/agent checks, not hosted CI or independent human review. + +The universal statement rests on the written ordered argument and rank +inequality. Small matrix fixtures corroborate the algebra; they do not +stand in for the full regular cover or an all-size supplier proof. + +## Reproduce + +Python 3.12 and the standard library, from the repository root: + +```sh +python3 -I -B scripts/research_package.py --package research/qq16-shear-transcript-floor --check-only +python3 -I -B scripts/research_package.py --package research/qq16-shear-transcript-floor +``` + +The direct checker also works in a source export containing the pinned +input files: + +```sh +python3 -I -O -B research/qq16-shear-transcript-floor/verify.py +``` + +Replay is read-only and compares every deterministic field of +[RESULT.json](RESULT.json). `--emit-result NEW_PATH` explicitly creates a +new receipt and refuses to overwrite an existing file. Exact upstream +commit, Git blob and SHA256 pins are in [SOURCES.json](SOURCES.json). +The catalogue and selected-result record are historical provenance; +the declared mathematical inputs are checked as live source bytes. + +## Source boundary and limitations + +Scientific base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`, priority revision 4. +The prototype, native phases, centre constructor and port transport are +individually bound to the selected source manifest. R is reconstructed +from root-coordinate totals and the literal `tau=43` port permutation. +Owner maps are reconstructed from the orthonormal-chart definition in +main's native verifier. The payload-constant restriction retains arbitrary +independent cover-owner values; it is not a cover-invariant approximation. + +The tail uses the retained QQ16 witness's bridge trajectory and the pair +sequence recorded in Brody Arbon's main-branch replica-prefix audit. It +checks this logical schedule, not the compressed parent template itself. +The compressed QQ16 packet, its map registry, the complete scalar words, +native field types and the full supplier are **not replayed**. Their +identification with these source definitions and the retained logical +interface remains inherited. The prescribed selected-baseline command +was attempted but could not verify the complete selected package inventory +in this bounded text export. No baseline pass is claimed. The new scoped +checker does not weaken or replace that baseline check. + +This excludes only the stated shear, record and observation model. +Ordinary-state changes, a different local pair, nonlinear encoders, +uncounted independent payload storage and access to the former-Y hole +are outside it. No native rank tariff, favourable moment invoice, +supplier adoption, new kappa, proof-assistant result or independent human +review is claimed. The existing selected frontier remains unchanged. + +## Overlap and credit + +- Ali Romman / PR #1969: conserved QQ16 maps, cover action, native words + and original selected-output witness. +- Adam Gall / PR #2093 and CubeJerry / PR #2306: the nonzero-chart and + selected-only obstructions. Cinna Davis / PR #2216 and PR #2268: + the shear and coordinate-tap witness repairs. +- commdata2338 / PR #2326: the full-input coordinate-tap obstruction and + explicit dense-observation handoff taken here. That result also grants + earlier selected cuts; the distinction above is essential. +- commdata2338 / PR #2189, Nick Petalas / PR #2181, Ross Richardson / + PR #2104 and commdata2338 / PR #2153: trace-moment and transcript + capacity methods. The fourth moment and polynomial are reused with + credit, not presented as a new numerical discovery. +- commdata2338 / PR #2174: two-query recovery with a recorded first-pair + cut. Charles Bethin / PR #2252 and commdata2338 / PR #2328: separate + native-frame and shear-tariff results. +- Brody Arbon's `replica-prefix-audit`: the retained complex parent + stage-to-pair sequence used to bind the logical tail. +- The source construction and transport retain icekylinx, + DreamingOfClouds, Chafik Boukhalfa, Jeremy Kothe, Rohan Arun, Hao Yan, + Zhihao Chen and the remaining lineage in the unchanged + [QQ16 notice](../joint-query/NOTICE.md). + +Prepared for Jason (@jgilfoil) with substantial OpenAI Codex assistance +in derivation, implementation, checking and writing. A separate agent +reviewed the ordered proof; this is not independent human review. +New material is Apache-2.0. No predecessor executable is imported or +vendored. Live PR overlap was checked with complete pagination; Discussion +coverage and publication limitations are recorded honestly in TASK.json. + +The final overlap refresh found concurrent +[PR #2346](https://github.com/CrocSwap/integer-mult-bounds/pull/2346), which +rules out one specified set of 64 initial query coordinates without a +pre-F2 selected intervention. It grants final selected values but not a +free B1 cut. Its family and observation contract differ from this changed +shear result; neither result supersedes the other. + +## Open next questions + +1. **Which changed first pair evades this kernel?** Specify one ordinary + update or local-map change and test the entire observation kernel on + dirty inputs. This matters because pricing the excluded repair cannot + close its information gap. The retained map/schedule is the blocker. +2. **Can sufficient records survive to the final cut at favourable cost?** + Start with PR #2174's two-query recovery and trace how its B1 cut + values become accessible final records. PR #2346 excludes replacing + that cut by its specified 64 initial queries without pre-F2 intervention; + a different retention mechanism is needed. Native frames, storage, + restoration, hosting, tape and precision must all be charged. The + information floor alone establishes none of these obligations. diff --git a/research/qq16-shear-transcript-floor/RESULT.json b/research/qq16-shear-transcript-floor/RESULT.json new file mode 100644 index 0000000000..0118c81066 --- /dev/null +++ b/research/qq16-shear-transcript-floor/RESULT.json @@ -0,0 +1,747 @@ +{ + "arithmetic": "exact integers and fractions; no assertion-dependent acceptance", + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "ordered_algebra_fixtures": { + "models": [ + { + "centre_dimension": 2, + "family_basis_vectors": 2, + "full_input_dimension": 20, + "full_input_kernel_dimension": 2, + "lost_selected_dimension": 2, + "observation_rank": 18, + "ordinary_dimension": 6, + "rejecting_controls": [ + "wrong shear sign", + "wrong noncommuting order", + "eleven replaced by twelve", + "omitted retained record", + "free transient F0 A record" + ], + "residue_nonzero_entries": [ + 2, + 2 + ], + "transcript_rank": 2, + "triple_query_rank": 6 + }, + { + "centre_dimension": 3, + "family_basis_vectors": 3, + "full_input_dimension": 30, + "full_input_kernel_dimension": 3, + "lost_selected_dimension": 3, + "observation_rank": 27, + "ordinary_dimension": 9, + "rejecting_controls": [ + "wrong shear sign", + "wrong noncommuting order", + "eleven replaced by twelve", + "omitted retained record", + "free transient F0 A record" + ], + "residue_nonzero_entries": [ + 2, + 3, + 4 + ], + "transcript_rank": 3, + "triple_query_rank": 9 + } + ], + "status": "PASS_ORDERED_SHEAR_ALGEBRA" + }, + "package_sha256": { + "PROOF.md": "d2faaf7a41ab41e8b5735b50b686431294a0c8ebca2ae9424d034a6c76fa479c", + "SOURCES.json": "8a0bd0537d5e2976452b5013db402fdb217dcec68d67ff64d801fd5e1e12d87d", + "algebra.py": "262a5d7f554a13c993e07886693dfa22641e64e59738536125e809cfcc050bda", + "source_moments.py": "21525b2ceee38ae1f073dc2e6dc74f8b2e8da2cc76202d107f601c3f109c21a6", + "tail.py": "33a033341bf55e6fe3d08d83e620a25f16778e954810198ed6ac0f85fab031d4", + "test_verify.py": "2ede49f07593104acafadf1027e6f53f22993d27368e0503fc5fa5b3d654c9a8", + "verify.py": "1dd8cfbd5bcbca97a51deaf32fe02f3692eb42696d0d6b568618135b23ea3d68" + }, + "rank_consequences": { + "fifteen_coordinate_record_deficit_per_owner_at_least": "2/5", + "integer_rounding": "ceil(77*N/5)-d for total record rank d", + "joint_selected_deficit_before_counted_record_per_owner_at_least": "77/5", + "necessary_uniform_scalar_records_per_owner": 16, + "one_eight_coordinate_record_deficit_per_owner_at_least": "37/5", + "sufficiency": "NOT CLAIMED", + "triple_query_rank_per_owner_at_least": "117/5" + }, + "retained_tail": { + "arbitrary_residue": "formal free ordinary vector g", + "checks": { + "completed_X_coefficients": [ + 0, + 0, + 0, + 0 + ], + "final_coefficients": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "final_type_classification": [ + [ + "former_Y_hole", + "completed_X_descendant" + ], + [ + "former_Y_hole", + "completed_X_descendant" + ], + [ + "former_Y_hole", + "completed_X_descendant" + ], + [ + "former_Y_hole", + "completed_X_descendant" + ] + ], + "forward_histories": { + "0": 0, + "2": 0, + "4": 0, + "6": 0, + "8": 0 + }, + "local_zero_source_checks": [ + { + "orientation": "forward", + "pair": 0, + "source_coefficient": 0, + "stage": 2 + }, + { + "orientation": "backward", + "pair": 1, + "source_coefficient": 0, + "stage": 3 + }, + { + "orientation": "forward", + "pair": 1, + "source_coefficient": 0, + "stage": 4 + }, + { + "orientation": "backward", + "pair": 2, + "source_coefficient": 0, + "stage": 5 + }, + { + "orientation": "forward", + "pair": 2, + "source_coefficient": 0, + "stage": 6 + }, + { + "orientation": "backward", + "pair": 3, + "source_coefficient": 0, + "stage": 7 + }, + { + "orientation": "forward", + "pair": 3, + "source_coefficient": 0, + "stage": 8 + } + ], + "trajectory_after_B1": [ + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0 + ], + "stage": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 5 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 3 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 6 + }, + { + "coefficient": -1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 3 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 7 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 8 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 0 + }, + { + "kind": "terminal", + "ordinary": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + ], + "zero_selected_cuts_from_B1": 18 + }, + "logical_event_count": 19, + "post_B1_event_count": 17, + "recipe": [ + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 0 + }, + { + "kind": "local", + "pair": 0, + "reverse": true, + "stage": 1 + }, + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 1, + "reverse": true, + "stage": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 1, + "reverse": false, + "stage": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 2, + "reverse": true, + "stage": 5 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "kind": "local", + "pair": 2, + "reverse": false, + "stage": 6 + }, + { + "coefficient": -1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "kind": "local", + "pair": 3, + "reverse": true, + "stage": 7 + }, + { + "kind": "local", + "pair": 3, + "reverse": false, + "stage": 8 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "src": 2 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 0 + }, + { + "kind": "terminal" + } + ], + "rejecting_controls": [ + { + "mutation": "omit the first canceling negative bridge", + "rejected_by": "local source must vanish at stage 3" + }, + { + "mutation": "bind F2 to pair 1", + "rejected_by": "local stage/pair/orientation binding" + }, + { + "mutation": "classify the former-Y hole as completed-X", + "rejected_by": "former-Y hole cannot be counted as completed-X" + } + ], + "source_boundary": { + "complete_native_word_or_type_validation": false, + "compressed_parent_template_replayed": false, + "event_projection": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json", + "native_endpoint_interpretation": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "pair_vector_assertion": "research/replica-prefix-audit/verify.py:schedule_audit.expected_pairs" + }, + "stage_pairs": [ + 0, + 0, + 0, + 1, + 1, + 2, + 2, + 3, + 3 + ], + "status": "PASS_RETAINED_QQ16_TAIL" + }, + "schema_version": 1, + "scope": "Written conditional regular-cover proof plus finite source and algebra checks; no complete native packet, supplier, tariff or kappa claim", + "source_moments": { + "active_axes": 25, + "controls": [ + { + "mutation": "corrupt one root coordinate", + "rejected_by": "root norm four" + }, + { + "mutation": "duplicate a norm-four root with different outer product", + "rejected_by": "full Gram 56I" + }, + { + "mutation": "corrupt one route matrix entry", + "rejected_by": "orthogonal route" + }, + { + "mutation": "swap two spectators while preserving orthogonality and involution", + "rejected_by": "48 spectators fixed with no active mixing" + }, + { + "mutation": "duplicate a valid ordinary owner route", + "rejected_by": "96 distinct relative routes" + } + ], + "credited_fourth_moment_argument": "commdata2338 PR2189, following Nick Petalas PR2181", + "full_route_columns_checked": 73, + "gram_multiples": { + "A": 4, + "T": 4, + "U": 48, + "all": 56 + }, + "matrix_equality": "full exact active-column tuples; sorted fibre/intersection comparison", + "native_routes_checked": 336, + "ordered_product_tables": { + "01": { + "distinct_products": 9121, + "identity_diagonal_pairs": 96, + "nonidentity_singleton_fibres": 9120, + "ordered_pairs": 9216, + "relative_routes": 96 + }, + "02": { + "distinct_products": 9121, + "identity_diagonal_pairs": 96, + "nonidentity_singleton_fibres": 9120, + "ordered_pairs": 9216, + "relative_routes": 96 + }, + "10": { + "distinct_products": 9121, + "identity_diagonal_pairs": 96, + "nonidentity_singleton_fibres": 9120, + "ordered_pairs": 9216, + "relative_routes": 96 + }, + "12": { + "distinct_products": 9121, + "identity_diagonal_pairs": 96, + "nonidentity_singleton_fibres": 9120, + "ordered_pairs": 9216, + "relative_routes": 96 + }, + "20": { + "distinct_products": 9121, + "identity_diagonal_pairs": 96, + "nonidentity_singleton_fibres": 9120, + "ordered_pairs": 9216, + "relative_routes": 96 + }, + "21": { + "distinct_products": 9121, + "identity_diagonal_pairs": 96, + "nonidentity_singleton_fibres": 9120, + "ordered_pairs": 9216, + "relative_routes": 96 + } + }, + "ordinary_columns": 96, + "product_intersections": { + "01_02": "identity only", + "10_12": "identity only", + "20_21": "identity only" + }, + "root_columns": 112, + "scope": "Finite source-matrix census and conditional regular-cover rank bound; no native packet, controller, supplier or kappa admission", + "source_interpretation": { + "R": "constructor coordinate totals, tau=43 transport, phase recipe port order", + "compressed_packet_comparison": "NOT RUN; no packet or scalar-program replay", + "partition": "retained QQ16-SELECTED-WITNESS A/T/U", + "routes": "C S C^T chart swaps from main verify_native definition" + }, + "source_paths": [ + "research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json", + "research/direct-delivery504-global/inputs/data-base/work/complex-nine-native/DATA-PHASES.json", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json", + "research/gauge44-slots-t16/construction/leaver/cgx_leaver.py", + "research/complex-sw4-frame8/vendor/pr635/research/complex-571-cold14-st2/code/hpe_audit_and_transport.py", + "research/joint-query/verify_native.py" + ], + "spectators_fixed": 48, + "status": "PASS_QQ16_TEXT_SOURCE_FOURTH_MOMENTS", + "trace_certificate": { + "identity_A_coefficient": 192, + "moments_per_owner": [ + "24", + "28", + "109/3", + "1823/36" + ], + "polynomial_coefficients_ascending": [ + "0", + "81/20", + "-9441/1600", + "729/200", + "-81/100" + ], + "rank_lower_bound_per_owner": "117/5", + "reduced_trace_values": { + "alternating_two": "23/216", + "one_stage": "8", + "repeated_among_three": "1/18", + "three_distinct": "1/18", + "two_stages": "2/3" + }, + "root_diagonal_dot_square_sum": 1536, + "root_dot_square_sum": 18432, + "spectral_certificate": "p(t)=1-(1-81t/40+9t^2/10)^2; p(0)=0; p(t)<=1", + "stage_word_counts": [ + { + "one_stage": 3 + }, + { + "one_stage": 3, + "two_stages": 6 + }, + { + "one_stage": 3, + "three_distinct": 6, + "two_stages": 18 + }, + { + "alternating_two": 6, + "one_stage": 3, + "repeated_among_three": 12, + "three_distinct": 24, + "two_stages": 36 + } + ] + } + }, + "sources": { + "full_selected_inventory_replay": "NOT RUN", + "live_input_sha256": { + "research/community-frontier1094-audit/SELECTED-SOURCE.json": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b", + "research/complex-sw4-frame8/vendor/pr635/research/complex-571-cold14-st2/code/hpe_audit_and_transport.py": "c9a05ff291016b870b4fc925b317abd9c3a604c73ffc8920dfdbbeb475e20aa3", + "research/direct-delivery504-global/inputs/data-base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", + "research/gauge44-slots-t16/construction/leaver/cgx_leaver.py": "3af491c63dd96204a7c36006c7e419c2e5ce77e5bc453ccd2495c1e41f83f87c", + "research/joint-query/NOTICE.md": "0e6f26a1453a98dc73c2d50e9bdd76a78e57411cd1b3f84331dc1590b128b0ff", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75", + "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md": "4bb4a68d8b4811b6d8364150612056bc124d38f1974d6f603dae68a99c4682fb", + "research/joint-query/evidence/QQ16-RATIONAL-OBSERVATION-REVIEW.md": "9a06ff40830ef80d3566fce77c78639cb64d519d487a0a7f57d543c3146e2c49", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md": "52f2ee565320f05282c637aa79eee100606c24240b1b5866f0c8d62e7913c9fc", + "research/joint-query/verify_native.py": "1c58e7b6e8e1cde4df455c2129601c145ed763fc63a3ab427eb1058d1fc08bd2", + "research/replica-prefix-audit/PROOF.md": "b8fa0fa9d032e90516568b39d32a538f8dcbc5bfc717750adba611511394623f", + "research/replica-prefix-audit/verify.py": "0986a7c9c028346091e83e390f83c52c5a441d7bb8ebfb2257a614489bb77f11" + }, + "selected_manifest_members_checked": [ + "research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json", + "research/direct-delivery504-global/inputs/data-base/work/complex-nine-native/DATA-PHASES.json", + "research/gauge44-slots-t16/construction/leaver/cgx_leaver.py", + "research/complex-sw4-frame8/vendor/pr635/research/complex-571-cold14-st2/code/hpe_audit_and_transport.py" + ] + }, + "status": "PASS_SCOPED_QQ16_SHEAR_TRANSCRIPT_FLOOR" +} diff --git a/research/qq16-shear-transcript-floor/SOURCES.json b/research/qq16-shear-transcript-floor/SOURCES.json new file mode 100644 index 0000000000..0f149506ff --- /dev/null +++ b/research/qq16-shear-transcript-floor/SOURCES.json @@ -0,0 +1,102 @@ +{ + "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-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "input", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/complex-sw4-frame8/vendor/pr635/research/complex-571-cold14-st2/code/hpe_audit_and_transport.py", + "usage": "input", + "git_blob": "d5d3509d90c01fd91dd00b78743287614b532e48", + "sha256": "c9a05ff291016b870b4fc925b317abd9c3a604c73ffc8920dfdbbeb475e20aa3" + }, + { + "path": "research/direct-delivery504-global/inputs/data-base/work/complex-nine-native/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json", + "usage": "input", + "git_blob": "9efe30ee107b9c67f15f1c726e1a1cb5cef03929", + "sha256": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f" + }, + { + "path": "research/gauge44-slots-t16/construction/leaver/cgx_leaver.py", + "usage": "input", + "git_blob": "e686c66306456e2c6cac9c05d01448765322836c", + "sha256": "3af491c63dd96204a7c36006c7e419c2e5ce77e5bc453ccd2495c1e41f83f87c" + }, + { + "path": "research/joint-query/NOTICE.md", + "usage": "input", + "git_blob": "297ac2775cd01d6a69f4b5afc54287ded8f14682", + "sha256": "0e6f26a1453a98dc73c2d50e9bdd76a78e57411cd1b3f84331dc1590b128b0ff" + }, + { + "path": "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "usage": "input", + "git_blob": "a6805c58f23132f9420efebf90f5b7e863c2e179", + "sha256": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75" + }, + { + "path": "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md", + "usage": "input", + "git_blob": "3dd1a990d7b9d57cfb20cf8e8dd45548f043a944", + "sha256": "4bb4a68d8b4811b6d8364150612056bc124d38f1974d6f603dae68a99c4682fb" + }, + { + "path": "research/joint-query/evidence/QQ16-RATIONAL-OBSERVATION-REVIEW.md", + "usage": "input", + "git_blob": "c6ecf75654a084a9cc001bd62663f341976bae7a", + "sha256": "9a06ff40830ef80d3566fce77c78639cb64d519d487a0a7f57d543c3146e2c49" + }, + { + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json", + "usage": "input", + "git_blob": "5082d791d0b993492cbc5bf61ac3b69e82c96f3f", + "sha256": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4" + }, + { + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "usage": "input", + "git_blob": "307650f45e37c28d14fe913958efa4fb429242b7", + "sha256": "52f2ee565320f05282c637aa79eee100606c24240b1b5866f0c8d62e7913c9fc" + }, + { + "path": "research/joint-query/verify_native.py", + "usage": "input", + "git_blob": "ede9e7e42744dd0c96790516a9acdfe07d180018", + "sha256": "1c58e7b6e8e1cde4df455c2129601c145ed763fc63a3ab427eb1058d1fc08bd2" + }, + { + "path": "research/replica-prefix-audit/PROOF.md", + "usage": "input", + "git_blob": "9c1728018d626501663a51268382f9e2e3813dda", + "sha256": "b8fa0fa9d032e90516568b39d32a538f8dcbc5bfc717750adba611511394623f" + }, + { + "path": "research/replica-prefix-audit/verify.py", + "usage": "input", + "git_blob": "90958638cbbfdbd6bdfe6cbd13db94e1e3301bd5", + "sha256": "0986a7c9c028346091e83e390f83c52c5a441d7bb8ebfb2257a614489bb77f11" + } + ] +} diff --git a/research/qq16-shear-transcript-floor/TASK.json b/research/qq16-shear-transcript-floor/TASK.json new file mode 100644 index 0000000000..91e9d8d35d --- /dev/null +++ b/research/qq16-shear-transcript-floor/TASK.json @@ -0,0 +1,161 @@ +{ + "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": "Determine whether the fixed QQ16 F0-to-B1 invertible A-to-T sum-preserving shear, together with one additional dense ordinary observation, restores all original pair-0 selected inputs under the retained ordinary tail. Prove a rank floor for this precise modified first pair.", + "scope_change_reason": "Follow the live full-kernel handoff of PR2326 instead of rerunning its coordinate-tap census. Allow an arbitrary fixed invertible selected pairing and a counted rational-linear record; keep the local QQ16 maps and ordinary tail.", + "bottleneck_link": "The joint-query native words already exist; this tests whether the proposed boundary shear actually removes their missing-information obstruction before a new physical controller is priced.", + "budget_minutes": 120, + "stop_rule": "Test the full observation kernel first. Stop construction/pricing if a positive-dimensional selected defect survives even with all implementation costs granted free. Reserve the final quarter for verification and handoff.", + "outcome": "negative-result", + "evidence": "Written ordered changed-shear kernel proof; independent exact text-source route/Gram fourth-moment replay; full logical retained-tail replay; two noncommuting rational full-input kernel fixtures. Registered normal and optimized replay passed with 18 mathematical/schedule failure controls and five integration tests, including Git-free read-only relocation and source/receipt tampering rejection. Separate agent reviews found no substantive blocker; no independent human review.", + "author": "Jason (@jgilfoil)", + "ai_assistance": "Substantial OpenAI Codex assistance in derivation, code, verification, writing, and independent agent review. No independent human review is claimed.", + "selection": { + "initial_nonce": "d7135726fa46715b28d9967be33fab98", + "initial_track": "bit-mechanisms", + "override": "Revision 4 permits a live central handoff matching available algebra/verification expertise. Taking PR2326's explicit dense-observation full-kernel question, without rerolling.", + "source_export": "Exact main Git commit and all tree hashes reconstructed from GitHub API; only relevant text blobs hydrated because shell networking and binary connector downloads are unavailable." + }, + "coordination": { + "status": "LOCAL-ONLY: no public claim posted", + "utc": "2026-10-15T06:04:46.313Z", + "reason": "Authorized Discussion participation is unavailable through the installed connector, and shell DNS remains disabled.", + "open_pr_snapshot": { + "fetched_at": "2026-10-15T06:04:46.313Z", + "records": 559, + "complete_pagination": true + }, + "discussion_coverage": "Public web onboarding/handoff/active threads checked, but newer discussion pages are unavailable or stale; full live discussion pagination not available.", + "nearest_prs": [ + { + "number": 2326, + "head": "fb7d64cd4a51c49bc56920305b0aca64011a420c", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2326" + }, + { + "number": 2306, + "head": "4d6e08099c11ff06a8585d04ed59453dd5a62d7d", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2306" + }, + { + "number": 2268, + "head": "daf44bfc752a5e89127defa1cb296210708cf7e6", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2268" + }, + { + "number": 2216, + "head": "b80e9ba43367fb8b20877a97da1cb677c34f9264", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2216" + }, + { + "number": 2189, + "head": "968ccd289de1130c437cb4936608c4ee419a27de", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2189" + }, + { + "number": 2181, + "head": "e18ca76987f5945c6a4b5b6bebbe73cdab3c4561", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2181" + }, + { + "number": 2174, + "head": "f79470a7931f3943360c10d15b428e0e4e479c22", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2174" + }, + { + "number": 2153, + "head": "5646398dcdc01769df83b939c6b3eb5ecb4d5ebd", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2153" + }, + { + "number": 2104, + "head": "4bdc574da394a39f955e8cf4637075649c43a632", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2104" + }, + { + "number": 2346, + "head": "653520d7f18f686ea3a274b4963981f5be563477", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2346" + } + ], + "concurrent_work": "PR2346 discovered in final refresh; pinned proof read. It forbids pre-F2 selected interventions and tests 64 specified initial records with final-only selected observations. Our changed-shear family vanishes already at B1, whose selected values are granted free; the results do not supersede each other." + }, + "verification_limitations": [ + "The prescribed research_baseline.py was attempted but cannot check the complete selected package inventory in the bounded source export. The selected record and its certificate/review were read; no baseline pass or supplier cold replay is claimed." + ], + "open_questions": [ + { + "question": "Can a changed first pair retain enough independent selected information to evade this quantified kernel?", + "why_it_matters": "A richer controller must change an implication excluded here before physical implementation can help.", + "first_step": "Specify one changed local map or ordinary-state update and derive its complete observation operator on arbitrary dirty inputs.", + "blocked_by": "The retained local maps and ordinary-only final endpoint hide the constructed residue." + }, + { + "question": "Can sixteen or more retained query coordinates be implemented and kept through the final selected cut at favorable full cost?", + "why_it_matters": "The information floor is necessary, and does not itself price or supply a legal controller.", + "first_step": "Start from PR2174's two-query cut recovery and bind its B1 values to actual final records. PR2346 rules out its specified 64-query replacement without pre-F2 intervention; change that retention mechanism. Then charge native frames, storage and cleanup.", + "blocked_by": "Final-cut retention and native/tape/precision obligations remain open." + } + ], + "upstream_checkpoint": { + "utc": "2026-10-15T06:04:46.313Z", + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "change": "Main unchanged; all original relevant PR heads unchanged. No source or frontier migration." + }, + "verification": { + "environment": "Linux x86_64, CPython 3.12.3, standard library only", + "commands": [ + "python3 -I -B scripts/research_package.py --package research/qq16-shear-transcript-floor --check-only", + "python3 -I -B scripts/research_package.py --package research/qq16-shear-transcript-floor", + "git diff --check" + ], + "receipt": "RESULT.json", + "code_review": "Separate agent reviews of source geometry/moments, ordered proof, algebra fixtures, and replay integrity. Not independent human or proof-assistant review." + } +} diff --git a/research/qq16-shear-transcript-floor/VERIFY.json b/research/qq16-shear-transcript-floor/VERIFY.json new file mode 100644 index 0000000000..2785f34c8d --- /dev/null +++ b/research/qq16-shear-transcript-floor/VERIFY.json @@ -0,0 +1,55 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "research/complex-sw4-frame8/vendor/pr635/research/complex-571-cold14-st2/code/hpe_audit_and_transport.py", + "research/direct-delivery504-global/inputs/data-base/work/complex-nine-native/DATA-PHASES.json", + "research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json", + "research/gauge44-slots-t16/construction/leaver/cgx_leaver.py", + "research/joint-query/NOTICE.md", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md", + "research/joint-query/evidence/QQ16-RATIONAL-OBSERVATION-REVIEW.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "research/joint-query/verify_native.py", + "research/replica-prefix-audit/PROOF.md", + "research/replica-prefix-audit/verify.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Pinned main source reconstruction, exact route moments and spectral certificate, ordered shear kernel, retained-tail fixtures and semantic failure controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Same proof-relevant replay with assertions disabled." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 120, + "checks": "External source corruption and receipt corruption must fail; source export replay is read-only." + } + ] +} diff --git a/research/qq16-shear-transcript-floor/algebra.py b/research/qq16-shear-transcript-floor/algebra.py new file mode 100644 index 0000000000..d047b1fc0d --- /dev/null +++ b/research/qq16-shear-transcript-floor/algebra.py @@ -0,0 +1,281 @@ +"""Exact ordered QQ16 shear fixtures; standard library, no producer imports. + +These small rational models test the general ordered theorem, not the +actual-source rank premise. Apache-2.0. Prepared for @jgilfoil with +substantial OpenAI Codex assistance. +""" + +from fractions import Fraction as F + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def eye(n): + return [[F(i == j) for j in range(n)] for i in range(n)] + + +def zeros(n, m): + return [[F(0) for _ in range(m)] for _ in range(n)] + + +def add(a, b): + need(len(a) == len(b), "vector dimensions") + return [x + y for x, y in zip(a, b)] + + +def scale(c, a): + return [c * x for x in a] + + +def mv(a, x): + need(all(len(row) == len(x) for row in a), "matrix/vector dimensions") + return [sum((c * v for c, v in zip(row, x)), F(0)) for row in a] + + +def mm(a, b): + need(bool(b) and all(len(row) == len(b) for row in a), "matrix dimensions") + return [[sum((row[k] * b[k][j] for k in range(len(b))), F(0)) + for j in range(len(b[0]))] for row in a] + + +def ma(a, b): + return [add(x, y) for x, y in zip(a, b)] + + +def ms(c, a): + return [scale(c, row) for row in a] + + +def rref(matrix, columns=None): + a = [[F(x) for x in row] for row in matrix] + n = len(a[0]) if a else (columns or 0) + need(all(len(row) == n for row in a), "rectangular matrix") + pivots = [] + for col in range(n): + pivot = next((i for i in range(len(pivots), len(a)) if a[i][col]), None) + if pivot is None: + continue + row = len(pivots) + a[row], a[pivot] = a[pivot], a[row] + a[row] = scale(1 / a[row][col], a[row]) + for i in range(len(a)): + if i != row and a[i][col]: + a[i] = add(a[i], scale(-a[i][col], a[row])) + pivots.append(col) + return a, pivots + + +def rank(a, columns=None): + return len(rref(a, columns)[1]) + + +def kernel(a, columns=None): + reduced, pivots = rref(a, columns) + n = len(a[0]) if a else columns + basis = [] + for free in range(n): + if free in pivots: + continue + v = [F(0)] * n + v[free] = F(1) + for i, pivot in enumerate(pivots): + v[pivot] = -reduced[i][free] + need(not any(mv(a, v)), "constructed nullspace") + basis.append(v) + return basis + + +def inverse(a): + n = len(a) + reduced, pivots = rref([row + unit for row, unit in zip(a, eye(n))]) + need(pivots == list(range(n)), "invertible matrix") + result = [row[n:] for row in reduced] + need(mm(a, result) == eye(n) and mm(result, a) == eye(n), "two-sided inverse") + return result + + +def columns_to_rows(columns, nrows=None): + if not columns: + return [[] for _ in range(nrows or 0)] + return [list(row) for row in zip(*columns)] + + +class Model: + """Literal conserved maps, independent of the witness construction.""" + + def __init__(self, q): + need(q in (2, 3), "fixture centre dimension") + self.q, self.m = q, 3 * q + upper, lower = eye(q), eye(q) + upper[0][1] = F(1) + lower[1][0] = F(1) + if q == 3: + upper[1][2] = F(1) + lower[2][1] = F(1) + self.A = [upper, ma(upper, ms(F(1), ma(upper, ms(-1, eye(q))))), mm(upper, lower)] + self.T = [lower, lower, mm(lower, upper)] + self.PA = [inverse(a) for a in self.A] + self.PT = [inverse(t) for t in self.T] + self.Q, self.Qinv = upper, inverse(upper) + self.B, self.K = [], [] + for stage in range(3): + b, k = zeros(q, self.m), zeros(self.m, q) + for i in range(q): + b[i][stage * q + i] = F(1) + k[stage * q + i][i] = F(12) + self.B.append(b) + self.K.append(k) + need(mm(b, k) == ms(12, eye(q)), "ordinary response identity") + need(mm(self.Qinv, self.PT[1]) != mm(self.PT[1], self.Qinv), + "fixture must detect operator order") + self.tap = mm(lower, upper) + + def split(self, x): + need(len(x) == self.m + 2 * self.q, "field dimension") + return x[:self.m], x[self.m:self.m+self.q], x[self.m+self.q:] + + def query(self, s, x): + u, a, t = self.split(x) + return add(add(mv(self.B[s], u), mv(self.A[s], a)), mv(self.T[s], t)) + + def forward(self, x, y): + xu, xa, xt = self.split(x) + yu, ya, yt = self.split(y) + f = self.query(0, x) + w = add(xu, scale(-1, mv(self.K[0], f))) + new_a = mv(self.PA[0], mv(self.T[0], xt)) + new_t = mv(self.PT[0], f) + return (w + new_a + new_t, + add(yu, w) + add(add(xa, ya), scale(-1, new_a)) + + add(add(xt, yt), scale(-1, new_t)), f) + + def boundary(self, x, y, read, shear_sign=1): + xu, xa, xt = self.split(x) + yu, ya, yt = self.split(y) + record = mv(read, xu) + # The retained record also drives an in-place opposite-sign T tap. + tap = mv(self.tap, record) if len(record) == self.q else [F(0)] * self.q + delta = add(scale(shear_sign, mv(self.Q, xa)), tap) + return (xu + xa + add(xt, delta), yu + ya + add(yt, scale(-1, delta)), record) + + def backward(self, x, y): + xu, xa, xt = self.split(x) + yu, ya, yt = self.split(y) + future = self.query(2, y) + ua = mv(self.PA[2], future) + driver = mv(self.T[1], xt) + current = self.query(1, yu + ua + yt) + new_xt = mv(self.PT[1], add(current, scale(12, driver))) + new_yt = add(yt, scale(-1, mv(self.PT[1], add(current, scale(11, driver))))) + return (add(xu, scale(-1, yu)) + add(add(xa, ya), scale(-1, ua)) + new_xt, + add(yu, mv(self.K[1], driver)) + ua + new_yt) + + def replay(self, x, y, read, shear_sign=1): + x, y, f = self.forward(x, y) + x, y, record = self.boundary(x, y, read, shear_sign) + x, y = self.backward(x, y) + return x, y, f, record + + def observation(self, x, y, read, shear_sign=1): + x, y, f, record = self.replay(x, y, read, shear_sign) + # Grant the entire post-B1 completed X bank as well as selected Y. + return x + y[self.m:] + f + record + + +def family(model, h, order_mutation=False, denominator=11): + left = (mm(model.PT[1], model.Qinv) if order_mutation + else mm(model.Qinv, model.PT[1])) + k = scale(-F(1, denominator), mv(left, mv(model.B[1], h))) + xa = add(scale(-1, mv(model.PA[0], mv(model.B[0], h))), scale(-1, k)) + xt = mv(model.PT[0], mv(model.A[0], k)) + return h + xa + xt, [F(0)] * model.m + scale(-1, xa) + scale(-1, xt) + + +def check_model(q): + model = Model(q) + ordinary = model.m + gmap = ma(ms(11, model.B[2]), mm( + mm(ma(mm(model.A[2], model.Qinv), model.T[2]), model.PT[1]), model.B[1])) + transcript = model.B[0] + h_basis = kernel(gmap + transcript) + need(len(h_basis) == q, "dense read residual dimension") + selected_family, first_pair_census = [], [] + for h in h_basis: + x, y = family(model, h) + after_x, after_y, f, record = model.replay(x, y, transcript) + expected_g = add(h, scale(-F(1, 11), mv(model.K[1], mv(model.B[1], h)))) + need(not any(after_x + after_y[ordinary:] + f + record), "ordered invisible family") + need(after_y[:ordinary] == expected_g, "ordinary residue") + need(any(x[ordinary:]), "nonzero required selected input") + selected_family.append(x[ordinary:]) + first_pair_census.append(sum(bool(v) for v in expected_g)) + need(rank(columns_to_rows(selected_family)) == q, "independent lost selected values") + + # Build the complete input/output matrices from basis evaluations of + # the literal maps, without using K, G, or the family parameterization. + fields = ordinary + 2 * q + observations, selected = [], [] + for j in range(2 * fields): + full = [F(i == j) for i in range(2 * fields)] + x, y = full[:fields], full[fields:] + observations.append(model.observation(x, y, transcript)) + selected.append(x[ordinary:]) + obs = columns_to_rows(observations) + desired = columns_to_rows(selected) + source_rank = rank(model.B[0] + model.B[1] + model.B[2]) + full_defect = rank(obs + desired) - rank(obs) + need(source_rank == 3 * q, "full triple-query rank fixture") + need(full_defect == source_rank - q - rank(transcript) == q, + "full arbitrary-input defect equals rank prediction") + full_kernel = kernel(obs) + need(len(full_kernel) == q, "full input kernel dimension") + for v in full_kernel: + need(not any(model.observation(v[:fields], v[fields:], transcript)), + "independent full-kernel replay") + need(rank(columns_to_rows([mv(desired, v) for v in full_kernel])) == q, + "full-kernel selected-image rank") + + controls = [] + need(any(any(model.observation(*family(model, h), transcript, shear_sign=-1)) + for h in h_basis), "wrong shear sign must be detected") + controls.append("wrong shear sign") + need(any(any(model.observation(*family(model, h, order_mutation=True), transcript)) + for h in h_basis), "wrong noncommuting order must be detected") + controls.append("wrong noncommuting order") + need(any(any(model.observation(*family(model, h, denominator=12), transcript)) + for h in h_basis), "wrong eleven coefficient must be detected") + controls.append("eleven replaced by twelve") + no_read_basis = kernel(gmap) + need(len(no_read_basis) == 2 * q, "unobserved family dimension") + detected = next((h for h in no_read_basis if any(mv(transcript, h))), None) + need(detected is not None, "record removes a real kernel direction") + x, y = family(model, detected) + need(not any(model.observation(x, y, [])), "omitted-record candidate") + need(any(model.observation(x, y, transcript)), "retained record must detect candidate") + controls.append("omitted retained record") + # A real first-pair transient is not among the free observations. + h = h_basis[0] + x, y = family(model, h) + fx, _, _ = model.forward(x, y) + need(any(fx[ordinary:ordinary+q]), "a free transient A cut changes the contract") + controls.append("free transient F0 A record") + return {"centre_dimension": q, "ordinary_dimension": ordinary, + "triple_query_rank": source_rank, "transcript_rank": rank(transcript), + "full_input_dimension": 2 * fields, "observation_rank": rank(obs), + "full_input_kernel_dimension": len(full_kernel), + "lost_selected_dimension": full_defect, + "family_basis_vectors": len(h_basis), "residue_nonzero_entries": first_pair_census, + "rejecting_controls": controls} + + +def verify(): + """Return deterministic JSON-compatible exact-check evidence.""" + return {"status": "PASS_ORDERED_SHEAR_ALGEBRA", "models": [check_model(2), check_model(3)]} + + +if __name__ == "__main__": + import json + print(json.dumps(verify(), sort_keys=True, indent=2)) diff --git a/research/qq16-shear-transcript-floor/source_moments.py b/research/qq16-shear-transcript-floor/source_moments.py new file mode 100644 index 0000000000..8168d567bb --- /dev/null +++ b/research/qq16-shear-transcript-floor/source_moments.py @@ -0,0 +1,371 @@ +"""Independent exact QQ16 source-geometry and fourth-moment calculation. + +Apache-2.0. Prepared with OpenAI Codex assistance. The fourth-moment +argument and spectral polynomial are credited to commdata2338, PR #2189, +following Nick Petalas's PR #2181 and the retained Ali Romman QQ16 work. +This module independently implements the arithmetic; it imports none of +those checkers. Native root coordinates are reconstructed from the credited +icekylinx / DreamingOfClouds / PR635 source lineage described below. + +This is a text-source replay. The constructor and transport define R; the +native verifier defines the owner chart swaps. Equality to the compressed +QQ16 packet, its map registry, scalar programs, phases, and complete +controller execution is NOT checked here. The package driver pins the +source files. The interpretation as the retained QQ16 operators inherits +those source definitions and the witness's native-interface interpretation. +""" + +from copy import deepcopy +from fractions import Fraction as Q +from itertools import groupby, permutations, product +import json +from pathlib import Path + + +PROTOTYPE = "research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json" +PHASES = ("research/direct-delivery504-global/inputs/data-base/work/" + "complex-nine-native/DATA-PHASES.json") +WITNESS = "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json" +CONSTRUCTOR = "research/gauge44-slots-t16/construction/leaver/cgx_leaver.py" +TRANSPORT = ("research/complex-sw4-frame8/vendor/pr635/research/" + "complex-571-cold14-st2/code/hpe_audit_and_transport.py") +NATIVE_DEFINITION = "research/joint-query/verify_native.py" +SOURCE_PATHS = (PROTOTYPE, PHASES, WITNESS, CONSTRUCTOR, TRANSPORT, + NATIVE_DEFINITION) + +AXES = 73 +ACTIVE = 25 +I73 = tuple(1 << i for i in range(AXES)) +I25 = I73[:ACTIVE] + + +def need(condition, reason): + if not condition: + raise ValueError(reason) + + +def parity(value): + return value.bit_count() & 1 + + +def apply_columns(columns, vector): + answer = 0 + while vector: + bit = vector & -vector + answer ^= columns[bit.bit_length() - 1] + vector ^= bit + return answer + + +def compose(left, right): + """Literal binary matrix product, represented by complete columns.""" + return tuple(apply_columns(left, column) for column in right) + + +def transpose(columns): + return tuple(sum(((column >> i) & 1) << j + for j, column in enumerate(columns)) + for i in range(len(columns))) + + +def gram(columns, ports): + return [[sum(columns[p][i] * columns[p][j] for p in ports) + for j in range(8)] for i in range(8)] + + +def scalar_identity(value): + return [[value * int(i == j) for j in range(8)] for i in range(8)] + + +def check_roots(columns, selected_a, selected_t, ordinary): + need(len(columns) == 112 and all(len(c) == 8 for c in columns), + "root dimensions") + need(all(type(x) is int for c in columns for x in c), "integer roots") + need(all(sum(x*x for x in c) == 4 for c in columns), "root norm four") + need(gram(columns, range(112)) == scalar_identity(56), "full Gram 56I") + need(gram(columns, selected_a) == scalar_identity(4), "A Gram 4I") + need(gram(columns, selected_t) == scalar_identity(4), "T Gram 4I") + need(gram(columns, ordinary) == scalar_identity(48), "ordinary Gram 48I") + + +def check_route(columns): + need(len(columns) == AXES and all(type(c) is int and 0 <= c < 1 << AXES + for c in columns), "73-column route") + need(compose(transpose(columns), columns) == I73, "orthogonal route") + need(compose(columns, columns) == I73, "involutive route") + need(columns[ACTIVE:] == I73[ACTIVE:] and + all(c < 1 << ACTIVE for c in columns[:ACTIVE]), + "48 spectators fixed with no active mixing") + + +def chart_route(chart, stage): + """Conjugate a coordinate swap by the full orthonormal chart. + + This implementation applies C S C^T to every standard basis vector. + It does not use a predecessor's rank-one update implementation. + In chart coordinates S exchanges positions 1..8 with the eight stage + slots; stage zero is the identity. + """ + if stage == 0: + return I73 + first = 9 + 8 * (stage - 1) + answer = [] + for axis in range(AXES): + coordinates = sum(((column >> axis) & 1) << j + for j, column in enumerate(chart)) + for k in range(8): + left, right = k + 1, first + k + if ((coordinates >> left) ^ (coordinates >> right)) & 1: + coordinates ^= (1 << left) | (1 << right) + answer.append(apply_columns(chart, coordinates)) + return tuple(answer) + + +def source_geometry(root): + root = Path(root) + for relative in SOURCE_PATHS: + need((root / relative).is_file(), "missing pinned source: " + relative) + prototype = json.loads((root / PROTOTYPE).read_text()) + phases = json.loads((root / PHASES).read_text()) + witness = json.loads((root / WITNESS).read_text()) + old_ports, old_roots = prototype["binary_ports"], prototype["root_lines"] + need(len(old_ports) == len(old_roots) == 120, "prototype inventory") + need(old_roots[:8] == [[2 * int(i == j) for j in range(8)] + for i in range(8)], "removed eight coordinate axes") + need(phases["m"] == AXES and phases["ports"] == 112, "phase dimensions") + recipes = phases["recipes"] + need(len(recipes) == 112, "all native ports") + native_labels = [record["q"] for record in recipes] + transformed = [p ^ (43 if parity(p & 43) else 0) for p in old_ports[8:]] + need(sorted(transformed) == sorted(native_labels) and + len(set(native_labels)) == 112, "native label permutation") + columns = [old_roots[8 + transformed.index(q)] for q in native_labels] + selected_a, selected_t, ordinary = (witness[k] for k in ("A", "T", "U")) + need(len(selected_a) == len(selected_t) == 8 and len(ordinary) == 96, + "QQ16 partition sizes") + need(sorted(selected_a + selected_t + ordinary) == list(range(112)), + "QQ16 partition is disjoint and exhaustive") + need(ordinary == [p for p in range(112) if p not in selected_a + selected_t], + "ordered ordinary ports") + check_roots(columns, selected_a, selected_t, ordinary) + all_routes = [[], [], []] + for p, record in enumerate(recipes): + need(record["port"] == p, "phase recipe order") + chart = (record["q"], *record["idle_children"][0]["orthogonal_axes"][:8], + *I73[9:]) + need(len(chart) == AXES and all(type(x) is int and 0 < x < 512 + for x in chart[:9]), "nine-axis chart") + need(compose(transpose(chart), chart) == I73, "orthonormal source chart") + beta = sum((((c.bit_count() - 1) // 2) & 1) << j + for j, c in enumerate(chart[1:9])) + lift = apply_columns(chart[1:9], beta) + for stage in range(3): + route = chart_route(chart, stage) + check_route(route) + entry = (record["q"] ^ lift) if stage else 0 + leave = (lift ^ (beta << (9 + 8*(stage - 1)))) if stage else 0 + need(record["stage_alignment"][stage] == + {"entry_X": entry, "entry_Y": entry, + "exit_X": leave, "exit_Y": leave}, + "source stage alignment") + all_routes[stage].append(route) + return columns, (selected_a, selected_t, ordinary), all_routes + + +def relative_routes(routes, ordinary, s, t): + result = [compose(routes[s][p][:ACTIVE], + transpose(routes[t][p][:ACTIVE])) for p in ordinary] + ordered = sorted(result) + need(all(a != b for a, b in zip(ordered, ordered[1:])), + "96 distinct relative routes") + return result + + +def exact_table(relative): + """Sort complete matrices: no digest participates in equality.""" + records = [(compose(a, transpose(b)), p, q) + for p, a in enumerate(relative) for q, b in enumerate(relative)] + records.sort() + image = [] + identity_pairs = 0 + singleton_pairs = 0 + for matrix, fibre in groupby(records, key=lambda item: item[0]): + pairs = [(p, q) for _, p, q in fibre] + image.append(matrix) + if matrix == I25: + need(pairs == [(p, p) for p in range(96)], "identity fibre is diagonal") + identity_pairs = len(pairs) + else: + need(len(pairs) == 1 and pairs[0][0] != pairs[0][1], + "nonidentity fibre is singleton") + singleton_pairs += 1 + need(len(image) == 9121 and identity_pairs == 96 and singleton_pairs == 9120, + "complete ordered-product census") + return image + + +def intersection(left, right): + """Exact merge intersection of sorted complete binary matrices.""" + i = j = 0 + common = [] + while i < len(left) and j < len(right): + if left[i] == right[j]: + common.append(left[i]) + i += 1 + j += 1 + elif left[i] < right[j]: + i += 1 + else: + j += 1 + return common + + +def cyclic_reduce(word): + word = list(word) + while len(word) > 1: + duplicate = next((i for i in range(len(word)) + if word[i] == word[(i+1) % len(word)]), None) + if duplicate is None: + return tuple(word) + del word[duplicate] + return tuple(word) + + +def trace_moments(columns, ordinary): + dots_square = sum(sum(x*y for x, y in zip(columns[p], columns[q]))**2 + for p in ordinary for q in ordinary) + diagonal = sum(sum(x*x for x in columns[p])**2 for p in ordinary) + need((dots_square, diagonal) == (18432, 1536), "root Gram contractions") + identity_coefficient = 4 * 48 + identity_norm = 8 * identity_coefficient**2 + values = { + "one_stage": Q(8), + "two_stages": Q(diagonal, 48**2), + "three_distinct": Q(96 * 4**3, 48**3), + "alternating_two": Q(identity_norm + 16*(dots_square-diagonal), 48**4), + "repeated_among_three": Q(identity_norm, 48**4), + } + moments, counts = [], [] + for length in range(1, 5): + tally = {key: 0 for key in values} + for word in product(range(3), repeat=length): + reduced = cyclic_reduce(word) + if len(reduced) == 1: + kind = "one_stage" + elif len(reduced) == 2: + kind = "two_stages" + elif len(reduced) == 3: + need(len(set(reduced)) == 3, "three-stage cyclic reduction") + kind = "three_distinct" + elif len(set(reduced)) == 2: + kind = "alternating_two" + else: + need(len(reduced) == 4 and len(set(reduced)) == 3, + "four-stage cyclic reduction") + kind = "repeated_among_three" + tally[kind] += 1 + counts.append({key: value for key, value in tally.items() if value}) + moments.append(sum((values[key] * count for key, count in tally.items()), Q(0))) + need(moments == [Q(24), Q(28), Q(109, 3), Q(1823, 36)], "four trace moments") + a, b = Q(81, 40), Q(-9, 10) + need(moments[1]*a + moments[2]*b == moments[0] and + moments[2]*a + moments[3]*b == moments[1], "exact moment system") + polynomial = [Q(1), -a, -b] + square = [Q(0)] * 5 + for i, x in enumerate(polynomial): + for j, y in enumerate(polynomial): + square[i+j] += x*y + certificate = [Q(int(i == 0)) - c for i, c in enumerate(square)] + need(certificate == [Q(0), Q(81, 20), Q(-9441, 1600), + Q(729, 200), Q(-81, 100)], "square polynomial identity") + rank = sum((c*m for c, m in zip(certificate[1:], moments)), Q(0)) + need(rank == Q(117, 5), "rational rank lower bound") + return {"moments_per_owner": list(map(str, moments)), + "stage_word_counts": counts, + "reduced_trace_values": {k: str(v) for k, v in values.items()}, + "root_dot_square_sum": dots_square, + "root_diagonal_dot_square_sum": diagonal, + "identity_A_coefficient": identity_coefficient, + "polynomial_coefficients_ascending": list(map(str, certificate)), + "rank_lower_bound_per_owner": str(rank), + "spectral_certificate": "p(t)=1-(1-81t/40+9t^2/10)^2; p(0)=0; p(t)<=1"} + + +def rejection_controls(columns, partition, routes): + selected_a, selected_t, ordinary = partition + controls = [] + + def reject(name, action, expected): + try: + action() + except ValueError as error: + need(str(error) == expected, "wrong control rejection: " + name) + controls.append({"mutation": name, "rejected_by": expected}) + else: + raise ValueError("mutation accepted: " + name) + + corrupted = deepcopy(columns) + corrupted[ordinary[0]][0] += 1 + reject("corrupt one root coordinate", lambda: check_roots(corrupted, *partition), + "root norm four") + corrupted_gram = deepcopy(columns) + victim = ordinary[0] + replacement = next(p for p in ordinary[1:] + if gram(columns, [p]) != gram(columns, [victim])) + corrupted_gram[victim] = columns[replacement][:] + reject("duplicate a norm-four root with different outer product", + lambda: check_roots(corrupted_gram, *partition), "full Gram 56I") + corrupted_route = list(routes[1][ordinary[0]]) + corrupted_route[0] ^= 1 + reject("corrupt one route matrix entry", lambda: check_route(tuple(corrupted_route)), + "orthogonal route") + spectator_route = list(routes[1][ordinary[0]]) + spectator_route[25], spectator_route[26] = spectator_route[26], spectator_route[25] + reject("swap two spectators while preserving orthogonality and involution", + lambda: check_route(tuple(spectator_route)), + "48 spectators fixed with no active mixing") + duplicate_routes = [list(stage) for stage in routes] + duplicate_routes[1][ordinary[0]] = routes[1][ordinary[1]] + reject("duplicate a valid ordinary owner route", + lambda: relative_routes(duplicate_routes, ordinary, 0, 1), + "96 distinct relative routes") + return controls + + +def run(root): + """Return a deterministic JSON-compatible exact finite receipt.""" + columns, partition, routes = source_geometry(root) + ordinary = partition[2] + tables, table_receipts = {}, {} + for s, t in permutations(range(3), 2): + relative = relative_routes(routes, ordinary, s, t) + tables[s, t] = exact_table(relative) + table_receipts[f"{s}{t}"] = { + "relative_routes": len(relative), "ordered_pairs": len(relative)**2, + "distinct_products": len(tables[s, t]), "identity_diagonal_pairs": 96, + "nonidentity_singleton_fibres": 9120} + intersections = {} + for s in range(3): + t, u = [v for v in range(3) if v != s] + common = intersection(tables[s, t], tables[s, u]) + need(common == [I25], "same-first-stage product images meet only at identity") + intersections[f"{s}{t}_{s}{u}"] = "identity only" + return { + "status": "PASS_QQ16_TEXT_SOURCE_FOURTH_MOMENTS", + "source_paths": list(SOURCE_PATHS), + "source_interpretation": { + "R": "constructor coordinate totals, tau=43 transport, phase recipe port order", + "routes": "C S C^T chart swaps from main verify_native definition", + "partition": "retained QQ16-SELECTED-WITNESS A/T/U", + "compressed_packet_comparison": "NOT RUN; no packet or scalar-program replay"}, + "credited_fourth_moment_argument": "commdata2338 PR2189, following Nick Petalas PR2181", + "root_columns": 112, "ordinary_columns": 96, + "gram_multiples": {"all": 56, "A": 4, "T": 4, "U": 48}, + "full_route_columns_checked": AXES, "native_routes_checked": 112*3, + "active_axes": ACTIVE, "spectators_fixed": AXES-ACTIVE, + "matrix_equality": "full exact active-column tuples; sorted fibre/intersection comparison", + "ordered_product_tables": table_receipts, + "product_intersections": intersections, + "trace_certificate": trace_moments(columns, ordinary), + "controls": rejection_controls(columns, partition, routes), + "scope": "Finite source-matrix census and conditional regular-cover rank bound; no native packet, controller, supplier or kappa admission"} diff --git a/research/qq16-shear-transcript-floor/tail.py b/research/qq16-shear-transcript-floor/tail.py new file mode 100644 index 0000000000..75068f3782 --- /dev/null +++ b/research/qq16-shear-transcript-floor/tail.py @@ -0,0 +1,226 @@ +"""Exact QQ16 retained-tail replay on a formal arbitrary ordinary residue. + +Apache-2.0. Prepared for @jgilfoil with substantial OpenAI Codex assistance. +No predecessor executable is imported or executed. The event projection is +checked against Ali Romman's retained QQ16 witness. Local pair indices are +read from the literal assertion in the main replica-prefix source audit. +The compressed parent template and physical endpoint types are not replayed: +their identification with these source assertions remains inherited. +""" + +import ast +from copy import deepcopy +import json +from pathlib import Path + + +WITNESS = "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json" +WITNESS_NOTE = "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md" +PAIR_SOURCE = "research/replica-prefix-audit/verify.py" +SOURCE_PATHS = (WITNESS, WITNESS_NOTE, PAIR_SOURCE) +PAIR_VECTOR = [0, 0, 0, 1, 1, 2, 2, 3, 3] + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def source_pairs(root): + """Read a unique literal binding without running the predecessor audit.""" + tree = ast.parse((Path(root) / PAIR_SOURCE).read_text()) + functions = [node for node in tree.body + if isinstance(node, ast.FunctionDef) and node.name == "schedule_audit"] + need(len(functions) == 1, "unique source schedule_audit function") + assignments = [node for node in ast.walk(functions[0]) + if isinstance(node, ast.Assign) + and any(isinstance(target, ast.Name) and target.id == "expected_pairs" + for target in node.targets)] + need(len(assignments) == 1, "unique source expected_pairs assignment") + pairs = ast.literal_eval(assignments[0].value) + need(type(pairs) is list and all(type(p) is int for p in pairs) + and pairs == PAIR_VECTOR, "source stage/pair vector") + # Verify that this literal is actually compared to the parent call pair. + comparison_found = False + for node in ast.walk(functions[0]): + if not isinstance(node, ast.Compare) or len(node.ops) != 1 or not isinstance(node.ops[0], ast.Eq): + continue + left, right = node.left, node.comparators[0] + if (isinstance(left, ast.Subscript) and isinstance(left.value, ast.Name) + and left.value.id == "call" and isinstance(left.slice, ast.Constant) + and left.slice.value == "pair" and isinstance(right, ast.Subscript) + and isinstance(right.value, ast.Name) and right.value.id == "expected_pairs" + and isinstance(right.slice, ast.Name) and right.slice.id == "s"): + comparison_found = True + need(comparison_found, "source pair assertion refers to actual parent calls") + return pairs + + +def recipe_from_pairs(pairs): + """Reconstruct the 19 logical events; then bind their full projection.""" + events = [{"kind": "local", "stage": 0, "pair": pairs[0], "reverse": False}] + for j in range(4): + events.append({"kind": "local", "stage": 2*j+1, + "pair": pairs[2*j+1], "reverse": True}) + if j < 3: + events.append({"kind": "bridge", "src": j+1, "dst": j, "coefficient": 1}) + events.append({"kind": "local", "stage": 2*j+2, + "pair": pairs[2*j+2], "reverse": False}) + if j < 3: + events.append({"kind": "bridge", "src": j+1, "dst": j, "coefficient": -1}) + for source in (2, 1, 0): + events.append({"kind": "bridge", "src": source, "dst": source+1, "coefficient": 1}) + events.append({"kind": "terminal"}) + return events + + +def projection(event): + if event["kind"] == "local": + return {"kind": "local", "stage": event["stage"]} + return dict(event) + + +def bind_recipe(recipe, pairs, witness): + need(len(recipe) == 19, "nineteen logical events") + locals_seen = [event for event in recipe if event["kind"] == "local"] + need(len(locals_seen) == 9 and all( + event == {"kind": "local", "stage": stage, "pair": pairs[stage], + "reverse": bool(stage % 2)} + for stage, event in enumerate(locals_seen)), "local stage/pair/orientation binding") + need(recipe[:2] == [ + {"kind": "local", "stage": 0, "pair": 0, "reverse": False}, + {"kind": "local", "stage": 1, "pair": 0, "reverse": True}], "initial local pair") + expected = [{key: value for key, value in event.items() if key != "ordinary"} + for event in witness["trajectory_after_B1"]] + need([projection(event) for event in recipe[2:]] == expected, + "all retained witness event identities") + need(sum(event["kind"] == "bridge" for event in recipe) == 9, + "nine ordinary bridges") + + +def replay(recipe, omit_canceling_bridge=False, classify_hole_as_completed=False): + """Track integer multiples of a free vector g, never its query values. + + A local call is used only when its full source is provably zero. In + the forward direction its target ordinary Y may be arbitrary. In the + backward direction both selected registers are zero and the ordinary + Y source must be zero. The literal conserved-map equations then imply + zero new selected fields without any condition on B_s g. + """ + x, y = [0] * 4, [1, 0, 0, 0] + histories = {0: 0} # supplied by the independently checked first pair + trace, calls = [], [] + completed, endpoint_types = None, None + skipped = False + for event in recipe[2:]: + kind = event["kind"] + if (omit_canceling_bridge and not skipped + and event == {"kind": "bridge", "src": 1, "dst": 0, "coefficient": -1}): + skipped = True + continue + if kind == "bridge": + source, target, coefficient = event["src"], event["dst"], event["coefficient"] + need(type(coefficient) is int and abs(coefficient) == 1, "signed unit bridge") + x[target] += coefficient * x[source] + y[source] -= coefficient * y[target] + elif kind == "local": + stage, pair = event["stage"], event["pair"] + source_coefficient = y[pair] if event["reverse"] else x[pair] + need(source_coefficient == 0, + "local source must vanish at stage " + str(stage)) + if event["reverse"]: + # a = 0 from the zero selected X_T; future/current queries + # are zero because the complete Y source is zero. + x[pair] -= y[pair] + else: + # f = 0; the forward source output w is also zero. + y[pair] += x[pair] + histories[stage] = 0 + calls.append({"stage": stage, "pair": pair, + "orientation": "backward" if event["reverse"] else "forward", + "source_coefficient": source_coefficient}) + else: + need(kind == "terminal", "tail event alphabet") + completed = list(x) + need(not any(completed), "all completed-X descendants vanish") + x, y = list(y), [-coefficient for coefficient in x] + endpoint_types = [["former_Y_hole", "completed_X_descendant"] for _ in range(4)] + if classify_hole_as_completed: + endpoint_types[0][0] = "completed_X_descendant" + need(all(coefficient == 0 + for pair in range(4) + for coefficient, tag in zip((x[pair], y[pair]), endpoint_types[pair]) + if tag == "completed_X_descendant"), + "former-Y hole cannot be counted as completed-X") + record = projection(event) + record["ordinary"] = [coefficient for pair in zip(x, y) for coefficient in pair] + trace.append(record) + need(sorted(histories) == [0, 2, 4, 6, 8] and not any(histories.values()), + "all five forward histories vanish") + need(completed == [0] * 4 and endpoint_types is not None, "terminal observed") + need(x == [1, 0, 0, 0] and y == [0] * 4, "sole final former-Y residue") + return {"trajectory_after_B1": trace, "local_zero_source_checks": calls, + "forward_histories": {str(stage): value for stage, value in sorted(histories.items())}, + "completed_X_coefficients": completed, + "final_coefficients": [coefficient for pair in zip(x, y) for coefficient in pair], + "final_type_classification": endpoint_types, + "zero_selected_cuts_from_B1": len(trace) + 1} + + +def verify(root): + """Return deterministic evidence; source-byte pins belong to the driver.""" + root = Path(root) + for source in SOURCE_PATHS: + need((root / source).is_file(), "missing tail source: " + source) + witness = json.loads((root / WITNESS).read_text()) + # Record the inherited endpoint contract expressly, rather than inferring + # the native type from the terminal field's current name. + note = (root / WITNESS_NOTE).read_text() + need("This is a former Y field with the phased native\noutput type." in note, + "retained former-Y endpoint interpretation") + pairs = source_pairs(root) + recipe = recipe_from_pairs(pairs) + bind_recipe(recipe, pairs, witness) + result = replay(recipe) + need(result["trajectory_after_B1"] == witness["trajectory_after_B1"], + "complete retained witness trajectory") + controls = [] + + def reject(name, action, expected): + try: + action() + except ValueError as error: + need(str(error) == expected, "wrong tail rejection: " + name) + controls.append({"mutation": name, "rejected_by": expected}) + else: + raise ValueError("tail mutation accepted: " + name) + + reject("omit the first canceling negative bridge", + lambda: replay(recipe, omit_canceling_bridge=True), + "local source must vanish at stage 3") + wrong_pair = deepcopy(recipe) + next(event for event in wrong_pair if event.get("stage") == 2)["pair"] = 1 + reject("bind F2 to pair 1", lambda: bind_recipe(wrong_pair, pairs, witness), + "local stage/pair/orientation binding") + reject("classify the former-Y hole as completed-X", + lambda: replay(recipe, classify_hole_as_completed=True), + "former-Y hole cannot be counted as completed-X") + # The F2 mutation has the SAME ordinary trace on this particular family: + # both candidate X sources are zero. Its rejection is a source-binding + # check, expressly not claimed as an algebraic separation. + need(replay(wrong_pair)["trajectory_after_B1"] == result["trajectory_after_B1"], + "wrong-F2 control is structural rather than a false trajectory claim") + return {"status": "PASS_RETAINED_QQ16_TAIL", "logical_event_count": len(recipe), + "post_B1_event_count": len(recipe) - 2, "stage_pairs": pairs, + "recipe": recipe, "arbitrary_residue": "formal free ordinary vector g", + "checks": result, "rejecting_controls": controls, + "source_boundary": { + "event_projection": WITNESS, + "pair_vector_assertion": PAIR_SOURCE + ":schedule_audit.expected_pairs", + "native_endpoint_interpretation": WITNESS_NOTE, + "compressed_parent_template_replayed": False, + "complete_native_word_or_type_validation": False}} + + +if __name__ == "__main__": + print(json.dumps(verify(Path(__file__).resolve().parents[2]), sort_keys=True, indent=2)) diff --git a/research/qq16-shear-transcript-floor/test_verify.py b/research/qq16-shear-transcript-floor/test_verify.py new file mode 100644 index 0000000000..c38d3ba807 --- /dev/null +++ b/research/qq16-shear-transcript-floor/test_verify.py @@ -0,0 +1,85 @@ +"""Integration controls for source-export replay. Apache-2.0; Codex assisted.""" + +import hashlib +import importlib.util +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] +SPEC = importlib.util.spec_from_file_location("qq16_shear_driver", HERE / "verify.py") +DRIVER = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(DRIVER) + + +def snapshot(root): + return {str(p.relative_to(root)): hashlib.sha256(p.read_bytes()).hexdigest() + for p in root.rglob("*") if p.is_file()} + + +class ReplayControls(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory(prefix="qq16-shear-control-") + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + self.package = self.root / HERE.relative_to(ROOT) + shutil.copytree(HERE, self.package, ignore=shutil.ignore_patterns("__pycache__")) + sources = json.loads((HERE / "SOURCES.json").read_text()) + for record in sources["files"]: + if record["usage"] != "input": + continue + target = self.root / record["path"] + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(ROOT / record["path"], target) + + def replay(self, *extra): + return subprocess.run([sys.executable, "-I", "-B", str(self.package / "verify.py"), + *extra], cwd=self.root, text=True, capture_output=True, + timeout=60) + + def test_export_passes_read_only(self): + before = snapshot(self.root) + result = self.replay() + self.assertEqual(result.returncode, 0, result.stderr) + self.assertIn("PASS_SCOPED_QQ16_SHEAR_TRANSCRIPT_FLOOR", result.stdout) + self.assertEqual(before, snapshot(self.root)) + + def test_external_source_drift_rejected(self): + source = self.root / "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json" + source.write_bytes(source.read_bytes() + b"\n") + result = self.replay() + self.assertNotEqual(result.returncode, 0) + self.assertIn("source SHA256 mismatch", result.stderr) + + def test_receipt_numeric_type_corruption_rejected(self): + receipt = self.package / "RESULT.json" + data = json.loads(receipt.read_text()) + data["schema_version"] = True # Python's ordinary dict equality misses 1 == True. + receipt.write_text(json.dumps(data)) + result = self.replay() + self.assertNotEqual(result.returncode, 0) + self.assertIn("RESULT.json differs", result.stderr) + + def test_emit_refuses_existing_file(self): + receipt = self.package / "RESULT.json" + before = receipt.read_bytes() + result = self.replay("--emit-result", str(receipt)) + self.assertNotEqual(result.returncode, 0) + self.assertEqual(before, receipt.read_bytes()) + self.assertIn("File exists", result.stderr) + + def test_duplicate_json_field_rejected(self): + bad = self.root / "duplicate.json" + bad.write_text('{"status":"PASS","status":"FAIL"}') + with self.assertRaisesRegex(ValueError, "duplicate JSON key"): + DRIVER.read_json(bad) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/research/qq16-shear-transcript-floor/verify.py b/research/qq16-shear-transcript-floor/verify.py new file mode 100644 index 0000000000..b00ec543a7 --- /dev/null +++ b/research/qq16-shear-transcript-floor/verify.py @@ -0,0 +1,154 @@ +#!/usr/bin/env python3 +"""Read-only, exact replay for the scoped QQ16 shear transcript floor. + +Apache-2.0. Prepared with substantial OpenAI Codex assistance. +No predecessor checker is imported, and no native supplier replay is claimed. +""" + +import argparse +from fractions import Fraction +import hashlib +import importlib.util +import json +from pathlib import Path, PurePosixPath +import sys + + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BASE = "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2" +MANIFEST = "research/community-frontier1094-audit/SELECTED-SOURCE.json" + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def unique_object(pairs): + result = {} + for key, value in pairs: + need(key not in result, "duplicate JSON key: " + key) + result[key] = value + return result + + +def read_json(path): + return json.loads(Path(path).read_text(encoding="utf-8"), + object_pairs_hook=unique_object) + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def canonical(value): + # Unlike Python dict equality, JSON equality distinguishes true from 1. + return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) + + +def compare_receipt(expected, actual): + need(canonical(expected) == canonical(actual), + "RESULT.json differs from deterministic replay") + + +def verify_sources(root=ROOT, package=HERE): + sources = read_json(package / "SOURCES.json") + declaration = read_json(package / "VERIFY.json") + need(sources["base_commit"] == BASE, "scientific base changed") + paths = [entry["path"] for entry in sources["files"]] + need(len(paths) == len(set(paths)), "duplicate source path") + inputs = {} + for entry in sources["files"]: + path = PurePosixPath(entry["path"]) + need(not path.is_absolute() and ".." not in path.parts and + str(path) == entry["path"], "noncanonical source path") + need(entry["usage"] in ("input", "provenance"), "unknown source usage") + if entry["usage"] == "provenance": + continue # The repository package launcher checks historical Git provenance. + raw = (root / path).read_bytes() + sha = hashlib.sha256(raw).hexdigest() + blob = hashlib.sha1(b"blob " + str(len(raw)).encode("ascii") + b"\0" + raw).hexdigest() + need(sha == entry["sha256"], "source SHA256 mismatch: " + str(path)) + need(blob == entry["git_blob"], "source Git blob mismatch: " + str(path)) + inputs[str(path)] = sha + need(sorted(declaration["inputs"]) == sorted(inputs), + "VERIFY.json inputs differ from pinned mathematical inputs") + selected = read_json(root / MANIFEST)["files"] + bound = [ + "research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json", + "research/direct-delivery504-global/inputs/data-base/work/complex-nine-native/DATA-PHASES.json", + "research/gauge44-slots-t16/construction/leaver/cgx_leaver.py", + "research/complex-sw4-frame8/vendor/pr635/research/complex-571-cold14-st2/code/hpe_audit_and_transport.py", + ] + for path in bound: + need(selected[path] == inputs[path], "selected-manifest binding failed: " + path) + return {"live_input_sha256": inputs, "selected_manifest_members_checked": bound, + "full_selected_inventory_replay": "NOT RUN"} + + +def module(name): + spec = importlib.util.spec_from_file_location("qq16_shear_" + name, HERE / (name + ".py")) + need(spec is not None and spec.loader is not None, "cannot load checker: " + name) + loaded = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = loaded + spec.loader.exec_module(loaded) + return loaded + + +def compute(): + sources = verify_sources() + moments = module("source_moments").run(ROOT) + algebra = module("algebra").verify() + tail = module("tail").verify(ROOT) + rank = Fraction(moments["trace_certificate"]["rank_lower_bound_per_owner"]) + floor = rank - 8 + need(floor == Fraction(77, 5), "joint selected capacity bound") + need(floor - 8 == Fraction(37, 5), "one-query deficit") + need(floor - 15 == Fraction(2, 5), "fifteen-coordinate deficit") + checked_files = ["PROOF.md", "SOURCES.json", "verify.py", "source_moments.py", + "algebra.py", "tail.py", "test_verify.py"] + return { + "schema_version": 1, + "status": "PASS_SCOPED_QQ16_SHEAR_TRANSCRIPT_FLOOR", + "base_commit": BASE, + "arithmetic": "exact integers and fractions; no assertion-dependent acceptance", + "package_sha256": {name: digest(HERE / name) for name in checked_files}, + "sources": sources, + "source_moments": moments, + "ordered_algebra_fixtures": algebra, + "retained_tail": tail, + "rank_consequences": { + "triple_query_rank_per_owner_at_least": str(rank), + "joint_selected_deficit_before_counted_record_per_owner_at_least": str(floor), + "one_eight_coordinate_record_deficit_per_owner_at_least": str(floor - 8), + "fifteen_coordinate_record_deficit_per_owner_at_least": str(floor - 15), + "necessary_uniform_scalar_records_per_owner": 16, + "integer_rounding": "ceil(77*N/5)-d for total record rank d", + "sufficiency": "NOT CLAIMED", + }, + "scope": "Written conditional regular-cover proof plus finite source and algebra checks; no complete native packet, supplier, tariff or kappa claim", + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--emit-result", type=Path, metavar="NEW_PATH", + help="explicitly write a new receipt; never overwrite") + args = parser.parse_args() + result = compute() + if args.emit_result: + with args.emit_result.open("x", encoding="utf-8") as stream: + stream.write(json.dumps(result, sort_keys=True, indent=2) + "\n") + print("WROTE_SCOPED_QQ16_RECEIPT", args.emit_result) + else: + compare_receipt(read_json(HERE / "RESULT.json"), result) + print(result["status"]) + + +if __name__ == "__main__": + try: + main() + except (ValueError, OSError, KeyError, TypeError) as error: + print("FAIL_QQ16_SHEAR:", error, file=sys.stderr) + raise SystemExit(1) from error From cee7efecb71956e65891a87724936324bc0a66ea Mon Sep 17 00:00:00 2001 From: Jason Date: Thu, 15 Oct 2026 01:04:34 -0600 Subject: [PATCH 2/3] Credit concurrent dense-query proof and refresh publication evidence --- research/qq16-shear-transcript-floor/PROOF.md | 9 +++-- .../qq16-shear-transcript-floor/README.md | 19 ++++++++-- .../qq16-shear-transcript-floor/RESULT.json | 2 +- .../qq16-shear-transcript-floor/TASK.json | 36 +++++++++++++------ 4 files changed, 51 insertions(+), 15 deletions(-) diff --git a/research/qq16-shear-transcript-floor/PROOF.md b/research/qq16-shear-transcript-floor/PROOF.md index 0b22f2cd81..70f825fedd 100644 --- a/research/qq16-shear-transcript-floor/PROOF.md +++ b/research/qq16-shear-transcript-floor/PROOF.md @@ -203,7 +203,12 @@ background input for the stated linear interface. The following fourth-moment argument and numerical certificate are reused, with credit, from [commdata2338's PR #2189](https://github.com/CrocSwap/integer-mult-bounds/pull/2189). That predecessor applies its capacity bound to the unsheared first pair. -The changed-shear implication above is the contribution here. +The quantified changed-shear transcript implication above is the +contribution here. Concurrent @starship-s PR #2368 independently proves +the overlapping B0-read case using a graph intersection and the second +moment. Its kernel is equivalent on that restriction. This package extends +the count to arbitrary rank-d records and applies the credited fourth +moment; it does not claim the first obstruction for the B0-read case. Here is the complete spectral implication of the finite source checks. Let `E_s = B_s* B_s/48` and `H = E_0+E_1+E_2`, where * denotes real @@ -306,6 +311,6 @@ rejected. The local maps, selected sections, and retained tail are credited to Ali Romman's QQ16 package. The triple-query moment/rank input is credited to its pinned predecessors. This proof's contribution is the -changed-shear invisible family and the resulting transcript floor, +arbitrary-record transcript floor for an independently derived changed-shear family, including dense reads used for paired selected updates. It does not claim native implementability, a favorable cost, or a changed frontier. diff --git a/research/qq16-shear-transcript-floor/README.md b/research/qq16-shear-transcript-floor/README.md index 3c531df0bd..4eea93d935 100644 --- a/research/qq16-shear-transcript-floor/README.md +++ b/research/qq16-shear-transcript-floor/README.md @@ -14,8 +14,9 @@ Each such array has one scalar per owner. Fifteen leave at least the necessary total rank is `ceil(77|G|/5)`, not `16|G|`. Sixteen arrays is a necessary floor, not a sufficiency or cost claim. -The new result is the ordered shear-kernel construction and its full-tail -implication. The fourth-moment rank certificate is credited to +The contribution is a quantitative transcript floor for the sheared pair, +with an ordered kernel construction and its full-tail implication. The +fourth-moment rank certificate is credited to [commdata2338's PR #2189](https://github.com/CrocSwap/integer-mult-bounds/pull/2189), which treated the unsheared first pair. Its finite premises are recalculated here by a separately implemented, exact text-source checker. The proof is @@ -178,6 +179,20 @@ pre-F2 selected intervention. It grants final selected values but not a free B1 cut. Its family and observation contract differ from this changed shear result; neither result supersedes the other. +Publication was delayed by shell network restrictions. During that delay, +@starship-s published [PR #2368](https://github.com/CrocSwap/integer-mult-bounds/pull/2368), +head `e5d4d78dcfdd55d323fcbc60df477b9f25c7abff`, with an independently +derived graph-intersection obstruction for the shear plus the initial B0 +record. Its proof also permits an arbitrary fixed invertible pairing. We +read that proof during the publication refresh and credit its overlapping +changed-pair kernel and tail argument; no first-closure claim is made here. +The original local package was committed at 06:08 UTC before that reading. +This package adds the arbitrary rank-d transcript bound, the stronger +`ceil(37N/5)` one-query defect and sixteen-array floor using PR #2189's +fourth moment, and a separate exact text-source moment implementation. +PR #2354's sharp 66-port threshold concerns its specified common-axis family +and coordinate observations; it does not settle this transcript bound. + ## Open next questions 1. **Which changed first pair evades this kernel?** Specify one ordinary diff --git a/research/qq16-shear-transcript-floor/RESULT.json b/research/qq16-shear-transcript-floor/RESULT.json index 0118c81066..f47ede8755 100644 --- a/research/qq16-shear-transcript-floor/RESULT.json +++ b/research/qq16-shear-transcript-floor/RESULT.json @@ -52,7 +52,7 @@ "status": "PASS_ORDERED_SHEAR_ALGEBRA" }, "package_sha256": { - "PROOF.md": "d2faaf7a41ab41e8b5735b50b686431294a0c8ebca2ae9424d034a6c76fa479c", + "PROOF.md": "0217cc26e180201c567261349436b39ac6b887915022d0453a309c22edd30857", "SOURCES.json": "8a0bd0537d5e2976452b5013db402fdb217dcec68d67ff64d801fd5e1e12d87d", "algebra.py": "262a5d7f554a13c993e07886693dfa22641e64e59738536125e809cfcc050bda", "source_moments.py": "21525b2ceee38ae1f073dc2e6dc74f8b2e8da2cc76202d107f601c3f109c21a6", diff --git a/research/qq16-shear-transcript-floor/TASK.json b/research/qq16-shear-transcript-floor/TASK.json index 91e9d8d35d..0b9649cfd1 100644 --- a/research/qq16-shear-transcript-floor/TASK.json +++ b/research/qq16-shear-transcript-floor/TASK.json @@ -59,18 +59,24 @@ "initial_nonce": "d7135726fa46715b28d9967be33fab98", "initial_track": "bit-mechanisms", "override": "Revision 4 permits a live central handoff matching available algebra/verification expertise. Taking PR2326's explicit dense-observation full-kernel question, without rerolling.", - "source_export": "Exact main Git commit and all tree hashes reconstructed from GitHub API; only relevant text blobs hydrated because shell networking and binary connector downloads are unavailable." + "source_export": "Research was completed in an exact bounded text export while shell networking was unavailable. Publication uses a valid partial clone of the same canonical main commit, with all declared text inputs hydrated." }, "coordination": { - "status": "LOCAL-ONLY: no public claim posted", - "utc": "2026-10-15T06:04:46.313Z", - "reason": "Authorized Discussion participation is unavailable through the installed connector, and shell DNS remains disabled.", + "status": "PUBLICATION PREPARED: no advance public claim posted", + "utc": "2026-10-15T07:00:41.375119+00:00", + "reason": "The user enabled automatic approval review, restoring approved shell network access. A writable fork now exists; the completed finding will be posted to the existing shear Discussion after its public artifact is pushed.", "open_pr_snapshot": { - "fetched_at": "2026-10-15T06:04:46.313Z", - "records": 559, + "fetched_at": "2026-10-15T06:59:02.814348+00:00", + "records": 584, "complete_pagination": true }, - "discussion_coverage": "Public web onboarding/handoff/active threads checked, but newer discussion pages are unavailable or stale; full live discussion pagination not available.", + "discussion_coverage": { + "fetched_at": "2026-10-15T07:00:41.329892+00:00", + "records": 1112, + "complete_pagination": true, + "warnings": [], + "canonical_thread": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2205" + }, "nearest_prs": [ { "number": 2326, @@ -121,9 +127,19 @@ "number": 2346, "head": "653520d7f18f686ea3a274b4963981f5be563477", "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2346" + }, + { + "number": 2368, + "head": "e5d4d78dcfdd55d323fcbc60df477b9f25c7abff", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2368" + }, + { + "number": 2354, + "head": "308ebc7405303bb7ed91b012bb705949c6091a16", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2354" } ], - "concurrent_work": "PR2346 discovered in final refresh; pinned proof read. It forbids pre-F2 selected interventions and tests 64 specified initial records with final-only selected observations. Our changed-shear family vanishes already at B1, whose selected values are granted free; the results do not supersede each other." + "concurrent_work": "PR2346 discovered in final refresh; pinned proof read. It forbids pre-F2 selected interventions and tests 64 specified initial records with final-only selected observations. Our changed-shear family vanishes already at B1, whose selected values are granted free; the results do not supersede each other. Publication refresh found PR2368. Its pinned written proof was read; it independently derives an equivalent shear kernel for the retained B0-read case, also allowing invertible pairings. This package was locally committed at 06:08 UTC before that reading. Added value is arbitrary rank-d records, the sharper fourth-moment defect and sixteen-array floor, plus separate text-source moment verification. No first-closure claim. PR2354 concerns the sharp66-port threshold of a specified common-axis family." }, "verification_limitations": [ "The prescribed research_baseline.py was attempted but cannot check the complete selected package inventory in the bounded source export. The selected record and its certificate/review were read; no baseline pass or supplier cold replay is claimed." @@ -143,10 +159,10 @@ } ], "upstream_checkpoint": { - "utc": "2026-10-15T06:04:46.313Z", + "utc": "2026-10-15T06:58:08Z", "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", "priority_revision": 4, - "change": "Main unchanged; all original relevant PR heads unchanged. No source or frontier migration." + "change": "Canonical main unchanged at publication. Complete refreshed PR and Discussion coverage recorded above. PR2368 overlap read and credited; original relevant source heads unchanged." }, "verification": { "environment": "Linux x86_64, CPython 3.12.3, standard library only", From 34d86fb6c128e87ec3f2841c560869c11a8e0764 Mon Sep 17 00:00:00 2001 From: Jason Date: Thu, 15 Oct 2026 01:06:24 -0600 Subject: [PATCH 3/3] Record the public QQ16 finding and retrievable artifact --- research/qq16-shear-transcript-floor/TASK.json | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/research/qq16-shear-transcript-floor/TASK.json b/research/qq16-shear-transcript-floor/TASK.json index 0b9649cfd1..78b5fe962f 100644 --- a/research/qq16-shear-transcript-floor/TASK.json +++ b/research/qq16-shear-transcript-floor/TASK.json @@ -62,9 +62,11 @@ "source_export": "Research was completed in an exact bounded text export while shell networking was unavailable. Publication uses a valid partial clone of the same canonical main commit, with all declared text inputs hydrated." }, "coordination": { - "status": "PUBLICATION PREPARED: no advance public claim posted", - "utc": "2026-10-15T07:00:41.375119+00:00", - "reason": "The user enabled automatic approval review, restoring approved shell network access. A writable fork now exists; the completed finding will be posted to the existing shear Discussion after its public artifact is pushed.", + "status": "FINDING/DONE posted; public artifact available; no advance public claim was posted", + "utc": "2026-10-15T07:05:00Z", + "reason": "The user enabled automatic approval review, restoring approved shell network access, and explicitly authorized fork, push and PR creation. The completed finding is posted in the existing shear Discussion.", + "finding_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2205#discussioncomment-18943100", + "public_artifact": "https://github.com/jgilfoil/integer-mult-bounds/tree/cee7efecb71956e65891a87724936324bc0a66ea/research/qq16-shear-transcript-floor", "open_pr_snapshot": { "fetched_at": "2026-10-15T06:59:02.814348+00:00", "records": 584, @@ -159,7 +161,7 @@ } ], "upstream_checkpoint": { - "utc": "2026-10-15T06:58:08Z", + "utc": "2026-10-15T07:05:00Z", "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", "priority_revision": 4, "change": "Canonical main unchanged at publication. Complete refreshed PR and Discussion coverage recorded above. PR2368 overlap read and credited; original relevant source heads unchanged."