From 33997335997f1eef37ee4f455244cd289ba07b06 Mon Sep 17 00:00:00 2001 From: Clear Insight Date: Sun, 18 Oct 2026 17:45:25 +1100 Subject: [PATCH 1/8] Audit the P104 kernel against its actual required X0 consumer Bind the exact event-1099 admission failure and a legal all-B9 paired family with a required signed X0 output beyond the five readouts. Preserve the physical caller and complete-cost obligations. Clear1nsight, with substantial OpenAI assistance from a root agent and three concurrent specialist agents. --- research/p104-kernel-consumer/COSTS.md | 148 + research/p104-kernel-consumer/PROOF.md | 288 ++ research/p104-kernel-consumer/README.md | 169 + research/p104-kernel-consumer/RECEIPT.json | 4040 +++++++++++++++++++ research/p104-kernel-consumer/SOURCES.json | 146 + research/p104-kernel-consumer/TASK.json | 266 ++ research/p104-kernel-consumer/VERIFY.json | 51 + research/p104-kernel-consumer/literal.py | 344 ++ research/p104-kernel-consumer/observable.py | 355 ++ research/p104-kernel-consumer/primary.py | 210 + research/p104-kernel-consumer/verify.py | 199 + 11 files changed, 6216 insertions(+) create mode 100644 research/p104-kernel-consumer/COSTS.md create mode 100644 research/p104-kernel-consumer/PROOF.md create mode 100644 research/p104-kernel-consumer/README.md create mode 100644 research/p104-kernel-consumer/RECEIPT.json create mode 100644 research/p104-kernel-consumer/SOURCES.json create mode 100644 research/p104-kernel-consumer/TASK.json create mode 100644 research/p104-kernel-consumer/VERIFY.json create mode 100644 research/p104-kernel-consumer/literal.py create mode 100644 research/p104-kernel-consumer/observable.py create mode 100644 research/p104-kernel-consumer/primary.py create mode 100644 research/p104-kernel-consumer/verify.py diff --git a/research/p104-kernel-consumer/COSTS.md b/research/p104-kernel-consumer/COSTS.md new file mode 100644 index 0000000000..1583f5861d --- /dev/null +++ b/research/p104-kernel-consumer/COSTS.md @@ -0,0 +1,148 @@ +# Local cost and the unfilled physical allowance + +These are constructive counts for the **actual eighth collector and named +consumer operations** in the frozen source word. They do not price the whole +word, produce the required input values, or admit a recursive supplier. +[PROOF.md](PROOF.md) distinguishes the original rejected coefficient point +from the all-$B_9$ admitted family. The complete input and predecessor pins +are in [SOURCES.json](SOURCES.json). + +## 1. Eighth collector: events 2114 to 2128 + +Let $N=512$, +$O_0=(257,129,65,33,16,9,5,2)$, and $P_0=(400)$. +The source initializes owned scratch C in $O_0$, gathers D4 through D0, +transports C to $P_0$, adds C into Q0, transports C back to $O_0$, +ungathers D0 through D4, and erases C at zero. The ten D reads leave their +sources unchanged. Q0 is the mutable query. + +| Source or component operation | Count | +|---|---:| +| D gathers / ungathers | 5 / 5 full-bank unit ADDs | +| Q0 readout | 1 full-bank unit ADD | +| Native calls | 2, each rank 7 | +| Native rank mass | 14 | +| Native pair applications | $2\cdot7\cdot256=3584$ | +| Native component ADD/SUB evaluations | $8\cdot3584=28672$ | +| Field real ADD/SUB evaluations | $11\cdot1024=11264$ | +| Component ADD/SUB subtotal | 39,936 | +| Native signed-floor half evaluations | $4\cdot3584=14336$ | +| Native Gaussian quarter turns | 3,584 | +| Actual monomial wrappers | 4 | +| Owned Gaussian scratch bank / zero erasure | 1 / 1 | + +The native-only child tariff is $2\cdot7^s$ if a rank-r child costs $r^s$. +Wrapper implementation, physical access, zero supply and control are +additional. The component subtotal is not a complete strict-register or +physical tape invoice. A literal native pair can involve nonexact individual +floor halves while its completed output agrees exactly with the ideal map +on the admitted Newton module. + +The archive specifies separate forward and reverse recipes. The actual four +wrappers, in execution order, have: + +| Event / wrapper | Permutation cycles | Ordinary Gaussian payload SWAPs | +|---|---:|---:| +| 2120 / right | 64 | 448 | +| 2120 / left | 64 | 448 | +| 2122 / right | 128 | 384 | +| 2122 / left | 48 | 464 | +| **Total** | **304** | **1,744** | + +A length-l cycle needs l−1 ordinary two-word swaps, so the total is +$4N-304=1744$. This is not the different zero-scratch cycle schedule. +Each wrapper has 128 input-address entries of each phase $1,i,-1,-i$; +the aggregate has 512 of each. Phases are evaluated on the input address +using the source's strict-upper-triangle quadratic convention. The +histogram is an inventory, not an operator-identity test. The actual reverse +wrappers cannot be replaced in this invoice by an assumed paired inverse +of the forward wrappers. + +## 2. Named consumer updates and restoration + +| Event | Actual source operation | Frame | Local real arithmetic | +|---|---|---|---:| +| 3025 | $G0\mathrel{+}=Q0$ | $P_0$ | 1,024 ADDs | +| 4104 | $G0\mathrel{-}=Q0$ | $F$ | 1,024 SUBs | +| 4241 | $Q0\mathrel{-}=Y90/4$ | $F$ | 1,024 SUBs, plus the division/restoration below | + +Here $F=(256,128,64,32,16,8,4,2,1)$. +These are three separated chronological operations, not an adjacent +self-contained return program. The source still needs all intervening +frame paths and required reads. In particular, the X0 delivery at event +3278, X0's sign and final chart, and all other affected outputs are +additional to this table. + +The admitted family proves $Y90\in4B_9$ at event 4241. If the physical +contract permits temporarily mutating that donor, each real component can +be divided exactly twice, used in the signed ADD, and doubled twice to +restore it. For the bank this adds **2,048 exact halves and 2,048 restoring +doublings**. A strictly read-only donor needs a separately supplied and +priced divided-copy/cleanup implementation. Divisibility alone grants no +ownership permission. + +Together, the collector and these three scalar operations have a +**43,008 component ADD/SUB subtotal**, plus the listed native floor halves, +quarter turns, wrappers, exact donor halves and restoration doublings. +No allocation, control, routing or bit-complexity tariff is hidden in that +subtotal. + +## 3. The existing X0 endpoint adapter is reused, not charged twice + +X0 is among the 93 banks omitted from PR3446's projection. PR3469 already +binds its initial frame $(386)$ to final frame F with a rank-eight +adapter. It is one of the 52 rank-eight entries in the existing profile +$52\cdot8^s+41\cdot9^s$, whose rank mass is 785. + +When assembling a projected normalized completion, that X0 adapter must be +included **once** as part of the credited 93-bank boundary. It is not an +additional rank-eight cost on top of that profile. When interpreting the +original full word, its actual X0 transports already occur in the source; +the endpoint adapter is not appended a second time. + +For $0\leq s\leq1$, the existing tariff is sharp only in its stated separate-bank, +nine-axis native model with free affine quadratic-phase monomials. +It does not price common-frame scalar acquisition, the monomial +implementation, ownership, or routing. Nor does it authorize replacing +the original interleaved transports by a single terminal adapter across +arbitrary intervening ADDs. + +## 4. Complete allowance and family decision + +| Obligation | Status in this result | +|---|---| +| Exact source-event coefficients and compatible recorded frames | Bound and checked | +| Eighth collector's numerical dirty compensation and C zero exit | Proved under the inherited native/module premises | +| Admitted all-$B_9$ family and actual X0 observation | Proved by the scalar-coefficient induction and phase-correct charts | +| Local collector and three-update arithmetic | Constructive component counts above | +| X0's omitted endpoint chart adapter | Credited PR3469 binding; counted once | +| A physical producer of the 52 PR3467 coefficient meanings | Unknown | +| Acquisition of the D/Y sources in the required frames | Additional; no complete physical allowance supplied | +| Physical permissions, temporary ownership, addresses and routing | Unknown | +| Complete scalar/native lowering, zero supply, controller and bit costs | Unknown | +| Actual caller component heights and finite storage widths | Unknown; the exact reference uses unbounded integers | +| Complete recursive supplier budget and outer transfer | Unknown | + +The fourfold family lies in the strong entrance $S=(4B_9)^{52}$. +Its required X0 output does not factor through the five first-collector +readouts, but it establishes no benefit from the larger quotient $L/S$. +No positive budget is inferred from a module index or from ignoring +additional required outputs. + +The inherited [PR #3423](https://github.com/CrocSwap/integer-mult-bounds/pull/3423) +599/584 stop remains conditional on its original fixed profile and coverage. +This package changes neither those hypotheses nor the selected frontier. +An optimistic budget for a different caller does not supply the missing +allowance for this coefficient interface. + +**Decision: finish this interface audit and stop dependent construction.** +A further construction needs an actual producer/consumer contract and a +complete allowance covering the missing rows. Unknown costs are not zero. + +Credit ywz65/PR2586 for the word/native recipes; Arham Tahir/PR2665 for +retention; the PR3025/PR3382 signed-floor and Newton lineage for component +semantics; PR3554 for the owned-donor quarter lowering and assigned +handoffs; Hiroki Kumazaki/PR3446 for the port projection; and Nick +Petalas/PR3416/#3462/#3469 for exact covariance, normalized completion +and the existing endpoint adapter. These remain scoped predecessor +results, not newly admitted physical suppliers. diff --git a/research/p104-kernel-consumer/PROOF.md b/research/p104-kernel-consumer/PROOF.md new file mode 100644 index 0000000000..ee61052775 --- /dev/null +++ b/research/p104-kernel-consumer/PROOF.md @@ -0,0 +1,288 @@ +# A required consumer of the five-readout kernel + +Clear1nsight, with substantial OpenAI assistance. This is a source-bound +answer to the two conditional handoffs in [PR #3554](https://github.com/CrocSwap/integer-mult-bounds/pull/3554). +It establishes an exact admission failure, an admitted family with a required +observable, and a specific physical interface mismatch. It does not supply an +actual paid caller, an advantage from the enlarged entrance, or a new bound. + +## 1. Frozen contract and inherited premises + +Work over $R=\mathbb Z[i]$, put $\pi=1+i$, and define + +$$ +E_9=\begin{pmatrix}1&0\\1&\pi\end{pmatrix}^{\otimes9}, +\qquad B_9=E_9R^{512}. +$$ + +All events below are zero-based indices in the unchanged 5,398-event PR #2586 +WORD. Its bytes and NATIVE recipes, executable dependencies, and credited +proofs are authenticated in [SOURCES.json](SOURCES.json). They are already +retained on the pinned canonical main commit +`20ecf2891d80b5acf18d980b2164fb44ea7faa90`. + +Write $A_H$ for the source's actual ideal map from the empty frame to frame +$H$. Precisely, this is the physical chart +$\Delta_H=\overline{\Gamma_H}=\Gamma_H^{-T}$, with the endpoint conventions +of the retained PR #3416 proof. It is not the bare frame matrix. The +`observable.py` receipt also calls this chart $J_H$. Set + +$$ +\begin{aligned} +F&=[256,128,64,32,16,8,4,2,1],\\ +O&=[256,136,64,40,16,4,2,1],\\ +O_0&=[257,129,65,33,16,9,5,2],\qquad P_0=[400]. +\end{aligned} +$$ + +The proof uses two explicitly inherited results. PR #3382 proves that the +actual affine/quadratic Gaussian monomial alphabet, complete coordinate +native stages, and their inverses preserve $B_9$. A completed literal signed-floor pair +equals its ideal pair on that domain. PR #3416 binds all 2,070 native +occurrences to the phase-correct identity +$U=A_{\mathrm{new}}A_{\mathrm{old}}^{-1}$. Their proofs are retained inputs; +this package does not rerun their complete operator certificates. The new +literal controls separately execute the actual signed-floor arithmetic on +the two specified fixtures. + +For the five first-collector source groups $G_j$, define the mathematical +readouts + +$$ +\rho_5(y)_j=\frac14\sum_{Y\in G_j}y_Y. +$$ + +The groups have sizes $3,7,7,11,24$ and partition the 52 sources of the +PR #3467 producer cone. Both Y91 and Y90 belong to its D27 group. The strong +raw-source domain is $S=(4B_9)^{52}$, inside that cone's correlated entrance +$L$. These are source domains, not claims that every element of $L$ executes +the omitted events of the whole word. + +## 2. The original witness fails at an actual omitted read + +PR #3467's coefficient slot 44 is the D27 zero-gap read at event 1817, with +next read 1819 and no intervening D27 transport. Its read frame is $O$. +The exact encoder $K$ sends $a_{44}=\delta_{15}$, all other coefficients zero, +to the raw sources + +$$ +Y91=p,\qquad Y90=-p,\qquad p=A_O^{-1}E_9\delta_{15}, +$$ + +with every other selected Y zero. Since $\pi^4=-4$, the field +$E_9\delta_{15}$ equals $-4$ on the 32 addresses containing mask 15, and is +zero elsewhere. The authenticated K encoder and decoder check the complete +coefficient meaning and its inverse. + +The independent literal implementation reconstructs the same $p$ without +importing that codec or its Gaussian implementation. It starts from this +profile and reverses Y91's actual native history at events +195, 992, 1133, 1238, 1397, and 1598. The two complete 512-entry arrays agree. +The canonical JSON digest of $p$ is + +`2d5e9e5b5d2ef3cbee879749e9f67b3c78c20eef2edf8f0b7737a0a65230503b`. + +It has 256 nonzero Gaussian coordinates, real/imaginary component height one, +belongs to $B_9$, and does not belong to $4B_9$. The latter is checked by exact +$E_9^{-1}$ decoding, not by a floating-point or Euclidean size test. + +Now place $p,-p$ in the two actual initial Y banks and zero in every other +initial public bank. The literal whole-word interpreter completes all 1,099 +events before event 1099, with no completed event output outside $B_9$. +Event 1099 is exactly + +```text +["add", "D1", "Y90", "1/4", [381,241,2]] +``` + +At address 10, the physical donor Y90 is $-2+0i$. Its required real increment +is $-1/2$, which is not on the specified Gaussian integer grid. Thus this +particular element admitted by the restricted producer cone does not satisfy +the full word's exact fractional-ADD contract. The verifier requires this +exact first failure and its preceding successful boundary. + +This is stronger than merely observing $p\notin4B_9$, which would only fail +a sufficient product-domain condition. It is still a statement about this +input, this grid, and this exact-literal contract. It does not classify all +correlated full-prefix inputs, rule out a proved rounded-error contract, or +establish a least sufficient rescaling. Later formulas for the unscaled pair +are ideal row identities, not a claim to have executed past its failure. + +## 3. An actual required observable exists + +The D27 transient displayed by PR #3554 has no direct observer between events +1817 and 1819. Event 1818 only transports Y91. All ADDs reading D27 as a source +occur at events 916, 2030, and 2034. The relevant actual consumer is instead +the asymmetric Y90 read into D1 and the later Q0/G0/X0 path. + +Under the inherited phase-correct covariance, write a bank at frame $H$ as +$A_H$ times its normalised value. Native transports then preserve that value. +Propagating the pair $(p,-p)$ formally gives the following selected cuts. +Other terms are zero on this pair direction. + +| Event | Actual operation or frame change | Normalised pair contribution | +|---:|---|---| +| 1099 | D1 += Y90/4, frame [381,241,2] | D1 becomes $-p/4$ | +| 2118 | C += D1, frame $O_0$ | C gathers $-p/4$ | +| 2120 | C from $O_0$ to $P_0$, rank seven | Same normalised value | +| 2121 | Q0 += C, frame $P_0$ | Q0 becomes $-p/4$ | +| 2122 | C from $P_0$ to $O_0$, rank seven | Return transport | +| 2128 | Erase C | C is zero after all ungather ADDs | +| 2166 | D1 -= Y90/4, frame $F$ | D1 contribution returns to zero | +| 3025 | G0 += Q0, frame $P_0$ | G0 becomes $-p/4$ | +| 3276 | G0 from $P_0$ to [400,85], rank one | Frame preparation | +| 3278 | X0 -= 2 G0, frame [400,85] | X0 becomes $+p/2$ at this cut | +| 4104 | G0 -= Q0, frame $F$ | G0 contribution returns to zero | +| 4241 | Q0 -= Y90/4, frame $F$ | Q0 contribution returns to zero | +| 5086 | Negate X0, frame [258,130,64,32,16,8,4,1] | X0 becomes $-p/2$ | +| 5190 | X0 to $F$, rank one | Final physical value $-A_Fp/2$ | + +The late sign matters. `observable.py` implements a separate reverse adjoint +of the full word, including every sign, and checks all 104 entries of the +complete X0 Y row against PR #3462's existing $CA/2$ certificate. That +certificate has + +$$ +A_{\bullet,91}-A_{\bullet,90}=(-1,1,0,0,1,-1,1,1)^T, +\qquad C_{X0,\bullet}=(1,0,0,0,0,0,0,0), +$$ + +where $A$ and $C$ in this display are the certificate's query matrices, not +the physical charts $A_H$. The response is therefore $-1/2$ on the pair. +An explicit control omitting event 5086 gives $+1/2$ and fails the claimed +signed endpoint. This check corrected a preliminary scalar triage omission +before publication; it is not a correction to PR #3554. + +The same reverse computation proves that the complete normalised final rows +of D1, Q0, and G0 equal their respective initial identity rows, and that the +eighth collector's C row is zero at erasure. These are algebraic statements +for arbitrary formal initial values under the covariance premise. Their +actual returned frames are those of the word. They do not establish literal +admission for arbitrary initial dirt, or return every bank to its empty frame. + +X0 is an existing required output of the whole word, omitted from PR #3446's +projection. Its projection-to-full frame gap is [386] to $F$. PR #3469 already +supplies the corresponding rank-eight native-only adapter. This package +authenticates that adapter and the one X0 row; it does not recompute the +rank-eight completion theorem or the full 675-port recipient closure. + +## 4. All-$B_9$ admitted family and nonfactorisation + +**Theorem.** Assume the inherited native preservation and phase-correct +covariance above. For every $u\in B_9$, initialise +$Y91=4u$, $Y90=-4u$, and every other public bank to zero. The entire original +word executes exactly on the fixed Gaussian integer grid. Every completed +event state belongs to $B_9$, all eight private-C lifetimes erase at zero, and + +$$ +\rho_5(y)=0,\qquad X0_{\mathrm{final}}=-2A_Fu. +$$ + +**Proof.** Run one scalar symbol through all 5,398 actual events, beginning +with normalised Y91 coefficient $1$, Y90 coefficient $-1$, and all others +zero. Apply every ADD coefficient and sign exactly as a rational number; +native transports only update the authenticated frame. `primary.py` checks +that both every stored bank coefficient and every individual ADD product +belong to $\tfrac14\mathbb Z$. It also checks the full chronological frame +constraints, final frames, and eight zero erasures. The exhaustive counts +are + +| Denominator | Updated bank coefficient after an event | Individual ADD product | +|---:|---:|---:| +| 1 | 4,928 | 3,006 | +| 2 | 390 | 52 | +| 4 | 72 | 46 | + +The first column of counts covers every event except the eight erasures; +the second covers all 3,104 ADDs. All 208 signs, 2,070 transports, eight +allocations, and eight erasures participate in this finite certificate. + +After substituting the input symbol $4u$, every stored normalised coefficient +and every individual ADD product is an integer multiple of $u$. Inductively, +at its actual frame it therefore belongs to $B_9$. For an ADD, the common +frame makes both the increment and updated value Gaussian integral in that +module. For a native, the credited monomials preserve $B_9$, the literal +signed-floor pairs agree with the ideal pairs, and each complete coordinate +stage preserves $B_9$. Disjoint pairs within that stage read disjoint inputs; +no claim that updating only one pair preserves the whole-array module is needed. +The covariance identity supplies the next normalised state. Signs and owned +zero lifetimes preserve the induction. The checked final scalar coefficient +of X0 is $-1/2$, giving $-2A_Fu$. + +Internal floor-halves need not be exact divisions individually. The preserved +objects here are the completed pairs and their states; equality of those +pairs follows from the inherited Gaussian parity lemma. No stronger claim +about the pair's temporary arithmetic is needed. Finally, Y91 and Y90 are +in the same source group and cancel in all five sums. This proves the theorem. + +For $u\ne0$, invertibility of $A_F$ gives $-2A_Fu\ne0$. Comparing with the +all-zero input shows that **no function of $\rho_5$ alone**, even a nonlinear +one, can supply this required X0 endpoint on the admitted strong domain. +The comparison fixes every other initial public bank at zero, so it also +rules out recovering this endpoint from $\rho_5$ plus those fixed values. + +For an independent finite positive control, the literal interpreter uses +$u=p$. It executes all 5,398 events, binds all 2,070 native occurrences, +compares 102,656 completed signed-floor/ideal pairs on 223 active native +calls, and evaluates the other 1,847 native calls by their exact all-zero +action. It checks all 3,104 ADDs, 208 signs, eight erasures, and 358 final +frames. Q0 finishes at zero. The 52 X banks and the two retained Y sources +are the 54 nonzero final banks. + +The integrated verifier compares all 512 independently prepared entries of +$p$, all 9,216 Gaussian coordinates of 18 Q0/G0/X0 checkpoints with their +frames, and both 512-entry returned Y arrays against a separate oracle. +That oracle uses the authenticated K encoder, one forward scalar symbol, +and short actual chart paths rather than the literal interpreter's full bank +histories. Complete arrays are compared before their hashes are recorded. +The reverse X0 adjoint is a third, separately written check. + +This family lies entirely in $S=(4B_9)^{52}$ and has zero relative class in +$L/S$. It therefore demonstrates no benefit from the enlarged entrance. +Nor does it contradict PR #3554, whose complete caller returns all 52 +coefficient banks. Those retained outputs still carry information for later +computation. The obstruction is to access restricted to the five readouts. + +## 5. Why the unchanged word is not the coefficient supplier + +The actual word contains exactly 728 writes targeting Y banks. Every one is +a native transport. There is no ADD, sign, allocation, or cross-bank write +into a Y. Thus each in-word Y state depends only on its own initial raw Y. + +Under a direct one-physical-bank-per-independent-coefficient identification, +even after relabelling, one nonzero initial coefficient can affect only one +Y bank through those operations. But the exact K column in Section 2 has +two nonzero Y outputs. The unchanged word therefore does not materialise K +under that identification. This proves a specific source-interface mismatch, +not a universal impossibility of a caller. + +One may define virtual coefficients $a=K^{-1}y$ algebraically. PR #3554's +strict gather still requires access to those actual coefficient values, or +a separately implemented and priced fused read. Renaming raw Y values does +not provide that access. An external coupled initializer is also possible, +with its stated ownership, common-frame reads, restoration, and complete bill. + +There is a second concrete boundary. All 104 actual initial Y frames are +empty, while all 104 actual final Y frames have dimension eight. PR #3554 +returns its 52 coefficient fields in empty frames. An adapter or a changed +caller contract can reconcile the outputs, with its costs and required reads +included. The two contracts are not automatically interchangeable. + +## 6. Result boundary + +The first handoff is resolved to this scoped interface gap, without a paid +physical caller. The second has an actual required legal observable on a +strong-domain family, plus an exact failure of the original unscaled witness. +[COSTS.md](COSTS.md) records the local acquisition and return components and +the obligations that prevent treating them as a complete supplier saving. + +The revision-6 family gate and inherited unchanged-profile stop remain in +force. No selected record, source word, native recipe, or historical evidence +is modified. A further construction round needs a named compatible caller +and a complete allowance, or a specifically changed admission/consumer +contract with that allowance. The present result alone does not justify one. + +Credit belongs to the predecessors named in [README.md](README.md), including +their geometry, compiler, literal arithmetic, covariance, completion, and +adapter results. Separate agent implementations provide corroboration, not +external human review or formal proof-kernel acceptance. diff --git a/research/p104-kernel-consumer/README.md b/research/p104-kernel-consumer/README.md new file mode 100644 index 0000000000..fae030355a --- /dev/null +++ b/research/p104-kernel-consumer/README.md @@ -0,0 +1,169 @@ +# A required P104 consumer beyond the five readouts + +**The original PR #3554 kernel witness fails at an omitted quarter read. +A fourfold family executes the whole word and changes the required X0 output +while all five first-collector readouts stay zero. The unchanged word does +not materialise K under direct bank identification; the required coefficient +access remains a physical caller obligation.** + +This focused audit answers the two conditional handoffs in +[PR #3554](https://github.com/CrocSwap/integer-mult-bounds/pull/3554), head +`9f225dda71c45e2e6fea70e2ff5ef9f27192e1f9`. It adds a useful interface +separation and one actual required consumer. It supplies no paid physical +caller, benefit from the relative enlargement, new supplier, or change to +the selected bound. + +## Exact result + +Let $B_9=E_9\mathbb Z[i]^{512}$ be the credited Gaussian Newton module, +$A_H$ the source's phase-correct physical chart, and +$p=A_O^{-1}E_9\delta_{15}$ the PR #3467 coefficient $a_{44}$ witness. +Its prepared sources are Y91 = $p$ and Y90 = $-p$. + +| Assigned question | Source-bound answer | +|---|---| +| Does the existing word supply PR #3467's 52 coefficient meanings and PR #3554's returned-state interface? | All 728 Y writes are bank-local native transports. They cannot materialise K under one-bank-per-independent-coefficient identification, even after relabelling. The 104 actual final Y frames have dimension eight, while the logical caller returns its coefficient fields in empty frames. External preparation, actual coefficient access, and adapters need an explicit paid contract. | +| Is there an actual required legal observable of the five-readout kernel? | Yes on the admitted strong family. For every $u\in B_9$, initial Y91 = $4u$, Y90 = $-4u$, and every other public bank zero execute the entire word exactly and produce $X0=-2A_Fu$. All five readouts are zero. The original unscaled $p$ fails earlier at event 1099. | + +At that first failure, the actual instruction is `D1 += Y90/4`, its common +frame is `[381,241,2]`, and the donor at address 10 is `(-2,0)`. The required +real increment is $-1/2$. All 1,099 earlier events complete exactly, with +no completed event output outside $B_9$. + +The required consumer runs through D1, the eighth collector's Q0, G0, and +X0. The late X0 sign at event 5086 changes its earlier $+p/2$ response to +the final $-p/2$. D27's particular transient at 1817 to 1819 has no direct +intervening reader. [PROOF.md](PROOF.md) gives the precise source events, +frames, restoration statements, and the all-$B_9$ induction. + +The admitted family belongs to $S=(4B_9)^{52}$. It shows that no function of +the five readouts alone can supply X0, even on $S$. It does not demonstrate +an advantage of $L/S$. PR #3554's complete output still returns all 52 +coefficient banks, so its full interface has not lost this information. + +## Evidence and verification boundary + +The package has three complementary paths. `primary.py` uses the authenticated +PR #3467 encoder and a forward rational symbol with short actual chart paths. +`literal.py` independently reconstructs $p$ and executes the literal +signed-floor program without importing predecessor executables. +`observable.py` derives a reverse X0 covector and compares all 104 Y entries +against the existing PR #3462 completion row. Its omission controls detect +the late sign and Q0 cleanup. + +The finite positive control uses $u=p$. It covers: + +| Check | Coverage | +|---|---:| +| Completed actual events | 5,398 | +| Bound native occurrences | 2,070 | +| Active native calls / explicit completed literal-ideal pairs | 223 / 102,656 | +| Native calls evaluated by their proved zero action | 1,847 | +| ADDs / signs / zero erasures | 3,104 / 208 / 8 | +| Final physical frames | 358 | +| Complete independently prepared $p$ coordinates | 512 | +| Complete Q0/G0/X0 checkpoint coordinates, with frames | 9,216 | +| Complete returned Y90/Y91 coordinates | 1,024 | + +All 52 affected X bank names and the two returned Y sources are checked as +the exact nonzero endpoint support. The full physical arrays are compared +for X0 and the named checkpoints; this is not a new full-matrix certificate. +The two finite fixtures have zero initial dirt. Arbitrary normalised +D1/Q0/G0 restoration is a separate reverse-row identity, conditional on +admission and the inherited native covariance. The universal paired-family +theorem uses a written induction and a complete symbolic denominator +certificate, not interpolation from those two fixtures. + +[RECEIPT.json](RECEIPT.json) records the exact inputs, implementation/proof +hashes, comparisons, and controls. The replay captures and authenticates +source bytes before compiling them, compares complete typed receipts, and +rechecks that inputs and implementation bytes did not change. It rejects +missing or changed inputs and Boolean-for-integer receipt substitutions. +No floating-point, external library, historical full-map replay, Lean, or +proof-kernel acceptance is involved. + +## Cost and stopping decision + +[COSTS.md](COSTS.md) counts both actual rank-seven eighth-collector calls, +all four monomial wrappers, 11 full-bank ADDs, the owned C zero bank, and +cleanup. Its component subtotal is 39,936 real ADD/SUB evaluations, with +14,336 native floor halves, 3,584 quarter turns, and 1,744 ordinary Gaussian +payload SWAPs recorded separately. Three named later scalar updates add +3,072 real ADD/SUBs. A temporarily mutable quarter-read donor needs 2,048 +exact halves and 2,048 restoring doublings; a read-only donor has a separate +copy-and-cleanup obligation. + +These are local arithmetic counts. The complete input preparation, required +reads and outputs, intermediate frames, ownership, zero supply, controller, +finite widths, routing, and recursive allowance remain unfilled. X0's +rank-eight endpoint adapter is credited to PR #3469 and counted once within +its existing adapter profile, never appended again to the original word. +The inherited fixed-profile 599/584 stop remains conditional on its original +premises. Unknown physical costs are not zero. + +## Reproduce + +From a complete Git checkout containing the committed package: + +```sh +python3.12 -B scripts/research_package.py --package research/p104-kernel-consumer --check-only +python3.12 -B scripts/research_package.py --package research/p104-kernel-consumer +python3.12 -B scripts/check_research_commit.py --package research/p104-kernel-consumer --check-source-history +``` + +The registered manifest runs normal and optimised Python with a 120-second +limit for each command. The bounded mathematical replay normally takes a +few seconds on the author environment; runtime is not a cost model. +All 20 declared live inputs are already retained canonical-main ancestors. +The selected record and catalogue are historical provenance, not scientific +runtime inputs. PR #3554 is the assigned question and credited context, +not an executable dependency or an unmerged source-history pin. + +After exporting the committed package with the repository's +[package exporter](../../docs/research/package-export.md), check the archive +before extraction. The direct replay works without Git or network access +and only reads its captured files: + +```sh +python3.12 -I -B research/p104-kernel-consumer/verify.py +python3.12 -I -O -B research/p104-kernel-consumer/verify.py +``` + +Normal replay never rewrites the receipt. `--write-receipt` is a separate, +explicit maintainer action after reviewing intentional changes. Export +integrity, committed source-history availability, and mathematical replay +are separate gates. + +## Open next questions + +The structured [TASK.json](TASK.json) records the assigned scope, live overlap +check, evidence, family decision, and empty `open_questions` list. No further +construction is justified by this result alone. Continuation requires a named +provider of the actual coefficient values or a specifically changed admitted +consumer contract, together with a complete allowance covering the missing +physical obligations. This is a stopping condition, not a new supplier claim. + +## Credit + +Prepared by Clear1nsight, with substantial OpenAI assistance from a root agent +and three concurrent specialist agents. Their separately written checks are +not independent human review. New work is Apache-2.0; retained licences, +NOTICE, and predecessor manifests remain inputs. + +Credit ywz65's [PR #2586](https://github.com/CrocSwap/integer-mult-bounds/pull/2586) +word/native recipes and Arham Tahir's retention in +[PR #2665](https://github.com/CrocSwap/integer-mult-bounds/pull/2665). +Tekalign's PR #3025/#3218 and Ross Richardson's PR #3068 provide the +literal arithmetic, exact comparison, and period-domain questions. +Clear1nsight's PR #3382/#3423/#3467/#3554 supply the Gaussian module, +conditional cost stop, coefficient interface, and assigned handoffs. +Nick Petalas's PR #3406/#3416/#3426/#3462/#3469 supply the whole-word +entrance, phase-correct covariance, correlated-interface context, normalised +completion, and existing frame adapters. Hiroki Kumazaki's PR #3446 supplies +the external-recipient projection. Nick Petalas's separate Y27/Y26 full-prefix +work in PR #3466 is a neighbouring result, not this Y91/Y90 calculation. +Jose Manuel/Vasek and the retained geometry, native, and compiler lineage +retain their corresponding implementation and cost credit. + +Archival merges and source retention do not imply scientific admission. +No selected frontier file is changed. diff --git a/research/p104-kernel-consumer/RECEIPT.json b/research/p104-kernel-consumer/RECEIPT.json new file mode 100644 index 0000000000..3ad4e948e9 --- /dev/null +++ b/research/p104-kernel-consumer/RECEIPT.json @@ -0,0 +1,4040 @@ +{ + "SOURCES_sha256": "53304943d977fa3a7c1c63e6e07745f6cef2cc8c2e80e629ff1da6427684145f", + "full_array_comparison": { + "comparison": "Complete arrays and frames compared before hashes, not hashes alone.", + "final_query_restored": true, + "final_required_X0_nonzero": true, + "full_p_coordinates": 512, + "original_failure_checked": { + "address": 10, + "coefficient": "1/4", + "component": "real", + "event": 1099, + "exact_increment": "-1/2", + "kind": "nonintegral_fractional_addend", + "source": "Y90", + "target": "D1" + }, + "returned_Y_Gaussian_coordinates": 1024, + "strong_checkpoint_Gaussian_coordinates": 9216, + "strong_checkpoint_banks": 18 + }, + "implementation_and_proof_sha256": { + "COSTS.md": "bdfdd28d468196c2ad87779d5981577b68f0badddb5f10b2f9cbdfd21d7e6e66", + "PROOF.md": "c7ea8909156b0faeb828b413cef28d64fffb5568e50454a11cfb8d2c4bf55347", + "literal.py": "c6539b1eddaa1ac334717ae8dc16d530c250f6b7b86fbb5bdd7c97f882fd8860", + "observable.py": "117ab7d91aea94c8dac6f38d36dbc89d42a8ceae4ce05f51bd3b8d58e3c5a869", + "primary.py": "754af4926caded102503759a6313d01a04a04bee3ad602ed5161fcb92152c0ed", + "verify.py": "4f7b325b40a498a06bd13f0a680b17e89157dc1636165d166281383112c6c55b" + }, + "input_sha256": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "research/p104-omitted-completion/CERTIFICATE.json": "f68a2e6f3bd771b9692772909df200102350a80deda35532f3cc348b75d0c044", + "research/p104-omitted-completion/PROOF.md": "d77dfddc22ec31b24b75f00bb0e78034e8d1abd37972651c80458a4339904961", + "research/p104-omitted-completion/README.md": "2d49ed6d8676a8f24dc453437ec320b23735dc3d979660a7d24fde71d34a9556", + "research/p104-omitted-frame-adapters/ADAPTERS.json": "db424edfb316f06f4913946b2b0cafa2f200b75392cacb35244b8705db02387c", + "research/p104-omitted-frame-adapters/PROOF.md": "f0ffae7c84f27bc0f4ae674335e639f79e73ec3c1c8f94ce7e18ec2e3d2aaf2b", + "research/p104-omitted-frame-adapters/README.md": "066c97976eaf2f2d8b61a11d43b8e44fd5338e47500290751566ecfa2ff02795", + "research/p104-rounded-collector/PREDECESSORS.json": "89f17ce76729101536cfc0be02ad153451c6606ebcfd3a1d6588226a83c88c64", + "research/p104-rounded-collector/README.md": "a77514952eda13fac047c5a4daba92d6c01d3e83bb1b41da4b87211bec6c37c9", + "research/p104-rounded-collector/inputs/NATIVE.json.gz": "ab91c78835c3e10cf3b2cb8a5d4e0b7cfc3df1ae5a811298d27842f2193e1e3d", + "research/p104-rounded-collector/inputs/WORD.json": "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50", + "research/p104-stagewise-entrance/PROOF.md": "4fb79a8da2740ac9608d5e153aec3199ab14e3955cf44710bb0a7f111d745fe1", + "research/p104-stagewise-entrance/admission.py": "00bd8c666fa758e76e47fb3e8835dd71770d1ce32c55d71d8d003dca2da15709", + "research/p104-stagewise-entrance/classifier.py": "3e42ba4e5fa1cc819f3e7b773b38ca47476bf85f581f888cc99690e1cf2f2b40", + "research/p104-stagewise-entrance/inputs/PR3382_PROOF.md": "1ca8c0e7e78f0f39de6cff7accc68ccd3901bfb50759bf7a2e2896bcf63bf081", + "research/p104-stagewise-entrance/inputs/PR3416_PROOF.md": "0dc1c35158902299fc8748c8baf89205483562f041e9050580e6579c331ebeb5", + "research/p104-stagewise-entrance/inputs/pr3382_model.py": "74c83367887dd885137b222155c86389fe0be9f1293a6f0e5fdb51d71f435fdd", + "research/p104-stagewise-entrance/source.py": "c54dabffe141de6befb6069e145c5ccbde629e76afb0f0afa3eb07bd72ab4b25", + "upstream/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "literal": { + "actual_final_Y_frame_dimensions": { + "8": 104 + }, + "all_Y_target_events": 728, + "all_native_occurrences_bound": 2070, + "cross_bank_Y_writes": 0, + "derivation": { + "cancellation_event": 1819, + "coefficient_mask": 15, + "coefficient_slot": 44, + "inverse_path_arithmetic": { + "active_native_events_completed": 6, + "active_native_rank_mass": 8, + "completed_literal_ideal_pairs": 2048, + "native_events_entered": 6 + }, + "p_sha256": "2d5e9e5b5d2ef3cbee879749e9f67b3c78c20eef2edf8f0b7737a0a65230503b", + "profile": "E9 delta15 = -4 on the 32 supersets of mask15", + "read_event": 1817, + "source_path": [ + 195, + 992, + 1133, + 1238, + 1397, + 1598 + ] + }, + "fixture_scope": "Y91=p,Y90=-p or Y91=4p,Y90=-4p; all other initial banks zero.", + "status": "PASS_TWO_LITERAL_KERNEL_PROBES", + "strong": { + "checkpoint_sha256": { + "1099": { + "G0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "Q0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "X0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16" + }, + "2121": { + "G0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "Q0": "648f2ef2e11e1a2eb087fc3cfbff190aae11af7a0abe557cee5738ce25fa7dbf", + "X0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16" + }, + "3278": { + "G0": "e93d0327a8c3216c69d3afd82905eb340e8f9841790b7cba526ff24705b6fb7a", + "Q0": "648f2ef2e11e1a2eb087fc3cfbff190aae11af7a0abe557cee5738ce25fa7dbf", + "X0": "60fbb391fd8655c034e8cdce3209d3968c5e6f59919329cf96089e9304571329" + }, + "4241": { + "G0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "Q0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "X0": "e6180b612b15c05c676deb0ea8725a25b756ed63d5d23272b07a72d9ffda3bf8" + }, + "5086": { + "G0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "Q0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "X0": "5fdfccc38ead92cc1384c30545bb386a16cb30eba045845e3d4cab4d44f0f752" + }, + "5397": { + "G0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "Q0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "X0": "d624d7f0549dbe555a7734a646f6161b64efbc082338c5a14d6b1b7d5398b385" + } + }, + "counts": { + "active_native_events_completed": 223, + "active_native_rank_mass": 401, + "completed_literal_ideal_pairs": 102656, + "events_completed": 5398, + "fractional_adds": 1438, + "native_events_entered": 2070, + "nonzero_fractional_adds": 33, + "private_zero": 8, + "private_zero_erase": 8, + "signs": 208, + "weighted_adds": 3104, + "zero_native_events": 1847, + "zero_native_pairs_proved_zero": 804096 + }, + "final_Q0_sha256": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "final_X0_sha256": "d624d7f0549dbe555a7734a646f6161b64efbc082338c5a14d6b1b7d5398b385", + "final_frames_checked": true, + "first_completed_event_outside_B9": null, + "first_literal_failure": null, + "multiplier": 4, + "nonzero_final_banks": [ + "X0", + "X1", + "X100", + "X11", + "X12", + "X15", + "X16", + "X19", + "X20", + "X24", + "X25", + "X28", + "X29", + "X3", + "X33", + "X34", + "X37", + "X38", + "X41", + "X42", + "X45", + "X46", + "X48", + "X49", + "X52", + "X53", + "X56", + "X57", + "X6", + "X60", + "X61", + "X64", + "X65", + "X68", + "X69", + "X7", + "X72", + "X73", + "X76", + "X77", + "X8", + "X80", + "X81", + "X83", + "X84", + "X87", + "X88", + "X90", + "X91", + "X96", + "X97", + "X99", + "Y90", + "Y91" + ], + "status": "PASS_EXACT_LITERAL_WORD" + }, + "unscaled": { + "checkpoint_sha256": {}, + "counts": { + "active_native_events_completed": 4, + "active_native_rank_mass": 7, + "completed_literal_ideal_pairs": 1792, + "events_completed": 1099, + "fractional_adds": 100, + "native_events_entered": 368, + "nonzero_fractional_adds": 0, + "signs": 104, + "weighted_adds": 627, + "zero_native_events": 364, + "zero_native_pairs_proved_zero": 194048 + }, + "final_Q0_sha256": null, + "final_X0_sha256": null, + "final_frames_checked": false, + "first_completed_event_outside_B9": null, + "first_literal_failure": { + "actual_word_event": [ + "add", + "D1", + "Y90", + "1/4", + [ + 381, + 241, + 2 + ] + ], + "address": 10, + "coefficient": "1/4", + "component": "real", + "event": 1099, + "exact_increment": "-1/2", + "kind": "nonintegral_fractional_addend", + "source": "Y90", + "source_value": [ + -2, + 0 + ], + "target": "D1" + }, + "multiplier": 1, + "nonzero_final_banks": null, + "status": "EXACT_LITERAL_FAILURE" + }, + "zero_branch_rule": "Every affine monomial and each exact signed-floor pair sends an all-zero field to zero." + }, + "observable": { + "Q0_after_2121_initial_row": { + "Q0": [ + 1, + 1 + ], + "Y0": [ + 1, + 4 + ], + "Y1": [ + -1, + 4 + ], + "Y10": [ + -1, + 4 + ], + "Y11": [ + 1, + 4 + ], + "Y16": [ + -1, + 4 + ], + "Y17": [ + 1, + 4 + ], + "Y18": [ + -1, + 4 + ], + "Y19": [ + 1, + 4 + ], + "Y2": [ + 1, + 4 + ], + "Y25": [ + -1, + 4 + ], + "Y26": [ + 1, + 4 + ], + "Y27": [ + -1, + 4 + ], + "Y28": [ + 1, + 4 + ], + "Y3": [ + -1, + 4 + ], + "Y33": [ + 1, + 4 + ], + "Y38": [ + -1, + 4 + ], + "Y39": [ + 1, + 4 + ], + "Y4": [ + 1, + 4 + ], + "Y42": [ + -1, + 4 + ], + "Y43": [ + 1, + 4 + ], + "Y44": [ + -1, + 4 + ], + "Y45": [ + 1, + 4 + ], + "Y49": [ + -1, + 4 + ], + "Y5": [ + -1, + 4 + ], + "Y50": [ + 1, + 4 + ], + "Y51": [ + -1, + 4 + ], + "Y52": [ + 1, + 4 + ], + "Y55": [ + -1, + 4 + ], + "Y56": [ + 1, + 4 + ], + "Y6": [ + 1, + 4 + ], + "Y61": [ + -1, + 4 + ], + "Y62": [ + 1, + 4 + ], + "Y65": [ + -1, + 4 + ], + "Y66": [ + 1, + 4 + ], + "Y67": [ + -1, + 4 + ], + "Y68": [ + 1, + 4 + ], + "Y71": [ + -1, + 4 + ], + "Y72": [ + 1, + 4 + ], + "Y77": [ + -1, + 4 + ], + "Y78": [ + 1, + 4 + ], + "Y79": [ + -1, + 4 + ], + "Y8": [ + -1, + 4 + ], + "Y80": [ + 1, + 4 + ], + "Y84": [ + -1, + 4 + ], + "Y85": [ + 1, + 4 + ], + "Y88": [ + -1, + 4 + ], + "Y89": [ + 1, + 4 + ], + "Y9": [ + 1, + 4 + ], + "Y90": [ + 1, + 4 + ], + "Y97": [ + -1, + 4 + ], + "Y98": [ + -1, + 4 + ], + "Y99": [ + 1, + 4 + ] + }, + "Y_endpoint_audit": { + "Y90": [ + [], + [ + 258, + 130, + 64, + 32, + 16, + 10, + 6, + 1 + ] + ], + "Y91": [ + [], + [ + 257, + 129, + 65, + 33, + 16, + 8, + 4, + 2 + ] + ], + "all_final_dimensions": 8, + "all_initial_frames_empty": true, + "all_transport_only": true, + "bindings_sha256": "ff10f1e88bfb8e1008a3ab71e2bd02a9aa4ea4e0f7a7e2e7faa2a7aabce480bd", + "count": 104 + }, + "completion": { + "A_pair_difference": [ + -1, + 1, + 0, + 0, + 1, + -1, + 1, + 1 + ], + "C_X0": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "X0_Y_nonzeros": 49, + "X0_Y_row": { + "Y0": [ + -1, + 1 + ], + "Y10": [ + 1, + 2 + ], + "Y100": [ + -1, + 2 + ], + "Y12": [ + -1, + 2 + ], + "Y15": [ + 1, + 2 + ], + "Y17": [ + -1, + 2 + ], + "Y18": [ + 1, + 2 + ], + "Y2": [ + -1, + 2 + ], + "Y20": [ + -1, + 2 + ], + "Y24": [ + 1, + 2 + ], + "Y26": [ + -1, + 2 + ], + "Y27": [ + 1, + 2 + ], + "Y29": [ + -1, + 2 + ], + "Y34": [ + -1, + 2 + ], + "Y37": [ + 1, + 2 + ], + "Y39": [ + -1, + 2 + ], + "Y4": [ + -1, + 2 + ], + "Y41": [ + 1, + 2 + ], + "Y43": [ + -1, + 2 + ], + "Y44": [ + 1, + 2 + ], + "Y46": [ + -1, + 2 + ], + "Y48": [ + 1, + 2 + ], + "Y5": [ + 1, + 2 + ], + "Y50": [ + -1, + 2 + ], + "Y51": [ + 1, + 2 + ], + "Y53": [ + -1, + 2 + ], + "Y55": [ + 1, + 2 + ], + "Y57": [ + -1, + 2 + ], + "Y60": [ + 1, + 2 + ], + "Y62": [ + -1, + 2 + ], + "Y64": [ + 1, + 2 + ], + "Y66": [ + -1, + 2 + ], + "Y67": [ + 1, + 2 + ], + "Y69": [ + -1, + 2 + ], + "Y7": [ + 1, + 2 + ], + "Y71": [ + 1, + 2 + ], + "Y73": [ + -1, + 2 + ], + "Y76": [ + 1, + 2 + ], + "Y78": [ + -1, + 2 + ], + "Y79": [ + 1, + 2 + ], + "Y81": [ + -1, + 2 + ], + "Y83": [ + 1, + 2 + ], + "Y85": [ + -1, + 2 + ], + "Y87": [ + 1, + 2 + ], + "Y89": [ + -1, + 2 + ], + "Y9": [ + -1, + 2 + ], + "Y91": [ + -1, + 2 + ], + "Y96": [ + 1, + 2 + ], + "Y98": [ + 1, + 2 + ] + }, + "X0_frame_gap": [ + [ + 386 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + "X0_omitted_from_4027_event_projection": true, + "X0_pair_coefficient": [ + -1, + 2 + ], + "adapter_rank": 8, + "adapter_recipe_sha256": "62f7e95c40996e996f905becdba1ddb45c32608184219ae86ed79ebf647d5e07", + "credited_adapter_certificate": { + "dirty_endpoint_sha256": "569b0a2de4937fb733483c087e17cf33ea606894c840ac5b3d7df495de631013", + "exact_anchor_sha256": "eec3e01fe7fb375eb78aebfd09970bfd453a5851ae72b872290a926d7e1203e1", + "rank": 8, + "signed_pauli_sha256": "681f11ff6e4b83925f8a1073d156f51e30e5691776100e564155a32158082c80" + } + }, + "controls": { + "omitted_Q0_cleanup_4241_pair": [ + -1, + 4 + ], + "omitted_sign_5086_X0_pair": [ + 1, + 2 + ], + "source_corruption_rejected": [ + "WORD", + "PR3462 certificate", + "PR3469 adapters" + ] + }, + "event_numbering": "zero-based source WORD program indices", + "five_source_groups": [ + { + "bank": "D31", + "reads": [ + { + "event": 1090, + "frame": [ + 157, + 56, + 2 + ], + "slot": 0, + "source": "Y27" + }, + { + "event": 1129, + "frame": [ + 152, + 56, + 5, + 2 + ], + "slot": 1, + "source": "Y26" + }, + { + "event": 1231, + "frame": [ + 320, + 152, + 56, + 5, + 2 + ], + "slot": 2, + "source": "Y99" + } + ], + "rho_coefficient": [ + 1, + 4 + ] + }, + { + "bank": "D30", + "reads": [ + { + "event": 1093, + "frame": [ + 80, + 61, + 2 + ], + "slot": 3, + "source": "Y93" + }, + { + "event": 1126, + "frame": [ + 272, + 80, + 61, + 2 + ], + "slot": 4, + "source": "Y94" + }, + { + "event": 1226, + "frame": [ + 272, + 157, + 80, + 61, + 2 + ], + "slot": 5, + "source": "Y96" + }, + { + "event": 1228, + "frame": [ + 272, + 157, + 80, + 61, + 2 + ], + "slot": 6, + "source": "Y95" + }, + { + "event": 1389, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "slot": 7, + "source": "Y102" + }, + { + "event": 1391, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "slot": 8, + "source": "Y101" + }, + { + "event": 1393, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "slot": 9, + "source": "Y100" + } + ], + "rho_coefficient": [ + 1, + 4 + ] + }, + { + "bank": "D29", + "reads": [ + { + "event": 1177, + "frame": [ + 204, + 40, + 21, + 2 + ], + "slot": 10, + "source": "Y65" + }, + { + "event": 1294, + "frame": [ + 137, + 69, + 40, + 21, + 2 + ], + "slot": 11, + "source": "Y64" + }, + { + "event": 1296, + "frame": [ + 137, + 69, + 40, + 21, + 2 + ], + "slot": 12, + "source": "Y63" + }, + { + "event": 1453, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "slot": 13, + "source": "Y70" + }, + { + "event": 1455, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "slot": 14, + "source": "Y69" + }, + { + "event": 1457, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "slot": 15, + "source": "Y68" + }, + { + "event": 1459, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "slot": 16, + "source": "Y66" + } + ], + "rho_coefficient": [ + 1, + 4 + ] + }, + { + "bank": "D28", + "reads": [ + { + "event": 1087, + "frame": [ + 85, + 56, + 2 + ], + "slot": 17, + "source": "Y103" + }, + { + "event": 1162, + "frame": [ + 64, + 45, + 21, + 2 + ], + "slot": 18, + "source": "Y31" + }, + { + "event": 1271, + "frame": [ + 64, + 40, + 16, + 5, + 2 + ], + "slot": 19, + "source": "Y22" + }, + { + "event": 1421, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "slot": 20, + "source": "Y29" + }, + { + "event": 1423, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "slot": 21, + "source": "Y28" + }, + { + "event": 1425, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "slot": 22, + "source": "Y23" + }, + { + "event": 1633, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 23, + "source": "Y78" + }, + { + "event": 1635, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 24, + "source": "Y75" + }, + { + "event": 1637, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 25, + "source": "Y74" + }, + { + "event": 1639, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 26, + "source": "Y73" + }, + { + "event": 1641, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 27, + "source": "Y72" + } + ], + "rho_coefficient": [ + 1, + 4 + ] + }, + { + "bank": "D27", + "reads": [ + { + "event": 1157, + "frame": [ + 360, + 136, + 21, + 2 + ], + "slot": 28, + "source": "Y98" + }, + { + "event": 1159, + "frame": [ + 360, + 136, + 21, + 2 + ], + "slot": 29, + "source": "Y97" + }, + { + "event": 1281, + "frame": [ + 260, + 136, + 108, + 21, + 2 + ], + "slot": 30, + "source": "Y79" + }, + { + "event": 1283, + "frame": [ + 260, + 136, + 108, + 21, + 2 + ], + "slot": 31, + "source": "Y71" + }, + { + "event": 1446, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "slot": 32, + "source": "Y84" + }, + { + "event": 1448, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "slot": 33, + "source": "Y77" + }, + { + "event": 1450, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "slot": 34, + "source": "Y25" + }, + { + "event": 1614, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "slot": 35, + "source": "Y92" + }, + { + "event": 1616, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "slot": 36, + "source": "Y88" + }, + { + "event": 1618, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "slot": 37, + "source": "Y87" + }, + { + "event": 1620, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "slot": 38, + "source": "Y83" + }, + { + "event": 1622, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "slot": 39, + "source": "Y76" + }, + { + "event": 1624, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "slot": 40, + "source": "Y67" + }, + { + "event": 1626, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "slot": 41, + "source": "Y32" + }, + { + "event": 1628, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "slot": 42, + "source": "Y30" + }, + { + "event": 1630, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "slot": 43, + "source": "Y24" + }, + { + "event": 1817, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 44, + "source": "Y91" + }, + { + "event": 1819, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 45, + "source": "Y90" + }, + { + "event": 1821, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 46, + "source": "Y89" + }, + { + "event": 1823, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 47, + "source": "Y86" + }, + { + "event": 1825, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 48, + "source": "Y85" + }, + { + "event": 1827, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 49, + "source": "Y82" + }, + { + "event": 1829, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 50, + "source": "Y81" + }, + { + "event": 1831, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "slot": 51, + "source": "Y80" + } + ], + "rho_coefficient": [ + 1, + 4 + ] + } + ], + "method": "One-output reverse adjoints and exact source/certificate binding", + "named_cuts": [ + { + "Y90_coefficient": [ + 1, + 4 + ], + "Y91_coefficient": [ + 0, + 1 + ], + "bank": "D1", + "event_after": 1099, + "frame": [ + 381, + 241, + 2 + ], + "pair_value": [ + -1, + 4 + ], + "row_nonzeros": 2, + "row_sha256": "fa8a19592fb03fe68e15265ce1c867abd266ff975996f89d3b50079ba1b0ffbb" + }, + { + "Y90_coefficient": [ + 1, + 4 + ], + "Y91_coefficient": [ + 0, + 1 + ], + "bank": "C", + "event_after": 2118, + "frame": [ + 257, + 129, + 65, + 33, + 16, + 9, + 5, + 2 + ], + "pair_value": [ + -1, + 4 + ], + "row_nonzeros": 41, + "row_sha256": "e49a9689915288de08ec0572c70e1b36b02a85f585524744c1a3d116d5d25b9a" + }, + { + "Y90_coefficient": [ + 1, + 4 + ], + "Y91_coefficient": [ + 0, + 1 + ], + "bank": "Q0", + "event_after": 2121, + "frame": [ + 400 + ], + "pair_value": [ + -1, + 4 + ], + "row_nonzeros": 53, + "row_sha256": "7bebb4c2c0a7d4a73fc93a4ad334a9f44144af637ae6edf4af0a919fa1acd7c4" + }, + { + "Y90_coefficient": [ + 0, + 1 + ], + "Y91_coefficient": [ + 0, + 1 + ], + "bank": "D1", + "event_after": 2166, + "frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "pair_value": [ + 0, + 1 + ], + "row_nonzeros": 14, + "row_sha256": "87b913ba1e957ccc8a7ca30ab1cc561bf908fb732eba1ee7d2aa14e21f54d30a" + }, + { + "Y90_coefficient": [ + 1, + 4 + ], + "Y91_coefficient": [ + 0, + 1 + ], + "bank": "G0", + "event_after": 3025, + "frame": [ + 400 + ], + "pair_value": [ + -1, + 4 + ], + "row_nonzeros": 54, + "row_sha256": "32508d0d53fcfa8cc3baf0d5134f504d4cb9d926017c8de1aaf8a95cd8cb1644" + }, + { + "Y90_coefficient": [ + 0, + 1 + ], + "Y91_coefficient": [ + 1, + 2 + ], + "bank": "X0", + "event_after": 3278, + "frame": [ + 400, + 85 + ], + "pair_value": [ + 1, + 2 + ], + "row_nonzeros": 54, + "row_sha256": "1a6002dc5e52bf9b40115d0669c39f2be7f79df0810c943b3aff8fa6b553c76e" + }, + { + "Y90_coefficient": [ + 0, + 1 + ], + "Y91_coefficient": [ + 0, + 1 + ], + "bank": "G0", + "event_after": 4104, + "frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "pair_value": [ + 0, + 1 + ], + "row_nonzeros": 1, + "row_sha256": "2eda07511cf5fda52a7308b91e5fc723f6df9eca4ecf28dba056b082a0f115e5" + }, + { + "Y90_coefficient": [ + 0, + 1 + ], + "Y91_coefficient": [ + 0, + 1 + ], + "bank": "Q0", + "event_after": 4241, + "frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "pair_value": [ + 0, + 1 + ], + "row_nonzeros": 49, + "row_sha256": "d051afff9b765c8a5d6d46d8a5a48ff466490d9f99d1d6930df2e3309e3427fe" + }, + { + "Y90_coefficient": [ + 0, + 1 + ], + "Y91_coefficient": [ + 1, + 2 + ], + "bank": "X0", + "event_after": 5085, + "frame": [ + 258, + 130, + 64, + 32, + 16, + 8, + 4, + 1 + ], + "pair_value": [ + 1, + 2 + ], + "row_nonzeros": 50, + "row_sha256": "3e765afac1feda7fc2907bea738a36491b0008ce02b61696588fd1935385afa8" + }, + { + "Y90_coefficient": [ + 0, + 1 + ], + "Y91_coefficient": [ + -1, + 2 + ], + "bank": "X0", + "event_after": 5086, + "frame": [ + 258, + 130, + 64, + 32, + 16, + 8, + 4, + 1 + ], + "pair_value": [ + -1, + 2 + ], + "row_nonzeros": 50, + "row_sha256": "85441f9058afd3756b5b26c74467d68b26f5b0869bacfd15b9b4525e8d856d94" + }, + { + "Y90_coefficient": [ + 0, + 1 + ], + "Y91_coefficient": [ + -1, + 2 + ], + "bank": "X0", + "event_after": 5190, + "frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "pair_value": [ + -1, + 2 + ], + "row_nonzeros": 50, + "row_sha256": "85441f9058afd3756b5b26c74467d68b26f5b0869bacfd15b9b4525e8d856d94" + } + ], + "named_native_paths": { + "D1": [ + { + "event": 969, + "instruction": [ + "transport", + "D1", + [], + [ + 381, + 241, + 2 + ], + 3 + ] + }, + { + "event": 1101, + "instruction": [ + "transport", + "D1", + [ + 381, + 241, + 2 + ], + [ + 360, + 228, + 21, + 2 + ], + 1 + ] + }, + { + "event": 1176, + "instruction": [ + "transport", + "D1", + [ + 360, + 228, + 21, + 2 + ], + [ + 325, + 201, + 45, + 21, + 2 + ], + 1 + ] + }, + { + "event": 1293, + "instruction": [ + "transport", + "D1", + [ + 325, + 201, + 45, + 21, + 2 + ], + [ + 264, + 132, + 77, + 45, + 21, + 2 + ], + 1 + ] + }, + { + "event": 1582, + "instruction": [ + "transport", + "D1", + [ + 264, + 132, + 77, + 45, + 21, + 2 + ], + [ + 260, + 132, + 65, + 33, + 21, + 12, + 2 + ], + 1 + ] + }, + { + "event": 1771, + "instruction": [ + "transport", + "D1", + [ + 260, + 132, + 65, + 33, + 21, + 12, + 2 + ], + [ + 257, + 129, + 65, + 33, + 16, + 9, + 5, + 2 + ], + 1 + ] + }, + { + "event": 2159, + "instruction": [ + "transport", + "D1", + [ + 257, + 129, + 65, + 33, + 16, + 9, + 5, + 2 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + 1 + ] + } + ], + "G0": [ + { + "event": 2993, + "instruction": [ + "transport", + "G0", + [], + [ + 400 + ], + 1 + ] + }, + { + "event": 3276, + "instruction": [ + "transport", + "G0", + [ + 400 + ], + [ + 400, + 85 + ], + 1 + ] + }, + { + "event": 3546, + "instruction": [ + "transport", + "G0", + [ + 400, + 85 + ], + [ + 268, + 156, + 85 + ], + 1 + ] + }, + { + "event": 3709, + "instruction": [ + "transport", + "G0", + [ + 268, + 156, + 85 + ], + [ + 268, + 128, + 73, + 28 + ], + 1 + ] + }, + { + "event": 3911, + "instruction": [ + "transport", + "G0", + [ + 268, + 128, + 73, + 28 + ], + [ + 268, + 128, + 73, + 41, + 28 + ], + 1 + ] + }, + { + "event": 4102, + "instruction": [ + "transport", + "G0", + [ + 268, + 128, + 73, + 41, + 28 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + 4 + ] + } + ], + "Q0": [ + { + "event": 979, + "instruction": [ + "transport", + "Q0", + [], + [ + 400 + ], + 1 + ] + }, + { + "event": 4103, + "instruction": [ + "transport", + "Q0", + [ + 400 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + 8 + ] + } + ], + "X0": [ + { + "event": 0, + "instruction": [ + "transport", + "X0", + [ + 386 + ], + [], + 1 + ] + }, + { + "event": 3103, + "instruction": [ + "transport", + "X0", + [], + [ + 453 + ], + 1 + ] + }, + { + "event": 3277, + "instruction": [ + "transport", + "X0", + [ + 453 + ], + [ + 400, + 85 + ], + 1 + ] + }, + { + "event": 3514, + "instruction": [ + "transport", + "X0", + [ + 400, + 85 + ], + [ + 400, + 80, + 5 + ], + 1 + ] + }, + { + "event": 3748, + "instruction": [ + "transport", + "X0", + [ + 400, + 80, + 5 + ], + [ + 400, + 80, + 40, + 5 + ], + 1 + ] + }, + { + "event": 3998, + "instruction": [ + "transport", + "X0", + [ + 400, + 80, + 40, + 5 + ], + [ + 258, + 130, + 64, + 32, + 16, + 8, + 4, + 1 + ], + 4 + ] + }, + { + "event": 5190, + "instruction": [ + "transport", + "X0", + [ + 258, + 130, + 64, + 32, + 16, + 8, + 4, + 1 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + 1 + ] + } + ], + "Y90": [ + { + "event": 194, + "instruction": [ + "transport", + "Y90", + [], + [ + 398 + ], + 1 + ] + }, + { + "event": 993, + "instruction": [ + "transport", + "Y90", + [ + 398 + ], + [ + 381, + 241, + 2 + ], + 2 + ] + }, + { + "event": 1100, + "instruction": [ + "transport", + "Y90", + [ + 381, + 241, + 2 + ], + [ + 272, + 156, + 109, + 2 + ], + 1 + ] + }, + { + "event": 1135, + "instruction": [ + "transport", + "Y90", + [ + 272, + 156, + 109, + 2 + ], + [ + 272, + 156, + 85, + 56, + 2 + ], + 1 + ] + }, + { + "event": 1240, + "instruction": [ + "transport", + "Y90", + [ + 272, + 156, + 85, + 56, + 2 + ], + [ + 272, + 156, + 84, + 56, + 2, + 1 + ], + 1 + ] + }, + { + "event": 1399, + "instruction": [ + "transport", + "Y90", + [ + 272, + 156, + 84, + 56, + 2, + 1 + ], + [ + 272, + 152, + 80, + 56, + 4, + 2, + 1 + ], + 1 + ] + }, + { + "event": 1600, + "instruction": [ + "transport", + "Y90", + [ + 272, + 152, + 80, + 56, + 4, + 2, + 1 + ], + [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + 1 + ] + }, + { + "event": 1820, + "instruction": [ + "transport", + "Y90", + [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + 1 + ] + }, + { + "event": 5384, + "instruction": [ + "transport", + "Y90", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + [ + 258, + 130, + 64, + 32, + 16, + 10, + 6, + 1 + ], + 1 + ] + } + ], + "Y91": [ + { + "event": 195, + "instruction": [ + "transport", + "Y91", + [], + [ + 481 + ], + 1 + ] + }, + { + "event": 992, + "instruction": [ + "transport", + "Y91", + [ + 481 + ], + [ + 272, + 156, + 109, + 2 + ], + 3 + ] + }, + { + "event": 1133, + "instruction": [ + "transport", + "Y91", + [ + 272, + 156, + 109, + 2 + ], + [ + 272, + 156, + 85, + 56, + 2 + ], + 1 + ] + }, + { + "event": 1238, + "instruction": [ + "transport", + "Y91", + [ + 272, + 156, + 85, + 56, + 2 + ], + [ + 272, + 156, + 84, + 56, + 2, + 1 + ], + 1 + ] + }, + { + "event": 1397, + "instruction": [ + "transport", + "Y91", + [ + 272, + 156, + 84, + 56, + 2, + 1 + ], + [ + 272, + 152, + 80, + 56, + 4, + 2, + 1 + ], + 1 + ] + }, + { + "event": 1598, + "instruction": [ + "transport", + "Y91", + [ + 272, + 152, + 80, + 56, + 4, + 2, + 1 + ], + [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + 1 + ] + }, + { + "event": 1818, + "instruction": [ + "transport", + "Y91", + [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + 1 + ] + }, + { + "event": 5385, + "instruction": [ + "transport", + "Y91", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + [ + 257, + 129, + 65, + 33, + 16, + 8, + 4, + 2 + ], + 1 + ] + } + ] + }, + "restoration": { + "C": "actual 2114..2128 collector has zero adjoint at erasure", + "D1_Q0_G0": "initial normalized rows; physical final frame F", + "Y": "normalized source payloads retained at their actual final frames" + }, + "rho5_pair_response": [ + [ + 0, + 1 + ], + [ + 0, + 1 + ], + [ + 0, + 1 + ], + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + "schema_version": 1, + "scope_limits": [ + "No literal full-word admission is proved by this scalar audit", + "No fresh full-map rank, recipient closure, or adapter optimality is claimed", + "Paid acquisition, physical layouts/routes, widths, and supplier advantage are not inferred" + ], + "separation": { + "Q0_after_2121": "-p/4", + "X0_after_3278": "+p/2", + "X0_final": "-p/2", + "claim": "The required X0 residual cannot factor through rho5 alone", + "formal_pair": "Y91=p, Y90=-p, all other initial increments zero", + "limitation": "This does not erase retained Y/coefficient outputs or prove a benefit from L/S", + "physical_meaning": "X0 increment is J_F(-p/2), conditional on native covariance and admission", + "rho5": "zero on all five group readouts", + "strong_4p_X0_final": "-2p" + }, + "source_read_audit": { + "all_D27_source_reads": [ + 916, + 2030, + 2034 + ], + "all_pair_reads": [ + { + "event": 1099, + "instruction": [ + "add", + "D1", + "Y90", + "1/4", + [ + 381, + 241, + 2 + ] + ] + }, + { + "event": 1132, + "instruction": [ + "add", + "D13", + "Y91", + "-1/4", + [ + 272, + 156, + 109, + 2 + ] + ] + }, + { + "event": 1134, + "instruction": [ + "add", + "D13", + "Y90", + "-1/4", + [ + 272, + 156, + 109, + 2 + ] + ] + }, + { + "event": 1237, + "instruction": [ + "add", + "D7", + "Y91", + "1/4", + [ + 272, + 156, + 85, + 56, + 2 + ] + ] + }, + { + "event": 1239, + "instruction": [ + "add", + "D7", + "Y90", + "1/4", + [ + 272, + 156, + 85, + 56, + 2 + ] + ] + }, + { + "event": 1396, + "instruction": [ + "add", + "D16", + "Y91", + "1/4", + [ + 272, + 156, + 84, + 56, + 2, + 1 + ] + ] + }, + { + "event": 1398, + "instruction": [ + "add", + "D16", + "Y90", + "1/4", + [ + 272, + 156, + 84, + 56, + 2, + 1 + ] + ] + }, + { + "event": 1597, + "instruction": [ + "add", + "D26", + "Y91", + "1/4", + [ + 272, + 152, + 80, + 56, + 4, + 2, + 1 + ] + ] + }, + { + "event": 1599, + "instruction": [ + "add", + "D26", + "Y90", + "1/4", + [ + 272, + 152, + 80, + 56, + 4, + 2, + 1 + ] + ] + }, + { + "event": 1817, + "instruction": [ + "add", + "D27", + "Y91", + "1/4", + [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ] + ] + }, + { + "event": 1819, + "instruction": [ + "add", + "D27", + "Y90", + "1/4", + [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2166, + "instruction": [ + "add", + "D1", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2177, + "instruction": [ + "add", + "D13", + "Y91", + "1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2178, + "instruction": [ + "add", + "D13", + "Y90", + "1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2215, + "instruction": [ + "add", + "D7", + "Y91", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2216, + "instruction": [ + "add", + "D7", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2280, + "instruction": [ + "add", + "D16", + "Y91", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2281, + "instruction": [ + "add", + "D16", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2369, + "instruction": [ + "add", + "D26", + "Y91", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2370, + "instruction": [ + "add", + "D26", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2473, + "instruction": [ + "add", + "D27", + "Y91", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2474, + "instruction": [ + "add", + "D27", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4231, + "instruction": [ + "add", + "Q7", + "Y91", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4232, + "instruction": [ + "add", + "Q6", + "Y91", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4233, + "instruction": [ + "add", + "Q4", + "Y91", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4234, + "instruction": [ + "add", + "Q3", + "Y91", + "1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4235, + "instruction": [ + "add", + "Q1", + "Y91", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4236, + "instruction": [ + "add", + "Q7", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4237, + "instruction": [ + "add", + "Q6", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4238, + "instruction": [ + "add", + "Q4", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4239, + "instruction": [ + "add", + "Q3", + "Y90", + "1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4240, + "instruction": [ + "add", + "Q1", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4241, + "instruction": [ + "add", + "Q0", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + } + ], + "events": [ + { + "event": 1099, + "instruction": [ + "add", + "D1", + "Y90", + "1/4", + [ + 381, + 241, + 2 + ] + ] + }, + { + "event": 1817, + "instruction": [ + "add", + "D27", + "Y91", + "1/4", + [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ] + ] + }, + { + "event": 1819, + "instruction": [ + "add", + "D27", + "Y90", + "1/4", + [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ] + ] + }, + { + "event": 2118, + "instruction": [ + "add", + "C", + "D1", + 1, + [ + 257, + 129, + 65, + 33, + 16, + 9, + 5, + 2 + ] + ] + }, + { + "event": 2121, + "instruction": [ + "add", + "Q0", + "C", + "1", + [ + 400 + ] + ] + }, + { + "event": 2166, + "instruction": [ + "add", + "D1", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 3025, + "instruction": [ + "add", + "G0", + "Q0", + 1, + [ + 400 + ] + ] + }, + { + "event": 3278, + "instruction": [ + "add", + "X0", + "G0", + -2, + [ + 400, + 85 + ] + ] + }, + { + "event": 4104, + "instruction": [ + "add", + "G0", + "Q0", + -1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 4241, + "instruction": [ + "add", + "Q0", + "Y90", + "-1/4", + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + }, + { + "event": 5086, + "instruction": [ + "sign", + "X0", + "-1", + [ + 258, + 130, + 64, + 32, + 16, + 8, + 4, + 1 + ] + ] + }, + { + "event": 5190, + "instruction": [ + "transport", + "X0", + [ + 258, + 130, + 64, + 32, + 16, + 8, + 4, + 1 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + 1 + ] + } + ], + "intervening_event": { + "event": 1818, + "instruction": [ + "transport", + "Y91", + [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + 1 + ] + } + }, + "source_sha256": { + "PR3462 certificate": "f68a2e6f3bd771b9692772909df200102350a80deda35532f3cc348b75d0c044", + "PR3469 adapters": "db424edfb316f06f4913946b2b0cafa2f200b75392cacb35244b8705db02387c", + "WORD": "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50" + }, + "status": "PASS", + "word_operation_counts": { + "add": 3104, + "erase": 8, + "sign": 208, + "transport": 2070, + "zero": 8 + } + }, + "primary": { + "chart_oracle_paths": { + "[256, 128, 64, 32, 16, 8, 4, 2, 1]": [ + [ + 972, + false + ], + [ + 4164, + false + ] + ], + "[257, 129, 65, 33, 16, 8, 4, 2]": [ + [ + 0, + true + ], + [ + 4768, + false + ] + ], + "[258, 130, 64, 32, 16, 10, 6, 1]": [ + [ + 1, + true + ], + [ + 4771, + false + ] + ], + "[258, 130, 64, 32, 16, 8, 4, 1]": [ + [ + 972, + false + ], + [ + 4164, + false + ], + [ + 5190, + true + ] + ], + "[400, 85]": [ + [ + 976, + false + ], + [ + 3277, + false + ] + ], + "[400]": [ + [ + 979, + false + ] + ], + "[]": [] + }, + "coefficient_column": { + "K_inverse_returns_coefficients": true, + "component_height": 1, + "gap": { + "bank": "D27", + "event": 1817, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1819, + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y91", + "source_path_to_read": [ + 195, + 992, + 1133, + 1238, + 1397, + 1598 + ], + "transport_event": null + }, + "in_4B9": false, + "in_B9": true, + "mask": 15, + "nonzero_coordinates": 256, + "p_sha256": "2d5e9e5b5d2ef3cbee879749e9f67b3c78c20eef2edf8f0b7737a0a65230503b", + "slot": 44, + "source_support": [ + "Y91", + "Y90" + ] + }, + "collector": { + "completed_native_pairs": 3584, + "counts": { + "add": 11, + "erase": 1, + "transport": 2, + "zero": 1 + }, + "events": [ + 2114, + 2128 + ], + "native_Gaussian_quarter_turns": 3584, + "native_floor_halves": 14336, + "native_rank_mass": 14, + "owned_zero_Gaussian_banks": 1, + "real_ADD_SUB_before_SWAP_phase_lowering": 39936, + "scope": "Existing eighth collector only. Both transports, all four wrappers and cleanup included; no physical or recursive price inferred.", + "wrapper_Gaussian_SWAPs": 1744, + "wrapper_phase_histogram": { + "0": 512, + "1": 512, + "2": 512, + "3": 512 + }, + "wrappers": [ + { + "Gaussian_SWAP": 448, + "cycles": 64, + "event": 2120, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "side": "right" + }, + { + "Gaussian_SWAP": 448, + "cycles": 64, + "event": 2120, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "side": "left" + }, + { + "Gaussian_SWAP": 384, + "cycles": 128, + "event": 2122, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "side": "right" + }, + { + "Gaussian_SWAP": 464, + "cycles": 48, + "event": 2122, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "side": "left" + } + ] + }, + "strong_checkpoint_hashes": { + "1099": { + "G0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "Q0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "X0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16" + }, + "2121": { + "G0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "Q0": "648f2ef2e11e1a2eb087fc3cfbff190aae11af7a0abe557cee5738ce25fa7dbf", + "X0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16" + }, + "3278": { + "G0": "e93d0327a8c3216c69d3afd82905eb340e8f9841790b7cba526ff24705b6fb7a", + "Q0": "648f2ef2e11e1a2eb087fc3cfbff190aae11af7a0abe557cee5738ce25fa7dbf", + "X0": "60fbb391fd8655c034e8cdce3209d3968c5e6f59919329cf96089e9304571329" + }, + "4241": { + "G0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "Q0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "X0": "e6180b612b15c05c676deb0ea8725a25b756ed63d5d23272b07a72d9ffda3bf8" + }, + "5086": { + "G0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "Q0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "X0": "5fdfccc38ead92cc1384c30545bb386a16cb30eba045845e3d4cab4d44f0f752" + }, + "5397": { + "G0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "Q0": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "X0": "d624d7f0549dbe555a7734a646f6161b64efbc082338c5a14d6b1b7d5398b385" + } + }, + "symbolic": { + "ADD_product_denominators": { + "1": 3006, + "2": 52, + "4": 46 + }, + "erasure_events": [ + 2039, + 2052, + 2063, + 2076, + 2089, + 2102, + 2113, + 2128 + ], + "final_nonzero_coefficients": { + "X0": [ + -1, + 2 + ], + "X1": [ + -1, + 2 + ], + "X100": [ + -1, + 2 + ], + "X11": [ + 1, + 2 + ], + "X12": [ + -1, + 2 + ], + "X15": [ + 1, + 2 + ], + "X16": [ + -1, + 2 + ], + "X19": [ + 1, + 2 + ], + "X20": [ + -1, + 2 + ], + "X24": [ + 1, + 2 + ], + "X25": [ + -1, + 2 + ], + "X28": [ + 1, + 2 + ], + "X29": [ + -1, + 2 + ], + "X3": [ + -1, + 2 + ], + "X33": [ + 1, + 2 + ], + "X34": [ + -1, + 2 + ], + "X37": [ + 1, + 2 + ], + "X38": [ + -1, + 2 + ], + "X41": [ + 1, + 2 + ], + "X42": [ + -1, + 2 + ], + "X45": [ + 1, + 2 + ], + "X46": [ + -1, + 2 + ], + "X48": [ + 1, + 2 + ], + "X49": [ + -1, + 2 + ], + "X52": [ + 1, + 2 + ], + "X53": [ + -1, + 2 + ], + "X56": [ + 1, + 2 + ], + "X57": [ + -1, + 2 + ], + "X6": [ + 1, + 2 + ], + "X60": [ + 1, + 2 + ], + "X61": [ + -1, + 2 + ], + "X64": [ + 1, + 2 + ], + "X65": [ + -1, + 2 + ], + "X68": [ + 1, + 2 + ], + "X69": [ + -1, + 2 + ], + "X7": [ + 1, + 2 + ], + "X72": [ + 1, + 2 + ], + "X73": [ + -1, + 2 + ], + "X76": [ + 1, + 2 + ], + "X77": [ + -1, + 2 + ], + "X8": [ + -1, + 2 + ], + "X80": [ + 1, + 2 + ], + "X81": [ + -1, + 2 + ], + "X83": [ + 1, + 2 + ], + "X84": [ + -1, + 2 + ], + "X87": [ + 1, + 2 + ], + "X88": [ + -1, + 2 + ], + "X90": [ + 1, + 2 + ], + "X91": [ + -1, + 2 + ], + "X96": [ + 1, + 2 + ], + "X97": [ + -1, + 2 + ], + "X99": [ + 1, + 2 + ], + "Y90": [ + -1, + 1 + ], + "Y91": [ + 1, + 1 + ] + }, + "maximum_absolute_normalised_coefficient": [ + 1, + 1 + ], + "opcode_counts": { + "add": 3104, + "erase": 8, + "sign": 208, + "transport": 2070, + "zero": 8 + }, + "scope": "One symbolic paired family, every5398 event, including all208 signs; no rank census.", + "six_first_collector_coefficients": [ + [ + 0, + 1 + ], + [ + 0, + 1 + ], + [ + 0, + 1 + ], + [ + 0, + 1 + ], + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + "stored_denominators": { + "1": 4928, + "2": 390, + "4": 72 + } + } + }, + "schema_version": 1, + "scope": "A source-bound consumer/caller audit with two finite fixtures and a written all-B9 paired-family implication. No paid caller, supplier, enlarged-domain advantage or kappa claim.", + "status": "PASS_P104_KERNEL_CONSUMER", + "typed_receipt_control": "Boolean true is distinct from integer1" +} diff --git a/research/p104-kernel-consumer/SOURCES.json b/research/p104-kernel-consumer/SOURCES.json new file mode 100644 index 0000000000..a779518209 --- /dev/null +++ b/research/p104-kernel-consumer/SOURCES.json @@ -0,0 +1,146 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/p104-rounded-collector/inputs/NATIVE.json.gz", + "usage": "input", + "git_blob": "04f2877aa5444948b7ae37efd267745af82cb34d", + "sha256": "ab91c78835c3e10cf3b2cb8a5d4e0b7cfc3df1ae5a811298d27842f2193e1e3d" + }, + { + "path": "research/p104-rounded-collector/inputs/WORD.json", + "usage": "input", + "git_blob": "93acaabc0a523789ef2f1b06f6eeeefed5551397", + "sha256": "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50" + }, + { + "path": "research/p104-stagewise-entrance/PROOF.md", + "usage": "input", + "git_blob": "8e10fbbeae2d21ffd7832bdadccc59b76554dec8", + "sha256": "4fb79a8da2740ac9608d5e153aec3199ab14e3955cf44710bb0a7f111d745fe1" + }, + { + "path": "research/p104-stagewise-entrance/admission.py", + "usage": "input", + "git_blob": "c035cc9f95b3f9c3a29dbb0e22cbc6816a2b5ade", + "sha256": "00bd8c666fa758e76e47fb3e8835dd71770d1ce32c55d71d8d003dca2da15709" + }, + { + "path": "research/p104-stagewise-entrance/classifier.py", + "usage": "input", + "git_blob": "6a299ce9b9bae7ee28bd4de6e00757dfe42eff72", + "sha256": "3e42ba4e5fa1cc819f3e7b773b38ca47476bf85f581f888cc99690e1cf2f2b40" + }, + { + "path": "research/p104-stagewise-entrance/inputs/PR3382_PROOF.md", + "usage": "input", + "git_blob": "10b3202c788b5b03188eed91181441dfd793ff7f", + "sha256": "1ca8c0e7e78f0f39de6cff7accc68ccd3901bfb50759bf7a2e2896bcf63bf081" + }, + { + "path": "research/p104-stagewise-entrance/inputs/PR3416_PROOF.md", + "usage": "input", + "git_blob": "276f61cb64d253f6d43e1ec7e8230df551ad02cd", + "sha256": "0dc1c35158902299fc8748c8baf89205483562f041e9050580e6579c331ebeb5" + }, + { + "path": "research/p104-stagewise-entrance/inputs/pr3382_model.py", + "usage": "input", + "git_blob": "4dd24a2627db8239d062afc7888a39bf5cd0f478", + "sha256": "74c83367887dd885137b222155c86389fe0be9f1293a6f0e5fdb51d71f435fdd" + }, + { + "path": "research/p104-stagewise-entrance/source.py", + "usage": "input", + "git_blob": "2e6a5116dbe5f7746fa688ece81345ad4a89dd6a", + "sha256": "c54dabffe141de6befb6069e145c5ccbde629e76afb0f0afa3eb07bd72ab4b25" + }, + { + "path": "research/p104-omitted-completion/CERTIFICATE.json", + "usage": "input", + "git_blob": "2893b15a23100beba7a46595afe181a551a7e39c", + "sha256": "f68a2e6f3bd771b9692772909df200102350a80deda35532f3cc348b75d0c044" + }, + { + "path": "research/p104-omitted-completion/README.md", + "usage": "input", + "git_blob": "d375a6ef314eb76a313145aee12d57ec0e8c560f", + "sha256": "2d49ed6d8676a8f24dc453437ec320b23735dc3d979660a7d24fde71d34a9556" + }, + { + "path": "research/p104-omitted-completion/PROOF.md", + "usage": "input", + "git_blob": "7cf8c7ee0eebb11ab024b8326e59c376cbd43701", + "sha256": "d77dfddc22ec31b24b75f00bb0e78034e8d1abd37972651c80458a4339904961" + }, + { + "path": "research/p104-omitted-frame-adapters/ADAPTERS.json", + "usage": "input", + "git_blob": "be3da1fa244260cf32d7c8f795af53b85965f2e0", + "sha256": "db424edfb316f06f4913946b2b0cafa2f200b75392cacb35244b8705db02387c" + }, + { + "path": "research/p104-omitted-frame-adapters/README.md", + "usage": "input", + "git_blob": "7aed10845228271b12ee6e428414dcd57f8e1506", + "sha256": "066c97976eaf2f2d8b61a11d43b8e44fd5338e47500290751566ecfa2ff02795" + }, + { + "path": "research/p104-omitted-frame-adapters/PROOF.md", + "usage": "input", + "git_blob": "7b994b1a229d26f7f4f0dc0fc456b2f7837f8fa9", + "sha256": "f0ffae7c84f27bc0f4ae674335e639f79e73ec3c1c8f94ce7e18ec2e3d2aaf2b" + }, + { + "path": "LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "NOTICE", + "usage": "input", + "git_blob": "59d8e0cf3102e15bd11db430838365531e2d7f18", + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd" + }, + { + "path": "upstream/LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "research/p104-rounded-collector/PREDECESSORS.json", + "usage": "input", + "git_blob": "944b9920686d1f3e23268191fcc652c66d246105", + "sha256": "89f17ce76729101536cfc0be02ad153451c6606ebcfd3a1d6588226a83c88c64" + }, + { + "path": "research/p104-rounded-collector/README.md", + "usage": "input", + "git_blob": "95288f6821cc4983df25f1f18aaacfc49f4f6299", + "sha256": "a77514952eda13fac047c5a4daba92d6c01d3e83bb1b41da4b87211bec6c37c9" + } + ], + "related_public_heads": { + "3554": "9f225dda71c45e2e6fea70e2ff5ef9f27192e1f9", + "3467": "4e4b08c689242f7f3be2e5e08dc1ae8d728ff920", + "3462": "7f0706bf7e7d6fce317d353d513157ebb368beb6", + "3469": "f42cc424aad37f5734fd1c893ecdadd8cc53e1c1", + "3446": "886222c1d3e2c2d878b263dc8d165ef03d5bac7f" + }, + "source_note": "All live inputs are byte-identical canonical-main20ec ancestors. PR3554 is the assigned public question and predecessor result, not an imported executable or source-history pin. The five-readout definition is reconstructed from WORD." +} diff --git a/research/p104-kernel-consumer/TASK.json b/research/p104-kernel-consumer/TASK.json new file mode 100644 index 0000000000..103f5ea917 --- /dev/null +++ b/research/p104-kernel-consumer/TASK.json @@ -0,0 +1,266 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "p104-side-correction", + "question": "Can the proposed P104 joint endpoint flags be realized by a chronological correction program with coefficients, dirty restoration and an affordable complete bill?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md", + "research/p104-joint-unit-flags/README.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the revision-6 family record and #2981 static joint flags, alongside the reviewed #1991 channel. #2981 is an author-checked source archive, not an independently validated executable correction or a refutation of program-level lifetime floors.", + "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": "After checking live handoffs, pin one named collection from #2981 and attach acquisition/delivery times, source dependencies and coefficient requirements. Test legal access and arbitrary dirty restoration; price any completion against the full channel/endpoint/hosting allowance. Stop with the exact missing implication or a scoped counterexample rather than expanding the static cover census.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier.", + "Repeating a correction or physical conversion already supplied by a pending follow-up without adding independent coverage or a different unresolved obligation.", + "Repeating the 208-flag static matching or calling a static nested cover a chronological correction program. Independent audit of that certificate is distinct and remains useful." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991", + "2586", + "endpoint transport", + "physical dual", + "relay composition", + "2981", + "joint unit flags", + "acquisition delivery", + "static nesting" + ], + "existing_checks": [ + { + "scope": "PR #2981 reports static joint endpoint flags and a matching of 208 departure and arrival flags; archival intake is not independent verification.", + "evidence": "research/p104-joint-unit-flags/README.md", + "remaining": "Independent flag check and a chronological coefficient program with dirty restoration and a complete cost.", + "status": "author-checked", + "source_commit": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Resolve the two assigned PR3554 handoffs against the unchanged physical P104 word: prove its coefficient-supplier mismatch, bind the a44=delta15 exact failure at event1099, and prove an all-B9 admitted paired family with an existing required signed X0 output beyond the five readouts.", + "scope_change_reason": "The user assigned the two conditional PR3554 handoffs. This audits their actual physical interface and one required kernel-sensitive output, without a new lattice census or supplier expansion.", + "bottleneck_link": "Prevents substituting a five-readout logical interface for an actual required output and identifies the exact coupled input preparation and payment still needed.", + "budget_minutes": null, + "stop_rule": "One source-bound caller mismatch and actual required-readout test. Stop before any dependent construction unless a physical caller and complete allowance are justified.", + "outcome": "completed", + "evidence": "PASS_P104_KERNEL_CONSUMER. Exact first failure at event 1099; complete 5398-event strong control with 102656 explicit native pair comparisons; full independent p/checkpoint/returned-source array comparisons; one reverse X0 row; a written all-B9 induction and local cost ledger. Receipt SHA256 d9626b8f44b83d50554af5ff868888327d68507fca5c23924e0ac89ff3e413b0. Detailed mathematical scope and separate publication gates are recorded below.", + "author": "Clear1nsight, with substantial OpenAI assistance", + "ai_assistance": "Clear1nsight with substantial OpenAI assistance from root and three concurrent specialist agents. Separately written agent checks are not external human or formal proof-kernel review.", + "open_questions": [], + "budget_override": "The user removed the 60-minute cap and assigned the two PR3554 handoff questions.", + "declared_milestone": "audit", + "family_expansion_decision": "narrow to one interface audit; unchanged-profile599/584 supplier stop retained", + "selection": { + "explicit_assignment": true, + "card_lookup": "choose_research_task.py --task p104-side-correction; no reroll", + "canonical_thread": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2750#discussioncomment-19012530" + }, + "entry_checkpoint": { + "canonical_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "checked_utc": "2026-10-18T06:00:14Z", + "priority_revision": 6, + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "open_prs": 281, + "pr_page_counts": [ + 100, + 100, + 81 + ], + "pr_snapshot_utc": "2026-10-18T06:06:39Z", + "complete_open_pr_body_pagination": true, + "discussions": "Fresh rendered2750/1166 and start1163; older hidden replies not exhaustively paginated.", + "limits": "No arbitrary code-diff or unpublished-work coverage. First100 closed records and named predecessors only. No novelty guarantee." + }, + "no_open_questions_reason": "The assigned audit is complete, but no additional construction is justified without a named physical provider of the actual coefficient reads or a specifically changed admitted consumer contract and a complete allowance. This result alone supplies neither.", + "evidence_details": { + "mathematical_status": "PASS_P104_KERNEL_CONSUMER", + "receipt_sha256": "d9626b8f44b83d50554af5ff868888327d68507fca5c23924e0ac89ff3e413b0", + "original_witness": "First exact literal failure at event1099, D1 += Y90/4, frame[381,241,2], address10, source(-2,0), real increment-1/2; all1099 preceding events complete in B9.", + "admitted_family": "For every u in B9, Y91=4u,Y90=-4u and other356 initial banks zero execute the complete word and give X0=-2 A_F u with rho5=0. Written induction uses the complete denominator certificate and explicitly inherited native preservation/covariance.", + "finite_control": "4p executes5398 events;2070 native occurrences bound;223 active calls with102656 explicit pair comparisons;1847 zero calls by exact zero action;3104 ADDs;208 signs;eight zero erasures;358 final frames.", + "independent_comparisons": "Complete512-entry p;9216 Q0/G0/X0 checkpoint coordinates and frames;1024 returned Y coordinates; exact54-bank endpoint support; separate reverse104-entry X0 row matched to existing CA/2 certificate.", + "caller_boundary": "728 transport-only Y writes do not materialise K under a direct one-bank-per-coefficient identification;104 actual final Y frames have dimension8. External preparation or virtual coefficient reads remain possible and require a physical contract and price.", + "cost_boundary": "Local eighth collector and named consumer operations priced in COSTS.md. Complete caller/supplier allowance remains unknown. The admitted family lies in S, so no L/S benefit or selected kappa claim follows.", + "review_corrections": "Independent source/certificate review caught a preliminary omitted late X0 sign before publication. Final verifier also requires the exact endpoint bank list, not only its cardinality.", + "validation_state": "Registered metadata/pins and both normal and optimised commands passed with receiptd9626b8f44b83d50554af5ff868888327d68507fca5c23924e0ac89ff3e413b0. All31 package/input files retained exact bytes and modes. Committed-source/history, export and actual CLI controls are separate publication gates recorded in the public handoff after execution." + }, + "submission_checkpoint": { + "schema_version": 1, + "checked_utc": "2026-10-18 06:37:50 UTC", + "main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "guidance_changed": [], + "guidance_sha256": { + "AGENTS.md": "eb25d8ec495b80190a4b1a634710819bb74f0fae88d5203285c2b75b6f147347", + "autoresearch.md": "8c98d179208c34a8c6768931e13f3bbeaa1cb63d59c660799ffde05c40935d9b", + "CONTRIBUTING.md": "8a49fe97e2ad088a2b2e0c5b222aaab08752783b1f9c1260790d7dd13011d215", + "docs/research/current-priorities.md": "c95e09baa997b48ba00a26ea29168e782b17392d28184ecb7a17eea5472dd77c", + "docs/research/research-family-status.md": "9b98ab42364e90588e90410fd2773f9bc4bf5050f514101bed0a0246881b5b7e", + "docs/research/p104-live-support-map.md": "571bf5619059182809d4590e48f02a5cf81cf55a8a1700f10f4c57be45537211", + "docs/research/agent-task-catalog.json": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "certificates/selected-result.json": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + "method": "GitHub MCP REST canonical ref plus newest100 open and100 closed title/body/head records, sorted created descending; bounded delta after complete06:06:39 snapshot", + "complete_new_open_delta_above": 3563, + "open_prefix_count": 100, + "closed_prefix_count": 100, + "newest_open": 3574, + "newest_closed": 3528, + "new_open_numbers": [ + 3574, + 3573, + 3572, + 3571, + 3570, + 3569, + 3568, + 3567, + 3566, + 3565, + 3564 + ], + "new_closed_above3563": [], + "overlapping_previous_open_records_compared": 89, + "changes_in_compared_records": [], + "new_metadata": [ + { + "number": 3574, + "title": "Bound the P104 rank-1 hosting threshold", + "head": "eb11cd484c23990c250bdc67ae61829ebae35536", + "author": "jwr404" + }, + { + "number": 3573, + "title": "Classify all thirty two-port support transfers", + "head": "f0cb59da21fbde87b4ca6a7480b0905d6f6fb9bc", + "author": "petalas" + }, + { + "number": 3572, + "title": "Prove sharp actual-body BIT borrowing cutoff 245767", + "head": "25bed4486b333e5a5e35ee3ed4438491e8ecb6b6", + "author": "petalas" + }, + { + "number": 3571, + "title": "feat(research): construct one-pass twiddle header producer", + "head": "3d197fbf50ed422afdd913b3d57ad9e593aa21ef", + "author": "petalas" + }, + { + "number": 3570, + "title": "Prove mixed Q8 call-count bounds and exclude eight calls for 3/1", + "head": "849fcf8dfb3c34693ed54d911cd9914955a306b7", + "author": "petalas" + }, + { + "number": 3569, + "title": "Prove residual reader floors for crossing closure cells", + "head": "51f4425e91f39c6e966007f1ab0ec9172653d83d", + "author": "petalas" + }, + { + "number": 3568, + "title": "Check the R480 leaver rank bill", + "head": "10fb1bac9393d1e651da927b9dc4988c0cf4b3b3", + "author": "jwr404" + }, + { + "number": 3567, + "title": "Bound the tetrad alphabet's exhibited effective rank", + "head": "9d7a2f0da3954651767d18103ee459534610ff60", + "author": "jwr404" + }, + { + "number": 3566, + "title": "Bind P112 tetrad decoder to selected ports; no kappa change", + "head": "ebd6b92c43239d76b1a59e29f574563494388f6a", + "author": "Gonzalo-Mier" + }, + { + "number": 3565, + "title": "Audit the 2980/2981 archive receipt", + "head": "936468ec4cb74ed383c6e3c8248483d112cd2a43", + "author": "jwr404" + }, + { + "number": 3564, + "title": "feat(research): bind strict plans to a sealed GL2 root", + "head": "c0c923a2cd5246cab970aaffea5f4fafea643f91", + "author": "petalas" + } + ], + "related_scope_notes": [ + { + "pr": 3574, + "head": "eb11cd484c23990c250bdc67ae61829ebae35536", + "assessment": "Adjacent P104 rank-one hosting threshold for a stated native-channel/unit-step-helper profile. Its README explicitly leaves native ADDs, owners, routing, precision and tape unpriced; it does not supply K coefficients, the Y91/Y90 observation, or a complete physical caller for this package." + }, + { + "pr": 3565, + "head": "936468ec4cb74ed383c6e3c8248483d112cd2a43", + "assessment": "Archival retention audit of2980/2981. Not new coefficient/consumer mathematics." + } + ], + "same_scope_body_result_observed": false, + "pr3554": { + "head": "9f225dda71c45e2e6fea70e2ff5ef9f27192e1f9", + "state": "open", + "review_count": 0, + "comments": [ + { + "id": 6246205749, + "author": "Clear1nsight", + "updated_at": "2026-10-18T05:42:33Z" + } + ] + }, + "root_supplied_discussion_checkpoint": { + "checked_utc_approx": "2026-10-18T06:38Z", + "source": "root browser report, not separately inspected by this agent", + "2750": "Latest12 top-level/reply IDs; newest remains our19012530 claim,0 replies, no newerP104 claim", + "1166": "Latest8 IDs; newest19012755; new3564/3569/3570/3571/3572/3573 distinct", + "limitations": "Older hidden replies not exhaustively paginated" + }, + "decision": "Continue to publication of frozen bounded interface audit; no observed same-scope completion or changed canonical priority. Preserve source inputs and family stop.", + "limitations": [ + "This is a bounded newest100 open/100 closed refresh, not a new complete currentopen/closed pagination.", + "Complete281-open snapshot remains timestamped06:06:39UTC. Older records outsidefreshprefix may havechanged.", + "No arbitrary code-diff or unpublished-work coverage.", + "Discussion findings attributed to roots bounded UI read; no exhaustive Discussion pagination." + ], + "non_atomic": true + }, + "baseline_reuse": "The preceding PASS_RESEARCH_BASELINE_BINDINGS_ONLY orientation is reused under unchanged canonical/selected source bindings. No new selected construction or historical cold replay is claimed." +} diff --git a/research/p104-kernel-consumer/VERIFY.json b/research/p104-kernel-consumer/VERIFY.json new file mode 100644 index 0000000000..9c42883ffb --- /dev/null +++ b/research/p104-kernel-consumer/VERIFY.json @@ -0,0 +1,51 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-rounded-collector/inputs/NATIVE.json.gz", + "research/p104-rounded-collector/inputs/WORD.json", + "research/p104-stagewise-entrance/PROOF.md", + "research/p104-stagewise-entrance/admission.py", + "research/p104-stagewise-entrance/classifier.py", + "research/p104-stagewise-entrance/inputs/PR3382_PROOF.md", + "research/p104-stagewise-entrance/inputs/PR3416_PROOF.md", + "research/p104-stagewise-entrance/inputs/pr3382_model.py", + "research/p104-stagewise-entrance/source.py", + "research/p104-omitted-completion/CERTIFICATE.json", + "research/p104-omitted-completion/README.md", + "research/p104-omitted-completion/PROOF.md", + "research/p104-omitted-frame-adapters/ADAPTERS.json", + "research/p104-omitted-frame-adapters/README.md", + "research/p104-omitted-frame-adapters/PROOF.md", + "LICENSE", + "NOTICE", + "upstream/LICENSE", + "research/p104-rounded-collector/PREDECESSORS.json", + "research/p104-rounded-collector/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Authenticate20 frozen inputs; independent full p and physical arrays; exact event1099 failure;5398-event strong control; full symbolic paired-family denominator certificate; reverse X0 row, late-sign and cleanup controls; actual collector cost inventory; typed read-only receipt." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Repeat the identical bounded mathematical contract with Python assertions disabled; explicit guards and complete typed receipt remain required." + } + ] +} diff --git a/research/p104-kernel-consumer/literal.py b/research/p104-kernel-consumer/literal.py new file mode 100644 index 0000000000..e1669d705e --- /dev/null +++ b/research/p104-kernel-consumer/literal.py @@ -0,0 +1,344 @@ +"""Two exact P104 kernel-witness executions, with independent native arithmetic. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +Gaussian and signed-floor formulas are adapted with credit from the separately +written PR3554 independent.py (SHA256 e7e06d875ffcf1b34946f844141b3c9fcf2f7395e35aba4e18277e6fea279428). +No predecessor executable is imported. The orchestrator authenticates the raw +WORD/NATIVE bytes; this module binds their complete occurrence/frame structure. +Only the specified p and 4p fixtures are executed; all other initial banks are zero. +""" + +from collections import Counter +from fractions import Fraction +import hashlib +import json + + +RANK = 9 +SIZE = 512 +ZERO = (0, 0) +WATCH_CUTS = (1099, 2121, 3278, 4241, 5086, 5397) +WATCH_BANKS = ('Q0', 'G0', 'X0') + + +class LiteralFailure(ValueError): + def __init__(self, record): + super().__init__(record['kind']) + self.record = record + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def field(values): + need(type(values) in (list, tuple) and len(values) == SIZE, 'rank-nine field') + need(all(type(z) in (list, tuple) and len(z) == 2 + and all(type(x) is int for x in z) for z in values), 'Gaussian integer field') + return [tuple(z) for z in values] + + +def plus(a, b): + return a[0] + b[0], a[1] + b[1] + + +def minus(a, b): + return a[0] - b[0], a[1] - b[1] + + +def rotate(z, phase): + a, b = z + return ((a, b), (-b, a), (-a, -b), (b, -a))[phase % 4] + + +def newton_failure(values): + """Return a first exact Mobius-coefficient divisibility witness, if any.""" + if not any(z != ZERO for z in values): + return None + coefficients = list(values) + for bit in range(RANK): + step = 1 << bit + for mask in range(SIZE): + if mask & step: + coefficients[mask] = minus(coefficients[mask], coefficients[mask ^ step]) + for mask, original in enumerate(coefficients): + a, b = original + for divided in range(mask.bit_count()): + if (a + b) % 2 or (b - a) % 2: + return {'mask': mask, 'degree': mask.bit_count(), 'mobius_coefficient': original, + 'pi_divisions_completed': divided, 'remaining_gaussian': (a, b)} + a, b = (a + b) // 2, (b - a) // 2 + return None + + +def bind(word, native): + need(len(word['program']) == 5398 and len(word['initial_frames']) == 358, + 'frozen full-word dimensions') + need(word['chart'] == native['chart'], 'word/native chart convention') + need(len(native['transports']) == 1245, 'frozen native class count') + result = {} + for record in native['transports']: + rank = record['recipe']['rank'] + need(type(rank) is int and 1 <= rank <= RANK, 'native rank') + for event in record['events']: + need(type(event) is int and 0 <= event < 5398 and event not in result, + 'unique bounded native occurrence') + row = word['program'][event] + need(row[0] == 'transport' and row[2:] == [record['old'], record['new'], rank], + 'exact native occurrence and frame binding') + result[event] = record['recipe'] + expected = {i for i, row in enumerate(word['program']) if row[0] == 'transport'} + need(set(result) == expected and len(result) == 2070, 'all actual native occurrences') + return result + + +def wrapper_plan(raw): + rows, linear, quadratic = (raw[k] for k in ('matrix_rows', 'linear_Z4', 'quadratic_rows')) + need(len(rows) == len(linear) == len(quadratic) == RANK, 'wrapper dimensions') + need(all(type(x) is int and 0 <= x < SIZE for x in rows + quadratic), 'binary wrapper rows') + need(all(type(x) is int and 0 <= x < 4 for x in linear), 'linear Z4 phase') + need(type(raw['offset']) is int and 0 <= raw['offset'] < SIZE, 'affine offset') + need(type(raw['phase']) is int and 0 <= raw['phase'] < 4, 'global phase') + result = [] + for address in range(SIZE): + target = raw['offset'] ^ sum(((address & row).bit_count() % 2) << j + for j, row in enumerate(rows)) + phase = raw['phase'] + for j in range(RANK): + if address & (1 << j): + upper = quadratic[j] & ~((1 << (j + 1)) - 1) + phase += linear[j] + 2 * (upper & address).bit_count() + result.append((target, phase % 4)) + need({target for target, _ in result} == set(range(SIZE)), 'wrapper permutation') + return result + + +def wrapper(values, mapping, inverse): + result = [ZERO] * SIZE + for source, (target, phase) in enumerate(mapping): + if inverse: + result[source] = rotate(values[target], -phase) + else: + result[target] = rotate(values[source], phase) + return result + + +def pair(a, b, inverse, event, bit, address): + dr, di = minus(a, b) + ar, ai = plus(a, b) + sign = -1 if inverse else 1 + numerators = ((ar - sign * di, ai + sign * dr), + (ar + sign * di, ai - sign * dr)) + if any(x % 2 for z in numerators for x in z): + raise LiteralFailure({'kind': 'nonintegral_ideal_native_pair', 'event': event, + 'bit': bit, 'address': address, 'inverse': inverse, + 'input_pair': (a, b), 'twice_ideal_outputs': numerators}) + ideal = tuple((r // 2, i // 2) for r, i in numerators) + midpoint = plus(b, (dr // 2, di // 2)) + turned = (di, -dr) if inverse else (-di, dr) + second = minus(midpoint, (turned[0] // 2, turned[1] // 2)) + literal = (plus(second, turned), second) + need(literal == ideal, 'literal signed-floor pair differs from integral ideal pair') + return literal + + +class Arithmetic: + def __init__(self, bound): + self.bound = bound + self.cache = {} + + def plan(self, raw): + key = canonical(raw) + if key not in self.cache: + need(len(self.cache) < 2490, 'bounded native wrapper cache') + self.cache[key] = wrapper_plan(raw) + return self.cache[key] + + def native(self, values, event, inverse, counts): + recipe = self.bound[event] + counts['native_events_entered'] += 1 + if not any(z != ZERO for z in values): + counts['zero_native_events'] += 1 + counts['zero_native_pairs_proved_zero'] += recipe['rank'] * (SIZE // 2) + return list(values) + first, last = ('left', 'right') if inverse else ('right', 'left') + result = wrapper(values, self.plan(recipe[first]), inverse) + bits = reversed(range(recipe['rank'])) if inverse else range(recipe['rank']) + for bit in bits: + step = 1 << bit + for address in range(SIZE): + if not address & step: + result[address], result[address | step] = pair( + result[address], result[address | step], inverse, event, bit, address) + counts['completed_literal_ideal_pairs'] += 1 + result = wrapper(result, self.plan(recipe[last]), inverse) + counts['active_native_events_completed'] += 1 + counts['active_native_rank_mass'] += recipe['rank'] + return result + + +def derive_p(word, arithmetic): + """Derive a44's zero-gap field from the actual Y91 path, without K imports.""" + row = word['program'][1817] + need(row[:4] == ['add', 'D27', 'Y91', '1/4'], 'a44 actual read event') + need(word['program'][1819][:4] == ['add', 'D27', 'Y90', '1/4'], 'a44 cancellation read') + path = [i for i, event in enumerate(word['program'][:1817]) + if event[:2] == ['transport', 'Y91']] + need(word['initial_frames']['Y91'] == [], 'empty Y91 source frame') + need(not any(event[1] == 'D27' for event in word['program'][1818:1819]), + 'zero-native D27 interval') + values = [(-4, 0) if address & 15 == 15 else ZERO for address in range(SIZE)] + counts = Counter() + current = tuple(row[4]) + for event in reversed(path): + literal = word['program'][event] + need(tuple(literal[3]) == current, 'inverse Y91 path composability') + values = arithmetic.native(values, event, True, counts) + current = tuple(literal[2]) + need(current == (), 'inverse Y91 path reaches original source frame') + need(newton_failure(values) is None, 'derived p belongs to B9') + return values, {'coefficient_slot': 44, 'coefficient_mask': 15, + 'read_event': 1817, 'cancellation_event': 1819, 'source_path': path, + 'profile': 'E9 delta15 = -4 on the 32 supersets of mask15', + 'inverse_path_arithmetic': dict(counts), 'p_sha256': digest(values)} + + +def increment(values, coefficient, event, source, target): + numerator, denominator = coefficient.as_integer_ratio() + result = [] + for address, z in enumerate(values): + for component, value in enumerate(z): + product = numerator * value + if product % denominator: + raise LiteralFailure({'kind': 'nonintegral_fractional_addend', 'event': event, + 'source': source, 'target': target, 'address': address, + 'component': ('real', 'imaginary')[component], + 'source_value': z, 'coefficient': str(coefficient), + 'exact_increment': str(Fraction(product, denominator))}) + result.append((numerator * z[0] // denominator, numerator * z[1] // denominator)) + return result + + +def advance(state, frames, row, event, arithmetic, counts): + op, target = row[:2] + if op == 'transport': + need(frames[target] == tuple(row[2]), 'actual native input frame') + state[target] = arithmetic.native(state[target], event, False, counts) + frames[target] = tuple(row[3]) + elif op == 'add': + source = row[2] + need(frames[target] == frames[source] == tuple(row[4]), 'equal-frame ADD') + coefficient = Fraction(str(row[3])) + addend = increment(state[source], coefficient, event, source, target) + state[target] = [plus(a, b) for a, b in zip(state[target], addend, strict=True)] + counts['weighted_adds'] += 1 + if coefficient.denominator > 1: + counts['fractional_adds'] += 1 + counts['nonzero_fractional_adds'] += int(any(z != ZERO for z in addend)) + elif op == 'sign': + need(str(row[2]) == '-1' and frames[target] == tuple(row[3]), 'actual signed frame') + state[target] = [(-a, -b) for a, b in state[target]] + counts['signs'] += 1 + elif op == 'zero': + need(target not in state, 'private bank absent before initialization') + state[target], frames[target] = [ZERO] * SIZE, tuple(row[2]) + counts['private_zero'] += 1 + else: + need(op == 'erase' and frames[target] == tuple(row[2]), 'actual private erase frame') + bad = next((i for i, z in enumerate(state[target]) if z != ZERO), None) + if bad is not None: + raise LiteralFailure({'kind': 'nonzero_private_erase', 'event': event, + 'target': target, 'address': bad, 'value': state[target][bad]}) + del state[target], frames[target] + counts['private_zero_erase'] += 1 + + +def snapshot(state, frames): + return {bank: {'frame': list(frames[bank]), 'values': list(state[bank])} for bank in WATCH_BANKS} + + +def trace(word, arithmetic, p, multiplier): + frames = {bank: tuple(value) for bank, value in word['initial_frames'].items()} + state = {bank: [ZERO] * SIZE for bank in frames} + need(frames['Y91'] == frames['Y90'] == (), 'paired initial source frame') + state['Y91'] = [(multiplier * a, multiplier * b) for a, b in p] + state['Y90'] = [(-a, -b) for a, b in state['Y91']] + counts, checkpoints = Counter(), {} + first_non_B, failure = None, None + for event, row in enumerate(word['program']): + try: + advance(state, frames, row, event, arithmetic, counts) + except LiteralFailure as error: + failure = {**error.record, 'actual_word_event': row} + break + counts['events_completed'] += 1 + target = row[1] + if first_non_B is None and target in state: + witness = newton_failure(state[target]) + if witness is not None: + first_non_B = {'event': event, 'bank': target, + 'frame': list(frames[target]), 'witness': witness} + if event in WATCH_CUTS: + checkpoints[str(event)] = snapshot(state, frames) + complete = failure is None + if complete: + need(frames == {b: tuple(f) for b, f in word['final_frames'].items()}, + 'all final physical frames exactly match original word') + need(counts['events_completed'] == 5398 and counts['native_events_entered'] == 2070, + 'complete actual full-word inventory') + need(counts['private_zero'] == counts['private_zero_erase'] == 8, 'all eight private erasures') + receipt = {'multiplier': multiplier, 'status': 'PASS_EXACT_LITERAL_WORD' if complete else 'EXACT_LITERAL_FAILURE', + 'counts': dict(counts), 'first_literal_failure': failure, + 'first_completed_event_outside_B9': first_non_B, + 'checkpoint_sha256': {cut: {bank: digest(item['values']) for bank, item in values.items()} + for cut, values in checkpoints.items()}, + 'final_frames_checked': complete, + 'nonzero_final_banks': sorted(b for b, v in state.items() if any(z != ZERO for z in v)) if complete else None, + 'final_Q0_sha256': digest(state['Q0']) if complete else None, + 'final_X0_sha256': digest(state['X0']) if complete else None} + return {'receipt': receipt, 'checkpoints': checkpoints, + 'final_Q0': list(state['Q0']) if complete else None, + 'final_X0': list(state['X0']) if complete else None, + 'final_Y90': list(state['Y90']) if complete else None, + 'final_Y91': list(state['Y91']) if complete else None} + + +def run_literal(word, native, p): + """Probe only the supplied K a44 witness and its strong-domain multiple four. + + The caller authenticates raw sources. All other 356 initial public banks, + including dirty D/Q roles, are zero in these two witnesses. The returned + complete Q0/G0/X0 checkpoint arrays are for exact comparison by the caller. + Zero native branches are evaluated by their proved zero action, not counted + as executed nonzero pair comparisons. No predecessor suite is invoked. + """ + p = field(p) + arithmetic = Arithmetic(bind(word, native)) + derived, derivation = derive_p(word, arithmetic) + need(p == derived and any(z != ZERO for z in p), 'exact independently derived nonzero K witness') + unscaled = trace(word, arithmetic, p, 1) + strong = trace(word, arithmetic, p, 4) + need(strong['receipt']['status'] == 'PASS_EXACT_LITERAL_WORD' + and strong['receipt']['first_completed_event_outside_B9'] is None, + '4p strong-domain word must execute exactly in B9') + y_writes = [(i, row) for i, row in enumerate(word['program']) if row[1].startswith('Y')] + need(len(y_writes) == 728 and all(row[0] == 'transport' for _, row in y_writes), + 'actual word has only bank-local Y writes') + return {'receipt': {'status': 'PASS_TWO_LITERAL_KERNEL_PROBES', 'derivation': derivation, + 'fixture_scope': 'Y91=p,Y90=-p or Y91=4p,Y90=-4p; all other initial banks zero.', + 'all_native_occurrences_bound': 2070, 'all_Y_target_events': 728, + 'cross_bank_Y_writes': 0, + 'actual_final_Y_frame_dimensions': dict(Counter(len(word['final_frames']['Y' + str(i)]) + for i in range(104))), + 'unscaled': unscaled['receipt'], 'strong': strong['receipt'], + 'zero_branch_rule': 'Every affine monomial and each exact signed-floor pair sends an all-zero field to zero.'}, + 'arrays': {'derived_p': derived, 'unscaled': unscaled, 'strong': strong}} diff --git a/research/p104-kernel-consumer/observable.py b/research/p104-kernel-consumer/observable.py new file mode 100644 index 0000000000..28f575c849 --- /dev/null +++ b/research/p104-kernel-consumer/observable.py @@ -0,0 +1,355 @@ +"""A source-bound adjoint audit of one P104 kernel observable. + +This module does not execute rounded native arithmetic. It checks one named +normalized endpoint, assuming the credited native covariance, and returns the +frames that any physical interpretation must respect. Literal admission and +the caller bill are separate obligations. + +Clear1nsight, with OpenAI assistance. Apache-2.0. +""" + +from collections import Counter +from fractions import Fraction +import hashlib +import json + + +WORD_SHA = "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50" +COMPLETION_SHA = "f68a2e6f3bd771b9692772909df200102350a80deda35532f3cc348b75d0c044" +ADAPTERS_SHA = "db424edfb316f06f4913946b2b0cafa2f200b75392cacb35244b8705db02387c" +NATIVE_SHA = "ab91c78835c3e10cf3b2cb8a5d4e0b7cfc3df1ae5a811298d27842f2193e1e3d" +FULL = [256, 128, 64, 32, 16, 8, 4, 2, 1] +O = [256, 136, 64, 40, 16, 4, 2, 1] +O0 = [257, 129, 65, 33, 16, 9, 5, 2] +D_BANKS = ["D31", "D30", "D29", "D28", "D27"] + + +class AuditError(ValueError): + """The exact finite contract was not met.""" + + +def require(condition, message): + if not condition: + raise AuditError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def authenticated(raw, expected, name): + require(type(raw) is bytes, name + " must be bytes") + require(hashlib.sha256(raw).hexdigest() == expected, name + " hash") + value = json.loads(raw) + require(type(value) is dict, name + " object") + return value + + +def rational(value): + require(type(value) in (int, str), "coefficient type") + result = Fraction(value) + require(result in (Fraction(1, 4), Fraction(-1, 4), Fraction(1, 2), + Fraction(-1, 2), -2, -1, 1, 2), "coefficient alphabet") + return result + + +def fraction_record(value): + return [value.numerator, value.denominator] + + +def row_record(row): + return {bank: fraction_record(value) for bank, value in sorted(row.items())} + + +def frame(value): + require(type(value) is list and len(value) <= 9, "frame list") + require(all(type(x) is int and 0 < x < 512 for x in value), "frame entry") + require(len(value) == len(set(value)), "frame duplicate") + return value + + +def frame_audit(word): + """Check every syntactic frame transition, not its native semantics.""" + program = word["program"] + initial, final = word["initial_frames"], word["final_frames"] + require(type(program) is list and len(program) == 5398, "word length") + require(type(initial) is dict and type(final) is dict, "frame dictionaries") + require(set(initial) == set(final) and len(initial) == 358, "public banks") + state = {bank: frame(value)[:] for bank, value in initial.items()} + after = [] + counts = Counter() + for event, instruction in enumerate(program): + require(type(instruction) is list and instruction, "instruction list") + op, bank = instruction[:2] + require(type(bank) is str, "bank name") + counts[op] += 1 + if op == "zero": + require(len(instruction) == 3 and bank not in state, "zero lifetime") + state[bank] = frame(instruction[2])[:] + else: + require(bank in state, "live target") + if op == "transport": + require(len(instruction) == 5, "transport arity") + require(state[bank] == frame(instruction[2]), "transport entrance") + require(type(instruction[4]) is int, "native rank type") + require(1 <= instruction[4] <= 9, "native rank") + state[bank] = frame(instruction[3])[:] + elif op == "add": + require(len(instruction) == 5, "ADD arity") + source = instruction[2] + require(type(source) is str and source in state, "live source") + require(source != bank, "distinct ADD banks") + require(state[bank] == state[source] == frame(instruction[4]), + "same-frame ADD") + rational(instruction[3]) + require(not bank.startswith("Y"), "Y is transport-only") + elif op == "sign": + require(len(instruction) == 4, "sign arity") + require(rational(instruction[2]) == -1, "sign coefficient") + require(state[bank] == frame(instruction[3]), "sign frame") + elif op == "erase": + require(len(instruction) == 3 and bank not in initial, + "private erasure") + require(state[bank] == frame(instruction[2]), "erase frame") + del state[bank] + else: + raise AuditError("unknown opcode " + str(op)) + after.append({b: state[b][:] for b in ("D1", "Q0", "G0", "X0", "C") + if b in state}) + require(state == final, "all declared endpoint frames") + require(dict(counts) == {"transport": 2070, "sign": 208, "add": 3104, + "zero": 8, "erase": 8}, "operation inventory") + ys = sorted(bank for bank in initial if bank.startswith("Y")) + require(set(ys) == {"Y" + str(i) for i in range(104)}, "104 Y banks") + require(all(initial[b] == [] and len(final[b]) == 8 for b in ys), + "actual Y endpoint dimensions") + bindings = {b: [initial[b], final[b]] for b in ys} + return after, dict(counts), bindings + + +def adjoint(program, stop, bank, omitted=()): + """Pull one output covector backward; no forward scalar state is used.""" + require(type(stop) is int and 0 <= stop <= len(program), "adjoint cut") + row = {bank: Fraction(1)} + for event in range(stop - 1, -1, -1): + if event in omitted: + continue + instruction = program[event] + op, target = instruction[:2] + coefficient = row.get(target, Fraction(0)) + if op == "add" and coefficient: + source = instruction[2] + value = row.get(source, Fraction(0)) + coefficient * rational(instruction[3]) + if value: + row[source] = value + else: + row.pop(source, None) + elif op == "sign" and coefficient: + row[target] = -coefficient + elif op == "zero": + row.pop(target, None) + elif op == "erase": + require(not coefficient, "backward erased lifetime") + return row + + +def pair_value(row): + return row.get("Y91", Fraction(0)) - row.get("Y90", Fraction(0)) + + +def source_groups(program): + groups = [] + flat = [] + for bank in D_BANKS: + reads = [] + for event, instruction in enumerate(program[:2025]): + if instruction[:2] != ["add", bank]: + continue + require(instruction[2].startswith("Y"), "D producer source") + require(rational(instruction[3]) == Fraction(1, 4), "D producer quarter") + reads.append({"source": instruction[2], "event": event, + "frame": instruction[4], "slot": len(flat)}) + flat.append(instruction[2]) + expected = {bank: Fraction(1)} + for read in reads: + expected[read["source"]] = Fraction(1, 4) + require(adjoint(program, 2025, bank) == expected, "actual D cut row") + groups.append({"bank": bank, "reads": reads, "rho_coefficient": [1, 4]}) + require([len(g["reads"]) for g in groups] == [3, 7, 7, 11, 24], "five groups") + require(len(flat) == len(set(flat)) == 52, "distinct 52 Y sources") + require(flat[44:46] == ["Y91", "Y90"], "actual a44 source slots") + require([g["reads"][-1]["source"] for g in groups] == + ["Y99", "Y100", "Y66", "Y72", "Y80"], "terminal sources") + rho = [sum((Fraction(int(r["source"] == "Y91") - + int(r["source"] == "Y90"), 4) for r in g["reads"]), + Fraction(0)) for g in groups] + require(rho == [0] * 5, "rho5 kernel direction") + return groups, rho + + +def named_reads(program): + wanted = { + 1099: ["add", "D1", "Y90", "1/4", [381, 241, 2]], + 1817: ["add", "D27", "Y91", "1/4", O], + 1819: ["add", "D27", "Y90", "1/4", O], + 2118: ["add", "C", "D1", 1, O0], + 2121: ["add", "Q0", "C", "1", [400]], + 2166: ["add", "D1", "Y90", "-1/4", FULL], + 3025: ["add", "G0", "Q0", 1, [400]], + 3278: ["add", "X0", "G0", -2, [400, 85]], + 4104: ["add", "G0", "Q0", -1, FULL], + 4241: ["add", "Q0", "Y90", "-1/4", FULL], + 5086: ["sign", "X0", "-1", [258, 130, 64, 32, 16, 8, 4, 1]], + 5190: ["transport", "X0", [258, 130, 64, 32, 16, 8, 4, 1], FULL, 1], + } + for event, expected in wanted.items(): + require(canonical(program[event]) == canonical(expected), "named event " + str(event)) + d27_reads = [i for i, e in enumerate(program) if e[0] == "add" and e[2] == "D27"] + require(d27_reads == [916, 2030, 2034], "all D27 source reads") + require(not any(1817 < i < 1819 for i in d27_reads), "unobserved D27 interval") + pair_reads = [{"event": i, "instruction": e} for i, e in enumerate(program) + if e[0] == "add" and e[2] in ("Y90", "Y91")] + d1_pair = [r for r in pair_reads if r["instruction"][1] == "D1"] + require([r["event"] for r in d1_pair] == [1099, 2166], "D1 pair asymmetry") + return {"events": [{"event": i, "instruction": e} for i, e in sorted(wanted.items())], + "all_pair_reads": pair_reads, "all_D27_source_reads": d27_reads, + "intervening_event": {"event": 1818, "instruction": program[1818]}} + + +def cut_audit(program, after): + cuts = [(1099, "D1", "-1/4"), (2118, "C", "-1/4"), + (2121, "Q0", "-1/4"), (2166, "D1", "0"), + (3025, "G0", "-1/4"), (3278, "X0", "1/2"), + (4104, "G0", "0"), (4241, "Q0", "0"), + (5085, "X0", "1/2"), (5086, "X0", "-1/2"), + (5190, "X0", "-1/2")] + out = [] + for event, bank, expected in cuts: + row = adjoint(program, event + 1, bank) + require(pair_value(row) == Fraction(expected), "named adjoint cut") + require(all(b != "C" for b in row), "private zero eliminated") + record = row_record(row) + out.append({"event_after": event, "bank": bank, "frame": after[event][bank], + "pair_value": fraction_record(pair_value(row)), + "row_sha256": digest(record), "row_nonzeros": len(record), + "Y91_coefficient": fraction_record(row.get("Y91", Fraction(0))), + "Y90_coefficient": fraction_record(row.get("Y90", Fraction(0)))}) + require(adjoint(program, 2128, "C") == {}, "actual collector C erasure") + for bank in ("D1", "Q0", "G0"): + require(adjoint(program, len(program), bank) == {bank: Fraction(1)}, + "normalized arbitrary-dirty restoration " + bank) + gather = adjoint(program, 2122, "Q0") + require(gather.get("Q0") == 1 and all(b == "Q0" or b.startswith("Y") + for b in gather), "Q0 dirty D cancellation") + return out, row_record(gather) + + +def completion_audit(program, completion, adapters, word): + require(completion["source_sha256"] == { + "research/p104-rounded-collector/inputs/WORD.json": WORD_SHA, + "research/p104-rounded-collector/inputs/NATIVE.json.gz": NATIVE_SHA}, + "completion original sources") + a, c = completion["factor"]["A"], completion["factor"]["C"] + require(type(a) is list and len(a) == 8, "eight credited query rows") + require(all(type(r) is dict and all(type(x) is int for x in r.values()) + for r in a), "integer A rows") + c0 = c["X0"] + require(type(c0) is list and all(type(x) is int for x in c0), "integer C X0") + require(c0 == [1, 0, 0, 0, 0, 0, 0, 0], "X0 basis row") + delta = [r.get("Y91", 0) - r.get("Y90", 0) for r in a] + require(delta == [-1, 1, 0, 0, 1, -1, 1, 1], "credited pair query vector") + final_row = adjoint(program, len(program), "X0") + require(final_row.pop("X0", None) == 1, "X0 original dirty coefficient") + expected = {"Y" + str(i): sum((Fraction(c0[j] * a[j].get("Y" + str(i), 0), 2) + for j in range(8)), Fraction(0)) for i in range(104)} + expected = {b: x for b, x in expected.items() if x} + require(final_row == expected, "full X0 adjoint row versus published CA/2") + require(pair_value(final_row) == Fraction(-1, 2), "observable coefficient") + gap = completion["unfilled_physical_frame_gaps"]["X0"] + require(gap == [word["initial_frames"]["X0"], word["final_frames"]["X0"]], + "X0 projection omission and endpoint gap") + x_entries = [x for x in adapters["omitted_banks"] if x["bank"] == "X0"] + require(x_entries == [{"bank": "X0", "recipe_key": [386], "rank": 8}], + "credited X0 native-only adapter") + recipes = [r for r in adapters["recipes"] if r["old"] == [386] and r["new"] == FULL] + require(len(recipes) == 1 and recipes[0]["recipe"]["rank"] == 8, "unique adapter") + require(adapters["projection_event_sha256"] == completion["closure"]["events_sha256"], + "same credited projection") + return {"A_pair_difference": delta, "C_X0": c0, + "X0_Y_row": row_record(final_row), "X0_Y_nonzeros": len(final_row), + "X0_pair_coefficient": [-1, 2], "X0_frame_gap": gap, + "X0_omitted_from_4027_event_projection": True, + "adapter_rank": 8, "adapter_recipe_sha256": digest(recipes[0]["recipe"]), + "credited_adapter_certificate": recipes[0]["certificate"]} + + +def controls(program, raws): + faulty = adjoint(program, len(program), "X0", omitted=(5086,)) + require(pair_value(faulty) == Fraction(1, 2), "omitted sign separating control") + dirty = adjoint(program, len(program), "Q0", omitted=(4241,)) + require(pair_value(dirty) == Fraction(-1, 4), "omitted Q0 cleanup control") + corruption = [] + for raw, sha, name in raws: + try: + authenticated(raw + b" ", sha, name) + except AuditError: + corruption.append(name) + else: + raise AuditError("source corruption was accepted") + return {"omitted_sign_5086_X0_pair": [1, 2], + "omitted_Q0_cleanup_4241_pair": [-1, 4], + "source_corruption_rejected": corruption} + + +def analyze(word_bytes, completion_certificate_bytes, adapters_bytes): + """Return exact named scalar/caller evidence; execute no native suite.""" + raws = [(word_bytes, WORD_SHA, "WORD"), + (completion_certificate_bytes, COMPLETION_SHA, "PR3462 certificate"), + (adapters_bytes, ADAPTERS_SHA, "PR3469 adapters")] + word, completion, adapters = [authenticated(*r) for r in raws] + program = word["program"] + after, counts, y_bindings = frame_audit(word) + groups, rho = source_groups(program) + reads = named_reads(program) + cuts, gather = cut_audit(program, after) + result = completion_audit(program, completion, adapters, word) + paths = {b: [{"event": i, "instruction": e} for i, e in enumerate(program) + if e[:2] == ["transport", b]] + for b in ("Y90", "Y91", "D1", "Q0", "G0", "X0")} + return { + "schema_version": 1, "status": "PASS", + "method": "One-output reverse adjoints and exact source/certificate binding", + "source_sha256": {name: sha for _, sha, name in raws}, + "event_numbering": "zero-based source WORD program indices", + "word_operation_counts": counts, + "five_source_groups": groups, "rho5_pair_response": [fraction_record(x) for x in rho], + "source_read_audit": reads, "named_cuts": cuts, + "Q0_after_2121_initial_row": gather, "completion": result, + "named_native_paths": paths, + "Y_endpoint_audit": {"count": 104, "all_initial_frames_empty": True, + "all_final_dimensions": 8, "all_transport_only": True, + "bindings_sha256": digest(y_bindings), + "Y90": y_bindings["Y90"], "Y91": y_bindings["Y91"]}, + "restoration": {"D1_Q0_G0": "initial normalized rows; physical final frame F", + "C": "actual 2114..2128 collector has zero adjoint at erasure", + "Y": "normalized source payloads retained at their actual final frames"}, + "separation": { + "formal_pair": "Y91=p, Y90=-p, all other initial increments zero", + "rho5": "zero on all five group readouts", + "Q0_after_2121": "-p/4", "X0_after_3278": "+p/2", + "X0_final": "-p/2", "strong_4p_X0_final": "-2p", + "claim": "The required X0 residual cannot factor through rho5 alone", + "physical_meaning": "X0 increment is J_F(-p/2), conditional on native covariance and admission", + "limitation": "This does not erase retained Y/coefficient outputs or prove a benefit from L/S", + }, + "controls": controls(program, raws), + "scope_limits": [ + "No literal full-word admission is proved by this scalar audit", + "No fresh full-map rank, recipient closure, or adapter optimality is claimed", + "Paid acquisition, physical layouts/routes, widths, and supplier advantage are not inferred", + ], + } diff --git a/research/p104-kernel-consumer/primary.py b/research/p104-kernel-consumer/primary.py new file mode 100644 index 0000000000..0cc251d10f --- /dev/null +++ b/research/p104-kernel-consumer/primary.py @@ -0,0 +1,210 @@ +"""Source-derived K column and one-bank ideal consumer oracle. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +The authenticated PR3467 codec and PR3382 Gaussian arithmetic are reused with +credit. Independent literal.py and observable.py import none of that code. +""" + +from collections import Counter, deque +from fractions import Fraction +import hashlib +import json + + +SIZE = 512 +ZERO = (0, 0) +WATCH = (1099, 2121, 3278, 4241, 5086, 5397) +BANKS = ("Q0", "G0", "X0") + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def digest(value): + return hashlib.sha256(json.dumps(value, sort_keys=True, + separators=(",", ":")).encode()).hexdigest() + + +def fraction(value): + return [value.numerator, value.denominator] + + +def scaled(values, factor): + out = [] + for real, imag in values: + parts = (factor * real, factor * imag) + require(all(x.denominator == 1 for x in parts), "integral oracle field") + out.append(tuple(x.numerator for x in parts)) + return out + + +def symbolic(word): + """Propagate one symbolic paired input, including every late sign.""" + program = word["program"] + state = {bank: Fraction(0) for bank in word["initial_frames"]} + state["Y91"], state["Y90"] = Fraction(1), Fraction(-1) + frames = {bank: list(frame) for bank, frame in word["initial_frames"].items()} + counts, stored_denominators, product_denominators = Counter(), Counter(), Counter() + snapshots, erasures, observed = {}, [], [] + maximum = Fraction(1) + for event, row in enumerate(program): + op, target = row[:2] + counts[op] += 1 + if op == "transport": + require(frames[target] == row[2], "symbolic source frame") + frames[target] = list(row[3]) + elif op == "add": + source = row[2] + require(frames[target] == frames[source] == row[4], "symbolic common frame") + product = Fraction(str(row[3])) * state[source] + require(4 % product.denominator == 0, "ADD product quarter denominator") + product_denominators[str(product.denominator)] += 1 + state[target] += product + elif op == "sign": + require(str(row[2]) == "-1" and frames[target] == row[3], "symbolic sign") + state[target] = -state[target] + elif op == "zero": + require(target not in state, "symbolic private allocation") + state[target], frames[target] = Fraction(0), list(row[2]) + else: + require(op == "erase" and state[target] == 0 and frames[target] == row[2], + "symbolic private erasure") + erasures.append(event) + del state[target], frames[target] + if target in state: + value = state[target] + require(4 % value.denominator == 0, "stored quarter denominator") + stored_denominators[str(value.denominator)] += 1 + maximum = max(maximum, abs(value)) + if event == 2024: + observed = [state[b] for b in ("D31", "D30", "D29", "D28", "D27", "Q7")] + if event in WATCH: + snapshots[str(event)] = { + bank: {"coefficient": state[bank], "frame": list(frames[bank])} + for bank in BANKS} + require(frames == word["final_frames"], "all symbolic final frames") + require(observed == [0] * 6, "six original collector fields vanish") + require(state["X0"] == Fraction(-1, 2), "late signed X0 response") + require(state["Q0"] == state["D1"] == state["G0"] == 0, "named dirty return") + require(counts == {"transport": 2070, "add": 3104, "sign": 208, "zero": 8, "erase": 8}, + "all five actual opcode kinds") + require(stored_denominators == {"1": 4928, "2": 390, "4": 72} + and product_denominators == {"1": 3006, "2": 52, "4": 46}, + "complete all-u denominator certificate") + return {"snapshots": snapshots, "final": state, "receipt": { + "opcode_counts": dict(counts), "stored_denominators": dict(stored_denominators), + "ADD_product_denominators": dict(product_denominators), + "maximum_absolute_normalised_coefficient": fraction(maximum), + "erasure_events": erasures, "six_first_collector_coefficients": [fraction(x) for x in observed], + "final_nonzero_coefficients": {b: fraction(x) for b, x in state.items() if x}, + "scope": "One symbolic paired family, every5398 event, including all208 signs; no rank census."}} + + +def chart_paths(word): + """Short source-authenticated chart paths, distinct from literal bank histories.""" + edges = {} + for event, row in enumerate(word["program"]): + if row[0] == "transport": + old, new = tuple(row[2]), tuple(row[3]) + edges.setdefault(old, []).append((new, event, False)) + edges.setdefault(new, []).append((old, event, True)) + paths, queue = {(): []}, deque([()]) + while queue: + old = queue.popleft() + for new, event, inverse in edges.get(old, []): + if new not in paths: + paths[new] = paths[old] + [(event, inverse)] + queue.append(new) + return paths + + +def collector_inventory(word, plans): + rows = word["program"][2114:2129] + counts = Counter(row[0] for row in rows) + require(counts == {"zero": 1, "add": 11, "transport": 2, "erase": 1}, + "actual eighth collector shape") + wrapper_rows, phases = [], Counter() + for event in (2120, 2122): + require(plans[event]["rank"] == 7, "actual eighth collector rank") + for side in ("right", "left"): + plan = plans[event][side] + permutation = [x for x, _ in plan] + require(sorted(permutation) == list(range(SIZE)), "wrapper permutation") + visited, cycles = set(), 0 + for start in range(SIZE): + if start in visited: + continue + cycles += 1 + current = start + while current not in visited: + visited.add(current) + current = permutation[current] + wrapper_phases = Counter(str(p) for _, p in plan) + require(wrapper_phases == {str(i): 128 for i in range(4)}, + "each actual wrapper has all four phase classes") + phases.update(wrapper_phases) + wrapper_rows.append({"event": event, "side": side, "cycles": cycles, + "Gaussian_SWAP": SIZE - cycles, + "phase_histogram": dict(wrapper_phases)}) + require([r["cycles"] for r in wrapper_rows] == [64, 64, 128, 48], "wrapper cycle inventory") + require(phases == {str(i): 512 for i in range(4)}, "wrapper phase inventory") + return {"events": [2114, 2128], "counts": dict(counts), "native_rank_mass": 14, + "completed_native_pairs": 3584, "real_ADD_SUB_before_SWAP_phase_lowering": 39936, + "native_floor_halves": 14336, "native_Gaussian_quarter_turns": 3584, + "wrappers": wrapper_rows, "wrapper_Gaussian_SWAPs": 1744, + "wrapper_phase_histogram": dict(phases), "owned_zero_Gaussian_banks": 1, + "scope": "Existing eighth collector only. Both transports, all four wrappers and cleanup included; no physical or recursive price inferred."} + + +def analyze(word, native, modules): + source, classifier, admission, model = [modules[n] for n in ("source", "classifier", "admission", "model")] + structure = source.structure(word, native) + paths = chart_paths(word) + path_events = {e for path in paths.values() for e, _ in path} + plans = source.native_plans(word, native, sorted(path_events | set(structure["selected"]) | {2120, 2122}), model) + parameters = [[ZERO] * SIZE for _ in range(52)] + parameters[44][15] = (1, 0) + initial_y = admission.encode_sources(structure, plans, model, source, classifier, parameters) + recovered = admission.decode_sources(structure, plans, model, source, classifier, initial_y) + require(recovered == parameters, "exact K column and return") + p = initial_y["Y91"] + require(initial_y["Y90"] == [(-r, -i) for r, i in p], "opposite prepared Y sources") + require({b for b, value in initial_y.items() if any(z != ZERO for z in value)} == {"Y90", "Y91"}, + "complete K column support") + require(model.member(p), "p belongs to B9") + require(any(x % 4 for z in model.decode(p) for x in z), "p outside4B9") + gap = structure["gaps"][44] + require(gap["kind"] == "zero" and gap["event"] == 1817 and gap["next_event"] == 1819, + "exact inherited coefficient meaning") + profile = source.apply_path(p, gap["path_to_read"], plans, model) + require(profile == [(-4, 0) if k & 15 == 15 else ZERO for k in range(SIZE)], "E9 delta15 profile") + scalar = symbolic(word) + images = {(): p} + + def image(frame): + key = tuple(frame) + if key not in images: + require(key in paths, "reachable canonical chart") + values = p + for event, inverse in paths[key]: + values = source.apply_native(values, event, plans, model, inverse=inverse) + require(model.member(values), "oracle frame image is in B9") + images[key] = values + return images[key] + + arrays = {cut: {bank: {"frame": item["frame"], "values": scaled(image(item["frame"]), 4 * item["coefficient"])} + for bank, item in row.items()} + for cut, row in scalar["snapshots"].items()} + final_ys = {bank: scaled(image(word["final_frames"][bank]), 4 * scalar["final"][bank]) + for bank in ("Y90", "Y91")} + return {"p": p, "expected_checkpoints": arrays, "expected_final_Y": final_ys, + "receipt": {"coefficient_column": {"slot": 44, "mask": 15, "source_support": ["Y91", "Y90"], + "p_sha256": digest(p), "nonzero_coordinates": sum(z != ZERO for z in p), + "component_height": max(abs(x) for z in p for x in z), "in_B9": True, + "in_4B9": False, "K_inverse_returns_coefficients": True, "gap": gap}, + "symbolic": scalar["receipt"], "collector": collector_inventory(word, plans), + "chart_oracle_paths": {str(list(k)): paths[k] for k in images}, + "strong_checkpoint_hashes": {cut: {b: digest(item["values"]) for b, item in row.items()} + for cut, row in arrays.items()}}} diff --git a/research/p104-kernel-consumer/verify.py b/research/p104-kernel-consumer/verify.py new file mode 100644 index 0000000000..4d39118e77 --- /dev/null +++ b/research/p104-kernel-consumer/verify.py @@ -0,0 +1,199 @@ +#!/usr/bin/env python3 +"""Authenticate, compare and replay the bounded P104 consumer audit. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +Normal replay reads its receipt and never regenerates source or output files. +""" + +import argparse +import gzip +import hashlib +import json +from pathlib import Path +import sys +from types import ModuleType + + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +OWN = ("primary.py", "literal.py", "observable.py", "verify.py", "PROOF.md", "COSTS.md") +PREDECESSORS = { + "source": "research/p104-stagewise-entrance/source.py", + "classifier": "research/p104-stagewise-entrance/classifier.py", + "admission": "research/p104-stagewise-entrance/admission.py", + "model": "research/p104-stagewise-entrance/inputs/pr3382_model.py", +} +WORD = "research/p104-rounded-collector/inputs/WORD.json" +NATIVE = "research/p104-rounded-collector/inputs/NATIVE.json.gz" +COMPLETION = "research/p104-omitted-completion/CERTIFICATE.json" +ADAPTERS = "research/p104-omitted-frame-adapters/ADAPTERS.json" + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def strict_json(data): + def pairs(items): + result = {} + for key, value in items: + require(key not in result, "duplicate JSON key " + key) + result[key] = value + return result + + def invalid(value): + raise ValueError("noninteger JSON token " + value) + + return json.loads(data, object_pairs_hook=pairs, parse_float=invalid, parse_constant=invalid) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def sha(data): + return hashlib.sha256(data).hexdigest() + + +def same(left, right): + if type(left) is not type(right): + return False + if isinstance(left, dict): + return left.keys() == right.keys() and all(same(left[k], right[k]) for k in left) + if isinstance(left, (list, tuple)): + return len(left) == len(right) and all(same(a, b) for a, b in zip(left, right)) + return left == right + + +def read_regular(path): + require(not any(part.is_symlink() for part in (path, *path.parents)), + "symbolic link in source path " + str(path)) + require(path.is_file(), "regular source missing " + str(path)) + with path.open("rb") as stream: + data = stream.read(32 * 1024 * 1024 + 1) + require(len(data) <= 32 * 1024 * 1024, "source size limit") + return data + + +def module(data, path, name): + value = ModuleType(name) + value.__file__ = str(path) + exec(compile(data, str(path), "exec"), value.__dict__) + return value + + +def capture(): + raw_manifest = read_regular(PACKAGE / "SOURCES.json") + manifest = strict_json(raw_manifest) + require(type(manifest.get("schema_version")) is int and manifest["schema_version"] == 1, + "source manifest schema") + raw = {} + for row in manifest["files"]: + if row["usage"] != "input": + continue + name = row["path"] + require(type(name) is str and not name.startswith("/") + and all(part not in ("", ".", "..") for part in name.split("/")), "canonical input path") + require(name not in raw, "duplicate input") + data = read_regular(ROOT / name) + require(sha(data) == row["sha256"], "source manifest mismatch " + name) + raw[name] = data + require(all(name in raw for name in (*PREDECESSORS.values(), WORD, NATIVE, COMPLETION, ADAPTERS)), + "all executable scientific inputs declared") + own = {name: read_regular(PACKAGE / name) for name in OWN} + return raw_manifest, raw, own + + +def compare_arrays(primary, literal): + require(primary["p"] == literal["arrays"]["derived_p"], "full independently prepared p") + unscaled = literal["receipt"]["unscaled"] + failure = unscaled["first_literal_failure"] + require(unscaled["status"] == "EXACT_LITERAL_FAILURE" + and unscaled["counts"]["events_completed"] == 1099 + and unscaled["first_completed_event_outside_B9"] is None, "exact first-failure boundary") + expected = {"kind": "nonintegral_fractional_addend", "event": 1099, + "source": "Y90", "target": "D1", "address": 10, + "component": "real", "coefficient": "1/4", "exact_increment": "-1/2"} + require(type(failure) is dict and all(same(failure.get(k), v) for k, v in expected.items()), + "specific unscaled admission counterexample") + require(same(failure["source_value"], (-2, 0)) and failure["actual_word_event"] == + ["add", "D1", "Y90", "1/4", [381, 241, 2]], "actual failed physical read") + strong = literal["arrays"]["strong"] + require(primary["expected_checkpoints"] == strong["checkpoints"], + "all complete Q0/G0/X0 arrays against separate scalar/chart oracle") + require(primary["expected_final_Y"]["Y90"] == strong["final_Y90"] + and primary["expected_final_Y"]["Y91"] == strong["final_Y91"], + "both returned physical Y arrays") + require(strong["final_Q0"] == [(0, 0)] * 512, "final Q0 zero") + require(strong["final_X0"] == primary["expected_checkpoints"]["5397"]["X0"]["values"] + and any(z != (0, 0) for z in strong["final_X0"]), "physical -2 A_F p endpoint") + expected_nonzero = sorted(primary["receipt"]["symbolic"]["final_nonzero_coefficients"]) + x_nonzero = set(expected_nonzero) - {"Y90", "Y91"} + require({"Y90", "Y91"} <= set(expected_nonzero) and len(x_nonzero) == 52 + and all(bank.startswith("X") and bank[1:].isdigit() for bank in x_nonzero), + "symbolic endpoint support is exactly52 X banks and two Y banks") + require(sorted(literal["receipt"]["strong"]["nonzero_final_banks"]) == expected_nonzero, + "literal endpoint support equals the complete symbolic bank list") + return {"full_p_coordinates": 512, "strong_checkpoint_banks": 18, + "strong_checkpoint_Gaussian_coordinates": 9216, + "returned_Y_Gaussian_coordinates": 1024, + "comparison": "Complete arrays and frames compared before hashes, not hashes alone.", + "original_failure_checked": expected, "final_query_restored": True, + "final_required_X0_nonzero": True} + + +def calculate(): + manifest, raw, own = capture() + modules = {name: module(raw[path], ROOT / path, "p104_retained_" + name) + for name, path in PREDECESSORS.items()} + executable = {name: module(own[name + ".py"], PACKAGE / (name + ".py"), "p104_consumer_" + name) + for name in ("primary", "literal", "observable")} + word = strict_json(raw[WORD]) + native = strict_json(gzip.decompress(raw[NATIVE])) + primary = executable["primary"].analyze(word, native, modules) + literal = executable["literal"].run_literal(word, native, primary["p"]) + observable = executable["observable"].analyze(raw[WORD], raw[COMPLETION], raw[ADAPTERS]) + comparisons = compare_arrays(primary, literal) + require(observable["completion"]["X0_pair_coefficient"] == [-1, 2] + and observable["rho5_pair_response"] == [[0, 1]] * 5, + "independent reverse row and five-readout oracle") + require(not same({"schema_version": 1}, {"schema_version": True}), "typed receipt control") + for path, original in raw.items(): + require(read_regular(ROOT / path) == original, "input changed during replay " + path) + for path, original in own.items(): + require(read_regular(PACKAGE / path) == original, "implementation changed during replay " + path) + require(read_regular(PACKAGE / "SOURCES.json") == manifest, "manifest changed during replay") + receipt = {"schema_version": 1, "status": "PASS_P104_KERNEL_CONSUMER", + "SOURCES_sha256": sha(manifest), "input_sha256": {p: sha(b) for p, b in raw.items()}, + "implementation_and_proof_sha256": {p: sha(b) for p, b in own.items()}, + "primary": primary["receipt"], "literal": literal["receipt"], + "observable": observable, "full_array_comparison": comparisons, + "typed_receipt_control": "Boolean true is distinct from integer1", + "scope": "A source-bound consumer/caller audit with two finite fixtures and a written all-B9 paired-family implication. No paid caller, supplier, enlarged-domain advantage or kappa claim."} + return strict_json(canonical(receipt)) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-receipt", action="store_true", + help="explicitly regenerate this package's owned RECEIPT.json") + args = parser.parse_args() + result = calculate() + path = PACKAGE / "RECEIPT.json" + if args.write_receipt: + require(not path.is_symlink(), "receipt output must not be a link") + path.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8") + else: + expected = strict_json(read_regular(path)) + require(same(result, expected), "typed deterministic receipt mismatch") + print("PASS_P104_KERNEL_CONSUMER receipt=" + sha(read_regular(path)) + + " p=" + result["primary"]["coefficient_column"]["p_sha256"]) + + +if __name__ == "__main__": + try: + main() + except (ValueError, OSError, KeyError, TypeError) as error: + print("FAIL_P104_KERNEL_CONSUMER: " + str(error), file=sys.stderr) + raise SystemExit(1) from error From 3d9180ee9568357fcf0a505c8d8a8d6fd134bc4c Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 15:20:41 +1100 Subject: [PATCH 2/8] fix(ci): retain exact historical ledger context after documentation append Admit only the reviewed optional-timeout documentation successor from54bbb81c. Preserve its historical snapshot and coverage pin, the previous accepted source, all mathematical checkers and unknown-source rejection. Add real-entry controls for exact successor acceptance, source/pin corruption, isolated materialization and both final byte gates. Also resolve RUNNER_TEMP at P112 step scope. Verified focused regression normally and under -O; the regression fails against the original guard. Existing historical and tooling-ledger CI validation follows. Prepared with substantial OpenAI assistance. --- .github/workflows/p112-common-slice.yml | 4 +- scripts/replay_historical_check.py | 6 ++- tests/test_historical_check.py | 69 +++++++++++++++++++++++++ 3 files changed, 76 insertions(+), 3 deletions(-) diff --git a/.github/workflows/p112-common-slice.yml b/.github/workflows/p112-common-slice.yml index 37f99ca573..48047f61c4 100644 --- a/.github/workflows/p112-common-slice.yml +++ b/.github/workflows/p112-common-slice.yml @@ -15,9 +15,9 @@ jobs: if: github.repository == 'CrocSwap/integer-mult-bounds' runs-on: ubuntu-24.04 timeout-minutes: 20 - env: - TMPDIR: ${{ runner.temp }}/p112-common-slice steps: + - name: Initialise P112 work directory + run: echo "TMPDIR=$RUNNER_TEMP/p112-common-slice" >> "$GITHUB_ENV" - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: fetch-depth: 0 diff --git a/scripts/replay_historical_check.py b/scripts/replay_historical_check.py index 4bb61eae10..6bf5c4197c 100755 --- a/scripts/replay_historical_check.py +++ b/scripts/replay_historical_check.py @@ -231,7 +231,11 @@ 'path': 'docs/ci-verification.md', 'input': 'ledger-frontier741-ci-verification.md', 'sha256': 'a854022e0e1d5d4db4d60e586be3ea56005013ef14a1fc06d02bc06e8529c4b0', - 'accepted_live_sha256': ['ae5bcac684ce2188632f38dee8ed46ebdc9588f490401505aa1cac33c55d84db']}, + 'accepted_live_sha256': [ + 'ae5bcac684ce2188632f38dee8ed46ebdc9588f490401505aa1cac33c55d84db', + # 54bbb81c: append optional module-timeout documentation; historical bytes stay pinned. + 'a3711fe12d560fac7726c530b9c8c622182f3d4f231a876c163616e49bd911bc', + ]}, {'manifest': 'research/community-frontier890-audit/CONTENT-COVERAGE.json', 'field': ['pull_requests', '853', 'files'], 'path': 'scripts/verify_complex741_parallel.py', diff --git a/tests/test_historical_check.py b/tests/test_historical_check.py index b20c6ff339..b6a2e1ced9 100644 --- a/tests/test_historical_check.py +++ b/tests/test_historical_check.py @@ -123,6 +123,75 @@ def write(records): with self.subTest(records=records), self.assertRaises(ValueError): checker.authenticated_input(root, config, inputs) + def test_ci_document_successor_preserves_historical_context_and_guards(self): + # 54bbb81c appended timeout guidance to the already accepted live doc. + # The PR695 evidence and every historical checker remain unchanged. + config = next(entry for entry in checker.CONFIG['tooling-ledger']['additional_inputs'] + if entry['path'] == 'docs/ci-verification.md') + live = (ROOT / config['path']).read_bytes() + historical = (checker.INPUTS / config['input']).read_bytes() + previous = live.split(b'\n### Bound an isolated test module\n', 1)[0] + self.assertEqual(hashlib.sha256(previous).hexdigest(), + 'ae5bcac684ce2188632f38dee8ed46ebdc9588f490401505aa1cac33c55d84db') + self.assertEqual(hashlib.sha256(live).hexdigest(), + 'a3711fe12d560fac7726c530b9c8c622182f3d4f231a876c163616e49bd911bc') + self.assertEqual(hashlib.sha256(historical).hexdigest(), config['sha256']) + with tempfile.TemporaryDirectory() as td: + root, inputs = Path(td) / 'source', Path(td) / 'inputs' + root.mkdir() + inputs.mkdir() + document = root / config['path'] + document.parent.mkdir(parents=True) + baseline = inputs / config['input'] + baseline.write_bytes(historical) + manifest = root / config['manifest'] + manifest.parent.mkdir(parents=True) + manifest_bytes = (ROOT / config['manifest']).read_bytes() + manifest.write_bytes(manifest_bytes) + for label, value in [('current', live), ('previous', previous), + ('historical', historical)]: + with self.subTest(live_context=label): + document.write_bytes(value) + self.assertEqual(checker.authenticated_input(root, config, inputs), historical) + document.write_bytes(live + b' ') + with self.assertRaisesRegex(ValueError, 'Unrecognized live source update'): + checker.authenticated_input(root, config, inputs) + document.write_bytes(live) + baseline.write_bytes(historical + b' ') + with self.assertRaisesRegex(ValueError, 'Changed historical input'): + checker.authenticated_input(root, config, inputs) + baseline.write_bytes(historical) + for mutation in ('changed', 'duplicate'): + coverage = json.loads(manifest_bytes) + records = coverage['pull_requests']['695']['files'] + record = next(row for row in records if row['integrated_path'] == config['path']) + if mutation == 'changed': + record['integrated_sha256'] = '0' * 64 + else: + records.append(dict(record)) + manifest.write_text(json.dumps(coverage), encoding='utf-8') + with self.subTest(pin_mutation=mutation), self.assertRaises(ValueError): + checker.authenticated_input(root, config, inputs) + manifest.write_bytes(manifest_bytes) + (root / 'unrelated.txt').write_bytes(b'unchanged current input\n') + paths = [config['path'], config['manifest'], 'unrelated.txt'] + before = {name: (root / name).read_bytes() for name in paths} + target = Path(td) / 'copy' + expected = checker.materialize(root, target, config, paths, inputs) + self.assertEqual((target / config['path']).read_bytes(), historical) + self.assertEqual({name: (root / name).read_bytes() for name in paths}, before) + checker.verify_unchanged(target, expected) + for name in (config['path'], 'unrelated.txt'): + path = target / name + original = path.read_bytes() + path.write_bytes(original + b' ') + with self.subTest(replay_mutation=name), self.assertRaisesRegex( + ValueError, 'Replay changed tracked artifact'): + checker.verify_unchanged(target, expected) + path.write_bytes(original) + checker.verify_unchanged(target, expected) + self.assertEqual({name: (root / name).read_bytes() for name in paths}, before) + def test_untracked_replacement_and_existing_destination_reject(self): with tempfile.TemporaryDirectory() as td: root, inputs, config, paths = self.fixture(td) From 8285ad041aa53cc987905124de5ad76b8ae602ec Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 15:31:55 +1100 Subject: [PATCH 3/8] fix(ci): preserve authoritative closure inheritance in ledger checks Project closure only from the initial decisions and chronological family rounds, matching the generator's explicit-update semantics. Keep raw family records, exact JSON equality, missing ledger-field rejection, source pins and evidence unchanged. Cover inherited receipts, explicit null and overrides, new records, forged or missing closure, nested boolean mutations and source immutability. Five focused regressions pass normally and under -O. Independent review also checked 5,460 seeded histories against generator-style overwrite semantics. Full existing historical and tooling-ledger CI validation follows. Prepared with substantial OpenAI assistance. --- scripts/verify_pr_reconciliation.py | 31 ++++++++++- tests/test_pr_reconciliation.py | 79 ++++++++++++++++++++++++++++- 2 files changed, 108 insertions(+), 2 deletions(-) diff --git a/scripts/verify_pr_reconciliation.py b/scripts/verify_pr_reconciliation.py index 4e85c458ea..dff81275a8 100644 --- a/scripts/verify_pr_reconciliation.py +++ b/scripts/verify_pr_reconciliation.py @@ -4,6 +4,7 @@ Offline integrity check, not a mathematical verifier or a live GitHub-state check. """ from pathlib import Path +from copy import deepcopy import hashlib import tempfile import json @@ -109,6 +110,28 @@ def check_family_decision(item, decision): f'#{decision["number"]}: ledger differs from family decision: {field}') +def project_family_closures(starting_numbers, initial_decisions, family_rounds): + """Mirror the generator's explicit closure updates without using the ledger. + + Omission carries forward the prior authoritative value; explicit null clears + it. Keep raw family records separate for later provenance comparisons. + """ + closures = dict.fromkeys(starting_numbers) + for number, decision in initial_decisions.items(): + number = int(number) + require(number in closures, 'Closure decision outside the starting snapshot') + if 'closure' in decision: + closures[number] = deepcopy(decision['closure']) + for decisions in family_rounds: + for decision in decisions: + number = decision['number'] + if 'closure' in decision: + closures[number] = deepcopy(decision['closure']) + elif number not in closures: + closures[number] = None + return closures + + def check_batch1099_file(item): """Authenticate the original Makefile prefix after the opt-in PR154 target.""" current = (ROOT / item['integrated_path']).read_bytes() @@ -266,10 +289,12 @@ def main(): snapshot = json.loads((AUDIT / 'starting-snapshot.json').read_text()) expected = {p['number']: p for p in snapshot['pull_requests']} family_decisions = {} + family_rounds = [] for family_path in decision_paths(): if not family_path.exists(): continue family = json.loads(family_path.read_text()) + family_rounds.append(family['pull_requests']) numbers = [p['number'] for p in family['pull_requests']] require(len(numbers) == len(set(numbers)), 'Duplicate family PR') for row in family['pull_requests']: @@ -281,8 +306,12 @@ def main(): actual = {p['number']: p for p in ledger['pull_requests']} require(len(actual) == len(ledger['pull_requests']) == len(expected), 'Duplicate or missing PR') require(actual.keys() == expected.keys(), 'Starting PR set changed') + closures = project_family_closures( + (pr['number'] for pr in snapshot['pull_requests']), + json.loads((AUDIT / 'decisions.json').read_text())['decisions'], + family_rounds) for number, decision in family_decisions.items(): - check_family_decision(actual[number], decision) + check_family_decision(actual[number], {**decision, 'closure': closures[number]}) for number, pr in actual.items(): require(pr['starting_head'] == expected[number]['headRefOid'], f'#{number}: starting head changed') require(pr['contributor'] == expected[number]['author'], f'#{number}: attribution changed') diff --git a/tests/test_pr_reconciliation.py b/tests/test_pr_reconciliation.py index db84e0f46b..d4eee15b8e 100644 --- a/tests/test_pr_reconciliation.py +++ b/tests/test_pr_reconciliation.py @@ -14,6 +14,78 @@ spec.loader.exec_module(checker) +class FamilyClosureProjection(unittest.TestCase): + def decision(self, number=7): + return dict(number=number, reviewed_head='a' * 40, current_head='a' * 40, + disposition='partially_reviewed', github_state='OPEN', + integration_location=[], unresolved_question='Review remains open.') + + def test_closure_inheritance_and_explicit_overrides(self): + first = {'receipt': 'first.json', 'verified': True} + second = {'receipt': 'second.json', 'verified': True} + cases = [ + ('baseline receipt survives omission', {'7': {'closure': first}}, + [[{'number': 7}]], first), + ('baseline null survives omission', {'7': {'closure': None}}, + [[{'number': 7}]], None), + ('new family record defaults to null', {}, [[{'number': 8}]], None), + ('family receipt survives omission', {}, + [[{'number': 7, 'closure': first}], [{'number': 7}]], first), + ('explicit null clears prior receipt', {'7': {'closure': first}}, + [[{'number': 7, 'closure': None}], [{'number': 7}]], None), + ('explicit receipt replaces prior receipt', {'7': {'closure': first}}, + [[{'number': 7, 'closure': second}]], second), + ] + for label, baseline, rounds, expected in cases: + with self.subTest(case=label): + result = checker.project_family_closures([7], baseline, rounds) + self.assertEqual(result[rounds[-1][-1]['number']], expected) + + def test_projection_does_not_mutate_sources_or_raw_latest_records(self): + baseline = {'7': {'closure': {'receipt': 'baseline.json', 'checks': [True]}}} + rounds = [[self.decision()], [self.decision()]] + before = deepcopy((baseline, rounds)) + latest = {row['number']: row for rows in rounds for row in rows} + result = checker.project_family_closures([7], baseline, rounds) + self.assertEqual((baseline, rounds), before) + self.assertIs(latest[7], rounds[-1][0]) + self.assertNotIn('closure', latest[7]) + result[7]['checks'].append(False) + self.assertEqual((baseline, rounds), before) + self.assertEqual(latest[7], before[1][-1][0]) + + def test_missing_or_fabricated_ledger_closure_rejects_expected_null(self): + raw = self.decision() + closure = checker.project_family_closures([7], {}, [[raw]])[7] + expected = {**raw, 'closure': closure} + checker.check_family_decision(dict(expected), expected) + for operation in ('missing', 'fabricated'): + item = dict(expected) + if operation == 'missing': + item.pop('closure') + else: + item['closure'] = {'receipt': 'unapproved.json'} + with self.subTest(operation=operation), self.assertRaisesRegex(ValueError, '#7:.*closure'): + checker.check_family_decision(item, expected) + + def test_inherited_receipt_rejects_null_forgery_and_boolean_integer_mutation(self): + receipt = {'receipt': 'approved.json', 'checks': {'published': True}} + raw = self.decision() + closure = checker.project_family_closures([7], {'7': {'closure': receipt}}, [[raw]])[7] + expected = {**raw, 'closure': closure} + checker.check_family_decision(deepcopy(expected), expected) + for mutation in (None, {'receipt': 'other.json', 'checks': {'published': True}}, + {'receipt': 'approved.json', 'checks': {'published': 1}}): + item = deepcopy(expected) + item['closure'] = mutation + with self.subTest(mutation=mutation), self.assertRaisesRegex(ValueError, '#7:.*closure'): + checker.check_family_decision(item, expected) + + def test_baseline_decision_outside_starting_snapshot_rejects(self): + with self.assertRaisesRegex(ValueError, 'outside the starting snapshot'): + checker.project_family_closures([7], {'8': {'closure': None}}, []) + + class FamilyDecision(unittest.TestCase): @classmethod def setUpClass(cls): @@ -26,6 +98,10 @@ def setUpClass(cls): if path.exists(): cls.families[path.parent.name.removeprefix('community-').removesuffix('-audit')] = json.loads(path.read_text())['pull_requests'] cls.latest = {row['number']: row for decisions in cls.families.values() for row in decisions} + snapshot = json.loads((checker.AUDIT / 'starting-snapshot.json').read_text()) + baseline = json.loads((checker.AUDIT / 'decisions.json').read_text())['decisions'] + cls.closures = checker.project_family_closures( + (row['number'] for row in snapshot['pull_requests']), baseline, cls.families.values()) def setUp(self): self.decision = deepcopy(self.latest[626]) @@ -38,7 +114,8 @@ def test_current_family_projections_match_authoritative_decisions(self): final[decision['number']] = (family, decision) for number, (family, decision) in final.items(): with self.subTest(family=family, number=number): - checker.check_family_decision(self.items[number], decision) + checker.check_family_decision( + self.items[number], {**decision, 'closure': self.closures[number]}) def test_equal_forged_heads_do_not_establish_review_provenance(self): self.item['reviewed_head'] = self.item['current_head'] = '0' * 40 From 585568c7fb747dab7be5089dfc3f15ce67ff01e0 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 15:43:08 +1100 Subject: [PATCH 4/8] Keep ledger failures fatal while completing regression diagnostics Split historical and normal/optimized reconciliation suites into independent steps that also run after a prior failure. Preserve the ledger replay exit status and run the existing tracked-file mutation gate even when tests fail. On a ledger failure, print bounded PR2985 closure-key/source diagnostics. No ledger, source decisions, evidence, pins or pass criteria are changed. Validation: YAML parse and Bash syntax passed. Stubbed ledger statuses 0, 1 and 17 were preserved; failure output was 453 bytes. Split-step failure-gate checks kept the aggregate unsuccessful for every failing scenario. Implemented and checked with substantial OpenAI assistance. --- .github/workflows/community-tooling799.yml | 42 +++++++++++++++++++--- 1 file changed, 37 insertions(+), 5 deletions(-) diff --git a/.github/workflows/community-tooling799.yml b/.github/workflows/community-tooling799.yml index 83e3fed23e..28415d0fcf 100644 --- a/.github/workflows/community-tooling799.yml +++ b/.github/workflows/community-tooling799.yml @@ -54,8 +54,40 @@ jobs: python -B research/community-frontier799-audit/check_pr806_trace.py - name: Current ledger and archive integrity controls run: | - python -B scripts/replay_historical_check.py tooling-ledger - python -B -m unittest discover -s tests -p 'test_historical_check.py' -v - python -B -m unittest discover -s tests -p 'test_*reconciliation*.py' -v - python -B -O -m unittest discover -s tests -p 'test_*reconciliation*.py' -v - - run: git diff --exit-code + status=0 + python -B scripts/replay_historical_check.py tooling-ledger || status=$? + if [ "$status" -ne 0 ]; then + python -B - <<'PY' + import json + from pathlib import Path + source = 'docs/research/pr-intake-decisions.json' + ledger = json.loads(Path('docs/research/pr-ledger.json').read_text()) + decisions = json.loads(Path(source).read_text())['pull_requests'] + item = next(row for row in ledger['pull_requests'] if row['number'] == 2985) + decision = next(row for row in decisions if row['number'] == 2985) + print(json.dumps({ + 'diagnostic': 'PR2985 closure field and source references', + 'ledger_closure_present': 'closure' in item, + 'ledger_closure': item.get('closure'), + 'source': source, + 'source_closure_present': 'closure' in decision, + 'source_closure': decision.get('closure'), + 'source_sha256': ledger['source_sha256'].get(source), + 'current_head_observed_in': item.get('current_head_observed_in'), + 'reconciliation_evidence': item.get('reconciliation_evidence', []), + }, sort_keys=True)) + PY + fi + exit "$status" + - name: Historical replay regression tests + if: ${{ success() || failure() }} + run: python -B -m unittest discover -s tests -p 'test_historical_check.py' -v + - name: Reconciliation regression tests + if: ${{ success() || failure() }} + run: python -B -m unittest discover -s tests -p 'test_*reconciliation*.py' -v + - name: Optimized reconciliation regression tests + if: ${{ success() || failure() }} + run: python -B -O -m unittest discover -s tests -p 'test_*reconciliation*.py' -v + - name: Reject tracked-file mutations + if: ${{ success() || failure() }} + run: git diff --exit-code From 75912666ad12cd7a941d7f80cefc46c7d5124fa9 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 15:54:05 +1100 Subject: [PATCH 5/8] Align maintenance successor checks and freeze the null-closure fixture Synchronize only the two exact runner successors already registered by the historical replay loader: 9158ee6d private cache namespaces and da400586 inherited descendant cache policy. Keep all predecessor/file bindings and unknown-byte rejection unchanged; do not admit the intervening deadline-only runner hash. Use PR620's frozen k492 recorded-null decision for the null-field test, with positive-null and missing/fabricated-closure controls. The current-family test continues to bind the later real merge receipt and reject the 19 missing ledger fields. No ledger, source decision, receipt, pin or snapshot changes. Validation: 11 focused tests passed normally and with -O. Independent review passed 17 exact-byte/closure controls, including historical/current acceptance, one-byte rejection and the live PR620 receipt. Full diagnostic CI follows. Implemented and reviewed with substantial OpenAI assistance. --- scripts/verify_pr_reconciliation.py | 5 ++++- tests/test_pr_reconciliation.py | 17 ++++++++++++----- 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/scripts/verify_pr_reconciliation.py b/scripts/verify_pr_reconciliation.py index dff81275a8..cd0abfd7a3 100644 --- a/scripts/verify_pr_reconciliation.py +++ b/scripts/verify_pr_reconciliation.py @@ -86,7 +86,10 @@ def check_batch932_file(item): '96ea543e6c707424afe247e77bd86c82152f90fc76a0773c4232145da5cdf8d1', ('b1c645e815a6abfbfdc2d77c4121c543ed0ca958095e97e1181d64e84cac0ed8', '05839996482058359b2ab8087d7d96e76934bd03d79981df9b99447e8ed09331', - 'fdc022f70e42a9b5a2be8c6c3645cfdc211c6dffdffac68904b2945b1cdc3e5a', 'f569b1c287252c698b4d59bc1bd0f013159e772cc3be64e26c4eab8eb99d0478', '6f353dae3f922d78f62bedddcb50cfe2b500b4195a888cec5ffac2367b1a4f88', '2bcc91541d4c328e9ca329aa02516836dc55fe326299ad6ecee6439f5806f6aa', '8f9298eb83184a447ee2dda64a42dfc5a56df08e4affae56f99974cad632713a')), + 'fdc022f70e42a9b5a2be8c6c3645cfdc211c6dffdffac68904b2945b1cdc3e5a', 'f569b1c287252c698b4d59bc1bd0f013159e772cc3be64e26c4eab8eb99d0478', '6f353dae3f922d78f62bedddcb50cfe2b500b4195a888cec5ffac2367b1a4f88', '2bcc91541d4c328e9ca329aa02516836dc55fe326299ad6ecee6439f5806f6aa', '8f9298eb83184a447ee2dda64a42dfc5a56df08e4affae56f99974cad632713a', + # Exact cache-policy successors already registered by the replay loader. + '93e49175a84ebcb3fe5e38503416ffae9c9f44754c3e974bf9c8ffaa6920f1bf', + 'ef5035e6216d39569da670f32b2717c870b23c418016fd134cc0a72649fb912a')), 'tests/test_isolated_test_runner.py': ( '628391b6abfbc8674ceec1751867a4392f2cc0b5b66886243e139af86cf355ac', ('8262f36202e426b849a925123ff789843115d5e564962710c31ab14f84c88067', diff --git a/tests/test_pr_reconciliation.py b/tests/test_pr_reconciliation.py index d4eee15b8e..0266367d1c 100644 --- a/tests/test_pr_reconciliation.py +++ b/tests/test_pr_reconciliation.py @@ -147,12 +147,19 @@ def test_changed_or_missing_projection_fields_are_rejected(self): checker.check_family_decision(item, self.decision) def test_missing_closure_is_distinct_from_recorded_null(self): - decision = self.latest[620] - item = deepcopy(self.items[620]) + # This frozen decision recorded null; PR620's latest review has a merge receipt. + decision = next(row for row in self.families['k492'] if row['number'] == 620) self.assertIsNone(decision['closure']) - item.pop('closure') - with self.assertRaisesRegex(ValueError, '#620:.*closure'): - checker.check_family_decision(item, decision) + checker.check_family_decision(deepcopy(decision), decision) + for operation in ('missing', 'fabricated'): + item = deepcopy(decision) + if operation == 'missing': + item.pop('closure') + else: + item['closure'] = {'receipt': 'unapproved.json'} + with self.subTest(operation=operation), self.assertRaisesRegex( + ValueError, '#620:.*closure'): + checker.check_family_decision(item, decision) def test_boolean_completion_flags_cannot_be_replaced_by_integers(self): for number in (626, 620): From d61354797ec5fc4655e322282bc7e7e12a992a88 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 16:54:11 +1100 Subject: [PATCH 6/8] Restore explicit null closure fields in nineteen intake ledger rows Add only the missing closure:null keys for PRs 2985, 3012, 3029, 3031, 3039, 3040, 3045, 3049, 3074, 3120, 3143, 3147, 3154, 3181, 3184, 3190, 3198, 3200 and 3251. This matches the source-derived generator projection for new intake rows; it does not record a closure receipt. Preserve all existing values, evidence, source hashes, historical snapshots, review status and head history. Do not regenerate the ledger: the full producer would alter unrelated retained intake provenance. Validation: removing these nineteen keys restores the original file byte-for-byte. All 43 unchanged reconciliation tests pass in scratch both normally and with -O, including the original 1700-blob archive comparison. Independent review confirmed the exact JSON and byte-level patch and passed all 13 family projection/closure controls in both modes. Hosted full-ledger validation is required on this exact commit. Implemented and independently reviewed with substantial OpenAI assistance. --- docs/research/pr-ledger.json | 57 ++++++++++++++++++++++++------------ 1 file changed, 38 insertions(+), 19 deletions(-) diff --git a/docs/research/pr-ledger.json b/docs/research/pr-ledger.json index c682b4c39d..f1cfd4f227 100644 --- a/docs/research/pr-ledger.json +++ b/docs/research/pr-ledger.json @@ -147019,7 +147019,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 2986, @@ -148266,7 +148267,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3013, @@ -149111,7 +149113,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3030, @@ -149204,7 +149207,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3032, @@ -149597,7 +149601,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3040, @@ -149640,7 +149645,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3041, @@ -149883,7 +149889,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3046, @@ -150078,7 +150085,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3050, @@ -151228,7 +151236,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3075, @@ -153534,7 +153543,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3121, @@ -154696,7 +154706,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3146, @@ -154789,7 +154800,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3148, @@ -155082,7 +155094,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3157, @@ -156275,7 +156288,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3182, @@ -156426,7 +156440,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3185, @@ -156719,7 +156734,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3192, @@ -157062,7 +157078,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3199, @@ -157155,7 +157172,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3201, @@ -159706,7 +159724,8 @@ "current_head_observed_in": "docs/research/pr-intake-decisions.json", "reconciliation_evidence": [ "docs/research/pr-intake-decisions.json" - ] + ], + "closure": null }, { "number": 3252, From 7c0f1923bd6a023d82860a12a0e593ba448d5398 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 17:48:41 +1100 Subject: [PATCH 7/8] Authenticate original intake history and explicitly replay two historical receipts Preserve authentic first-appearance starting heads using three byte-exact, source-commit-bound intake snapshots. Share this projection with future queue generation while retaining current-head/review/closure checks; do not regenerate the ledger. Add narrowly scoped PR1 and PR636 historical wrappers anchored to canonical commit 20ecf2891d80b5acf18d980b2164fb44ea7faa90. Authenticate original package trees, manifests and source bytes, run unchanged original declarations in an isolated Git object store, and explicitly report that live inputs are not validated. Preserve evidence, source pins, contributors and strict drift rejection. Validation: 50 reconciliation tests and 36 historical adapter controls pass normally and with Python -O; both outer registered wrappers and their original positive/negative controls pass. Exact 16-file planner inventory selects only the two wrappers. Hosted exact-head CI remains to be verified. Implemented and independently reviewed with substantial OpenAI assistance. --- docs/research/research-package-guide.md | 54 + research/pr1-retention-receipt/README.md | 30 + research/pr1-retention-receipt/SOURCES.json | 18 +- research/pr1-retention-receipt/VERIFY.json | 27 +- .../README.md | 30 + .../SOURCES.json | 4 +- .../VERIFY.json | 26 +- ...bc0f002fc5b04814272c89edbd557b2a8285d.json | 8556 +++++++++++ ...b9bfffd4a7c812545ea6ae58853cb9ef094b2.json | 12350 ++++++++++++++++ ...67beb311be1b630eb95197492e6462eddccd8.json | 5736 +++++++ .../intake-starting-heads/README.md | 43 + scripts/reconcile_pr_queue.py | 20 +- scripts/replay_historical_receipt.py | 344 + scripts/verify_pr_reconciliation.py | 68 + tests/test_pr_reconciliation.py | 119 + tests/test_research_historical_receipts.py | 355 + 16 files changed, 27754 insertions(+), 26 deletions(-) create mode 100644 scripts/historical-ci-inputs/intake-starting-heads/09fbc0f002fc5b04814272c89edbd557b2a8285d.json create mode 100644 scripts/historical-ci-inputs/intake-starting-heads/24db9bfffd4a7c812545ea6ae58853cb9ef094b2.json create mode 100644 scripts/historical-ci-inputs/intake-starting-heads/82d67beb311be1b630eb95197492e6462eddccd8.json create mode 100644 scripts/historical-ci-inputs/intake-starting-heads/README.md create mode 100644 scripts/replay_historical_receipt.py create mode 100644 tests/test_research_historical_receipts.py diff --git a/docs/research/research-package-guide.md b/docs/research/research-package-guide.md index 1a70e63c75..088978e061 100644 --- a/docs/research/research-package-guide.md +++ b/docs/research/research-package-guide.md @@ -339,3 +339,57 @@ Tekalign, with substantial OpenAI Codex assistance. Apache-2.0. The exact HEAD/index fallback premise follows Arham-Tahir64's PR3102 sparse-reference work; this applies it to replay declarations. The original planner, canonical Git spelling, symlink and inventory-error controls retain their predecessor credit. + +## Historical source/credit receipt adapters + +Two source/credit receipts now register an explicit historical-only wrapper: +`research/pr1-retention-receipt` and +`research/pr636-family-witness-manifest-receipt`. Their original package bytes +are frozen at `20ecf2891d80b5acf18d980b2164fb44ea7faa90`, with original input +bases `d8e0f83f00191df62174b641e9fff055c357f641` and +`1f7a934975e5eacaf83511c9ac870263bf095e05`, respectively. Later additions to +CONTRIBUTORS.md and the ledger must not be rolled back to satisfy those old +live-input pins. + +Their current SOURCES.json retains each original commit/blob/SHA256 pin as +historical provenance. Current VERIFY.json and README.md explicitly describe +the historical scope. The adapter permits only the exact reviewed transformation +of those three files; current verifier, evidence and other package bytes must +still equal the frozen original. This is a two-package policy, not a fallback +for arbitrary stale live pins. + +```sh +python3 -B scripts/replay_historical_receipt.py --package research/pr1-retention-receipt +python3 -B scripts/replay_historical_receipt.py --package research/pr636-family-witness-manifest-receipt +python3 -W error -B -m unittest discover -s tests -p 'test_research_historical_receipts.py' -v +``` + +CI must fetch full Git history (`fetch-depth: 0`). Required historical commit, +tree and blob objects must be locally available; missing objects fail closed, +and this adapter never fetches them. The adapter authenticates exact +commit/path/blob identities and SHA256 pins, then copies only the original +package, source bytes and required Git objects into a private temporary tree. +It shares no Git object store, config, refs, hooks, worktree or alternate with +the live repository. Replacement objects and inherited Git configuration cannot +substitute history; legacy grafts, symlinks and path aliases are rejected. +The unchanged generic validator and unchanged original commands run there, +including the PR1 positive/twelve failure controls and PR636 positive/four +failure controls. Original per-command timeouts and Python cache isolation +remain in force. The temporary tree is removed after success or failure. + +Success requires final unchanged-file checks for original materialized files +and live package/input bytes, and emits `PASS_HISTORICAL_RECEIPT_ONLY` with both +commit IDs and `live_inputs_validated=false`. `--check-only` authenticates only +metadata and pins, emitting `PASS_HISTORICAL_METADATA_ONLY`; it runs no verifier. +Missing history, changed pins, unapproved wrapper/code/evidence changes or +failed controls exit nonzero. This is not a sandbox against arbitrary untrusted +code, an atomic snapshot of a changing checkout, a current-state validation, +a new scientific acceptance or a PR closure decision. + +The current registered wrappers also run the focused regression suite and +declare its file and the adapter as inputs. Their edits therefore invalidate +these two consumers without changing the shared planner or workflows. All +other packages retain normal live-input validation. The original manifests +remain immutable in Git; running their original live contract against later +input bytes still fails closed as before. Existing contributor credit, +scientific evidence and selected-frontier obligations are unchanged. diff --git a/research/pr1-retention-receipt/README.md b/research/pr1-retention-receipt/README.md index 16bd447014..bbaff8b068 100644 --- a/research/pr1-retention-receipt/README.md +++ b/research/pr1-retention-receipt/README.md @@ -154,3 +154,33 @@ this package follows. Prepared by **Aaron Wang**, with help from opencode (substantial AI assistance; no model named; no independent human review claimed). Apache-2.0. Predecessor licenses and notices remain in force. + +## Explicit historical-only registered replay + +The registered command now authenticates and replays the original package at +`20ecf2891d80b5acf18d980b2164fb44ea7faa90` against its original pinned base. +It does not validate today's ledger, contributor list, or other live input +bytes. The original SOURCES.json, VERIFY.json, verifier and evidence are read +unchanged from that commit into an isolated temporary tree. Current source +rows keep their exact original commit/blob/SHA256 pins as historical provenance. + +Only these three wrapper files (README.md, SOURCES.json and VERIFY.json) may +differ from the frozen package, and the adapter checks their exact approved +transformation. All current verifier and evidence bytes must still equal the +original tree. The original positive and negative controls run without edits; +materialized and live package/input files must remain unchanged afterward. +`PASS_HISTORICAL_RECEIPT_ONLY` is a historical source/credit result, not a +current-state validation, new scientific acceptance, or closure decision. + +Run the historical adapter with Python 3.12: + +```sh +python3 -B scripts/replay_historical_receipt.py --package research/pr1-retention-receipt +``` + +The generic runner's default live-input contract is unchanged. To inspect the +original live contract, replay the original frozen package metadata against live +inputs: it correctly rejects later byte drift. The registered wrapper declares +the adapter and its focused tests as inputs, so changes select these two +consumers without a global shared-workflow invalidation. See +[the replay guide](../../docs/research/research-package-guide.md#historical-sourcecredit-receipt-adapters). diff --git a/research/pr1-retention-receipt/SOURCES.json b/research/pr1-retention-receipt/SOURCES.json index ac94245585..1e41734053 100644 --- a/research/pr1-retention-receipt/SOURCES.json +++ b/research/pr1-retention-receipt/SOURCES.json @@ -4,31 +4,31 @@ "files": [ { "path": "CITATION.cff", - "usage": "input", + "usage": "provenance", "git_blob": "574b2108bc40b5799f5a8c54fa3519d8aea51892", "sha256": "4b17b8cff777e2f619afc47d7421e49e9309bdff9f8fe2f185fc774ff18a25e1" }, { "path": "CONTRIBUTORS.md", - "usage": "input", + "usage": "provenance", "git_blob": "6431453337f4ff2fec9b560decce3267f443ea5a", "sha256": "e16a737af455f68cf329710bf9bc48ec1728101cbeaf1519dd7aef0fbafad172" }, { "path": "Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "02055437d2b90c705e8b82d2ef2b58633101ca7d", "sha256": "cbcc8cb5e977970fce52ad0b2e4440eb6b6a9c9e87fa1bcfd6af11a16f9344b7" }, { "path": "NOTICE", - "usage": "input", + "usage": "provenance", "git_blob": "59d8e0cf3102e15bd11db430838365531e2d7f18", "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd" }, { "path": "README.md", - "usage": "input", + "usage": "provenance", "git_blob": "74f49a5eca5910b915cb8446462c081c0372b141", "sha256": "00162212b6ae88b02330d824c8d1469ef41097c88b91e32b0876f83d29a94caa" }, @@ -40,7 +40,7 @@ }, { "path": "docs/reproducibility.md", - "usage": "input", + "usage": "provenance", "git_blob": "ce620954a86c0b6688859a7421441fc97a3d9259", "sha256": "333f87bf13c4aa911af89d278923ea84bfd091966e23f5fb1332e83aa4565db9" }, @@ -52,19 +52,19 @@ }, { "path": "docs/research/pr-ledger.json", - "usage": "input", + "usage": "provenance", "git_blob": "f5ce7e4c467d3e9bfe1d16a1524228b11c655769", "sha256": "f36486250793e396bebe63f51adafcee82fe28a4a0c7e9a40cf6b5d1713cb066" }, { "path": "research/overnight-pr-review-20261009/dispositions.json", - "usage": "input", + "usage": "provenance", "git_blob": "ed53da272d6dc016420f2a6a75321e9c18fb5bc1", "sha256": "9dd0264e667551852a7d6747df490e3e542465caf347d9f43998c6f0665faae9" }, { "path": "research/overnight-pr-review-20261009/source-inventory.json", - "usage": "input", + "usage": "provenance", "git_blob": "ab2e653500b152ca672d8651d2c4476d5672d9fb", "sha256": "0dc9bc5fc0da37f4442014e17106823f24c4ecaf36b144643fc5684474ac2261" } diff --git a/research/pr1-retention-receipt/VERIFY.json b/research/pr1-retention-receipt/VERIFY.json index a7d74ba05a..f1d0c4f5cf 100644 --- a/research/pr1-retention-receipt/VERIFY.json +++ b/research/pr1-retention-receipt/VERIFY.json @@ -12,30 +12,37 @@ "docs/reproducibility.md", "docs/research/pr-ledger.json", "research/overnight-pr-review-20261009/dispositions.json", - "research/overnight-pr-review-20261009/source-inventory.json" + "research/overnight-pr-review-20261009/source-inventory.json", + "scripts/replay_historical_receipt.py", + "tests/test_research_historical_receipts.py" ], "commands": [ { "argv": [ "{python}", - "-I", - "-O", "-B", - "{package}/verify.py" + "scripts/replay_historical_receipt.py", + "--package", + "{package}" ], - "timeout_seconds": 60, - "checks": "Authenticate the 11 vendored PR1 head files against their recorded live REST blob identities, reparse every changed file's REST patch hunk-exactly against the API additions field, classify each path at the base commit, recompute the multiset survival of PR1's added lines in the five shared files, exclude byte-identical copies of the six new files in the exact base-tree enumeration, and verify credit against CONTRIBUTORS.md, NOTICE, README.md, CITATION.cff, the ledger and the 2026-10-09 review records." + "timeout_seconds": 480, + "checks": "Historical-only replay: authenticate the exact frozen package and original source pins, run unchanged original commands and failure controls in an isolated Git snapshot, and require historical/live bytes unchanged; does not validate today's input bytes." }, { "argv": [ "{python}", - "-I", - "-O", "-B", - "{package}/test_verify.py" + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_research_historical_receipts.py", + "-v" ], "timeout_seconds": 120, - "checks": "One real-evidence positive case and twelve failure controls over vendored bytes, REST blob identities, patch parse counts, base-file content, the CITATION.cff convention line, the CONTRIBUTORS credit row, a forged tree copy, the credit enumeration, both 2026-10-09 review records and the expected result itself." + "checks": "Focused historical-adapter regression controls for wrong history/pins, path aliases, missing inputs, wrapper/code/evidence drift, isolation and unchanged-file gates; the generic live-input validator remains strict." } ] } diff --git a/research/pr636-family-witness-manifest-receipt/README.md b/research/pr636-family-witness-manifest-receipt/README.md index 466012cb30..e12564ddab 100644 --- a/research/pr636-family-witness-manifest-receipt/README.md +++ b/research/pr636-family-witness-manifest-receipt/README.md @@ -170,3 +170,33 @@ which audited a different family. Prepared by Aaron Wang / navinor with help from opencode. Substantial AI assistance is disclosed; no independent human review is claimed. Apache-2.0. + +## Explicit historical-only registered replay + +The registered command now authenticates and replays the original package at +`20ecf2891d80b5acf18d980b2164fb44ea7faa90` against its original pinned base. +It does not validate today's ledger, contributor list, or other live input +bytes. The original SOURCES.json, VERIFY.json, verifier and evidence are read +unchanged from that commit into an isolated temporary tree. Current source +rows keep their exact original commit/blob/SHA256 pins as historical provenance. + +Only these three wrapper files (README.md, SOURCES.json and VERIFY.json) may +differ from the frozen package, and the adapter checks their exact approved +transformation. All current verifier and evidence bytes must still equal the +original tree. The original positive and negative controls run without edits; +materialized and live package/input files must remain unchanged afterward. +`PASS_HISTORICAL_RECEIPT_ONLY` is a historical source/credit result, not a +current-state validation, new scientific acceptance, or closure decision. + +Run the historical adapter with Python 3.12: + +```sh +python3 -B scripts/replay_historical_receipt.py --package research/pr636-family-witness-manifest-receipt +``` + +The generic runner's default live-input contract is unchanged. To inspect the +original live contract, replay the original frozen package metadata against live +inputs: it correctly rejects later byte drift. The registered wrapper declares +the adapter and its focused tests as inputs, so changes select these two +consumers without a global shared-workflow invalidation. See +[the replay guide](../../docs/research/research-package-guide.md#historical-sourcecredit-receipt-adapters). diff --git a/research/pr636-family-witness-manifest-receipt/SOURCES.json b/research/pr636-family-witness-manifest-receipt/SOURCES.json index 5483551a76..a4d17b3e21 100644 --- a/research/pr636-family-witness-manifest-receipt/SOURCES.json +++ b/research/pr636-family-witness-manifest-receipt/SOURCES.json @@ -16,13 +16,13 @@ }, { "path": "docs/research/pr-ledger.json", - "usage": "input", + "usage": "provenance", "git_blob": "20df7e36f5378796816db70aa755f281f550b45a", "sha256": "905c5efdf20883dbc212b936bde516c192017869754bcbd4bca9052f03c0f07e" }, { "path": "research/larger-gain/MANIFEST.json", - "usage": "input", + "usage": "provenance", "git_blob": "c8c22f51ca33156f696b48ea8214ef2ffcc13f00", "sha256": "73c186c2807c703e43293c7cf785557a046958c245fa812e433f7fe208cdef6d" } diff --git a/research/pr636-family-witness-manifest-receipt/VERIFY.json b/research/pr636-family-witness-manifest-receipt/VERIFY.json index abe86c1999..277e485ecd 100644 --- a/research/pr636-family-witness-manifest-receipt/VERIFY.json +++ b/research/pr636-family-witness-manifest-receipt/VERIFY.json @@ -5,17 +5,37 @@ "requirements": [], "inputs": [ "docs/research/pr-ledger.json", - "research/larger-gain/MANIFEST.json" + "research/larger-gain/MANIFEST.json", + "scripts/replay_historical_receipt.py", + "tests/test_research_historical_receipts.py" ], "commands": [ { "argv": [ "{python}", "-B", - "{package}/verify.py" + "scripts/replay_historical_receipt.py", + "--package", + "{package}" + ], + "timeout_seconds": 480, + "checks": "Historical-only replay: authenticate the exact frozen package and original source pins, run unchanged original commands and failure controls in an isolated Git snapshot, and require historical/live bytes unchanged; does not validate today's input bytes." + }, + { + "argv": [ + "{python}", + "-B", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_research_historical_receipts.py", + "-v" ], "timeout_seconds": 120, - "checks": "Drift identity of the two committed larger-gain MANIFEST copies against their recorded digests and against the working tree's research/larger-gain/MANIFEST.json; per-PR pin verdicts and retention counts recomputed from the per-PR audit rows; every changed-path retention class re-derived against git ls-tree -r ; cross-PR shared-blob counts recomputed; one positive fixture of the classification rule; four failure controls (tampered digest, substituted manifest diff, omitted row, substituted class) that must each be rejected." + "checks": "Focused historical-adapter regression controls for wrong history/pins, path aliases, missing inputs, wrapper/code/evidence drift, isolation and unchanged-file gates; the generic live-input validator remains strict." } ] } diff --git a/scripts/historical-ci-inputs/intake-starting-heads/09fbc0f002fc5b04814272c89edbd557b2a8285d.json b/scripts/historical-ci-inputs/intake-starting-heads/09fbc0f002fc5b04814272c89edbd557b2a8285d.json new file mode 100644 index 0000000000..6c5a777a82 --- /dev/null +++ b/scripts/historical-ci-inputs/intake-starting-heads/09fbc0f002fc5b04814272c89edbd557b2a8285d.json @@ -0,0 +1,8556 @@ +{ + "schema_version": 1, + "scope": "Incremental exact-head decisions. Only changed entries are updated; historical decisions remain in the Git history and central ledger sources.", + "pull_requests": [ + { + "number": 275, + "metadata": { + "number": 275, + "title": "Finite assembly theorem and source-bound PR799 application", + "author": { + "id": "MDQ6VXNlcjE2NDk0NDU=", + "is_bot": false, + "login": "lydakis", + "name": "George Lydakis" + }, + "headRefOid": "524375c61b75dc10cef68a71d504e79e7e7f138c", + "isDraft": false + }, + "reviewed_head": "524375c61b75dc10cef68a71d504e79e7e7f138c", + "current_head": "524375c61b75dc10cef68a71d504e79e7e7f138c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/524375c61b75dc10cef68a71d504e79e7e7f138c" + ], + "unresolved_question": "Two primary finite-assembly packages previously passed, including the pinned PR799 application. Eleven additional research/tooling packages still require scientific review and execution. Historical source retention does not admit the submitted test wrappers, CI configuration or certificate replacement.", + "closure": { + "kind": "merged_for_historical_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/275", + "merge_commit": "fadae6f469e0d5c9c03bbe047a4d383dac254448" + }, + "scope": "Complete historical source retention only: all 734 original changed-file entries and full original commit remain accessible in main ancestry. No proposed scientific files, test wrappers, workflows, certificate or attributes are installed in the default tree. Existing main source stays unchanged. Two primary finite-assembly package reviews previously passed and remain credited; eleven other packages retain independent proof/replay obligations.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/275.json", + "research/community-efficient1900-audit/packets/275.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/275.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/275.json", + "docs/research/pr-intake-evidence/pr275-historical-retention.json" + ] + }, + { + "number": 826, + "metadata": { + "number": 826, + "title": "Independent audit: confirm κ of #699 (0.001660666354374641) and #685 (0.001660339298410333)", + "author": { + "id": "MDQ6VXNlcjk4Mzc5MDc=", + "is_bot": false, + "login": "Rohansguliani", + "name": "Rohan Guliani" + }, + "headRefOid": "ea3ceae40d5fa19dc0361d3f15546df0182459c4", + "isDraft": false + }, + "reviewed_head": "ea3ceae40d5fa19dc0361d3f15546df0182459c4", + "current_head": "ea3ceae40d5fa19dc0361d3f15546df0182459c4", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/pr-record699-685-audit" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/826", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change. Generated contributor/ledger metadata resolved against current authoritative dispositions; original self-attested validation text retained only at original author commit.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 1252, + "metadata": { + "number": 1252, + "title": "Idle pair exchanges improve the #1094 κ candidate", + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "1b9db2faf82b8866b0bb0164501c9a627c7dca9b", + "isDraft": false + }, + "reviewed_head": "1b9db2faf82b8866b0bb0164501c9a627c7dca9b", + "current_head": "1b9db2faf82b8866b0bb0164501c9a627c7dca9b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/frontier1094-idle-exchanges" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1252", + "merge_commit": "47fa55b3cd8c7cf8879206f33569bc59d637dad8" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change. The older README candidate note is retained at its original author commit; current README and selected result are unchanged.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016c.json" + ] + }, + { + "number": 1786, + "metadata": { + "number": 1786, + "title": "Conditional κ = 0.001679754788150048 from fine source-prime padding", + "author": { + "id": "MDQ6VXNlcjQ0MDA1Mjc=", + "is_bot": false, + "login": "chafreaky", + "name": "chafreaky" + }, + "headRefOid": "c52345caa318fc6b1b6e2659c57d746317a72823", + "isDraft": false + }, + "reviewed_head": "c52345caa318fc6b1b6e2659c57d746317a72823", + "current_head": "c52345caa318fc6b1b6e2659c57d746317a72823", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity hold: a changed-file MANIFEST.json does not match the vendored PR1673 CAPPED-LAYOUT-CONTROLS.json. The same inconsistency exists upstream; provenance does not repair the package pin. Resolve the frozen manifest/byte contract before integration; mathematical proof/replay review remains open.", + "closure": null, + "scope": "Exact-head source/configuration revision gate. No new scientific execution or approval. Prior scoped evidence is retained.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/1786.json", + "research/community-efficient1900-audit/packets/1786.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/1786.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/1786.json", + "docs/research/pr-intake-evidence/remaining-holds-20261016d.json", + "docs/research/pr-intake-evidence/archives-20261016d.json" + ] + }, + { + "number": 1897, + "metadata": { + "number": 1897, + "title": "Conditional kappa refinement: 500-digit enclosures and complete native-proof reuse", + "author": { + "id": "U_kgDOBdOLfA", + "is_bot": false, + "login": "M6LI", + "name": "Muhammed Ali Mehmood" + }, + "headRefOid": "fdf717a838bb3d4c78396474131bd1ab5f18165d", + "isDraft": false + }, + "reviewed_head": "fdf717a838bb3d4c78396474131bd1ab5f18165d", + "current_head": "fdf717a838bb3d4c78396474131bd1ab5f18165d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity hold: a changed-file MANIFEST.json does not match the vendored PR1673 CAPPED-LAYOUT-CONTROLS.json. The same inconsistency exists upstream; provenance does not repair the package pin. Resolve the frozen manifest/byte contract before integration; mathematical proof/replay review remains open.", + "closure": null, + "scope": "Exact-head source/configuration revision gate. No new scientific execution or approval. Prior scoped evidence is retained.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/1897.json", + "research/community-efficient1900-audit/packets/1897.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/1897.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/1897.json", + "docs/research/pr-intake-evidence/remaining-holds-20261016d.json", + "docs/research/pr-intake-evidence/archives-20261016d.json" + ] + }, + { + "number": 2361, + "metadata": { + "number": 2361, + "title": "ci: select affected verification inputs and preserve historical replays", + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "b15a55ba1cecf985a584ad5926bc67ebb940b8d3", + "isDraft": false + }, + "reviewed_head": "b15a55ba1cecf985a584ad5926bc67ebb940b8d3", + "current_head": "b15a55ba1cecf985a584ad5926bc67ebb940b8d3", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Revise CI adoption against current manual-only historical sweeps: submitted verify.yml enables push/PR runs and a full scheduled matrix every six hours, including formal work. Preserve the current opt-in/no-automatic-Lean policy. Current historical-adapter reconciliation and native Linux strace coverage remain required.", + "closure": null, + "scope": "Exact-head source/configuration revision gate. No new scientific execution or approval. Prior scoped evidence is retained.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/2361.json", + "research/community-efficient1900-audit/packets/2361.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/2361.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/2361.json", + "docs/research/pr-intake-evidence/remaining-holds-20261016d.json" + ] + }, + { + "number": 2452, + "metadata": { + "number": 2452, + "title": "Test native Windows replay descendant cleanup", + "author": { + "id": "U_kgDOCTONGQ", + "is_bot": false, + "login": "ywz65", + "name": "" + }, + "headRefOid": "5208ab2780550273b1d8933ff584ce7581fb242d", + "isDraft": false + }, + "reviewed_head": "5208ab2780550273b1d8933ff584ce7581fb242d", + "current_head": "5208ab2780550273b1d8933ff584ce7581fb242d", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/windows-replay-timeout-audit.md", + "tests/test_research_windows_process_tree.py" + ], + "unresolved_question": "", + "closure": { + "kind": "merged_with_scoped_review", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2452", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Native Windows tooling review: exact composed source passed eight current Job Object tests and three frozen historical taskkill observer tests, normal and optimized on Windows/Python 3.12 and 3.14. Non-Windows AST preserved; no mathematical replay.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json", + "docs/research/pr-intake-evidence/windows-native-20261016.log" + ] + }, + { + "number": 2469, + "metadata": { + "number": 2469, + "title": "Fix Windows replay lifetime with gated Job Object ownership", + "author": { + "id": "U_kgDOCTONGQ", + "is_bot": false, + "login": "ywz65", + "name": "" + }, + "headRefOid": "65080e406c9edb0e93daa631f90b3fa4e4461910", + "isDraft": false + }, + "reviewed_head": "65080e406c9edb0e93daa631f90b3fa4e4461910", + "current_head": "65080e406c9edb0e93daa631f90b3fa4e4461910", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/windows-replay-lifetime.md", + "scripts/research_package.py", + "tests/test_research_windows_job.py" + ], + "unresolved_question": "", + "closure": { + "kind": "merged_with_scoped_review", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2469", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Native Windows tooling review: exact composed source passed eight current Job Object tests and three frozen historical taskkill observer tests, normal and optimized on Windows/Python 3.12 and 3.14. Non-Windows AST preserved; no mathematical replay.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json", + "docs/research/pr-intake-evidence/windows-native-20261016.log" + ] + }, + { + "number": 2780, + "metadata": { + "number": 2780, + "title": "Prove paid return of every physical head for the clean six-tape multiplier", + "author": { + "id": "MDQ6VXNlcjQ5MDU0NTMy", + "is_bot": false, + "login": "Dugongue", + "name": "" + }, + "headRefOid": "59f336094958b51b312e54deb85347e1b671172d", + "isDraft": false + }, + "reviewed_head": "59f336094958b51b312e54deb85347e1b671172d", + "current_head": "59f336094958b51b312e54deb85347e1b671172d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "multitape-origin-return/LICENSE", + "multitape-origin-return/MANIFEST.json", + "multitape-origin-return/MODULES.json", + "multitape-origin-return/NOTICE.md", + "multitape-origin-return/PORTING.json", + "multitape-origin-return/README.md", + "multitape-origin-return/REUSE.json", + "multitape-origin-return/SOURCES.json", + "multitape-origin-return/TASK.json", + "multitape-origin-return/VERIFY.json", + "multitape-origin-return/expected", + "multitape-origin-return/lean", + "multitape-origin-return/replay.py", + "multitape-origin-return/verify.py" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2780", + "merge_commit": "47fa55b3cd8c7cf8879206f33569bc59d637dad8" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016c.json" + ] + }, + { + "number": 2832, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "0da81b22178e70dbf59a23dda02371c6201fa4f3", + "isDraft": false, + "number": 2832, + "title": "Decoder floors: universality, projection transfer and batching reductions; C(P112) ≥ 64 reduced to named conjectures, C(P120) ≥ 72 restated on N₀ (no κ claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2832" + }, + "reviewed_head": "0da81b22178e70dbf59a23dda02371c6201fa4f3", + "current_head": "0da81b22178e70dbf59a23dda02371c6201fa4f3", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Theorem TF consequence uses a single fold parameter to cancel all proportional MD terms, but proportionality ratios may differ. The retained P112 decoder has16 MD terms p=(x_i,+/-x_i),q=p/8, exact target diag(G/2,G/2), and total cost128; ratios+1 and-1 require incompatible cancelling parameters. This exposes a gap in the conditional-under-H argument, not a proof or refutation of H. Supply common-ratio/common-annihilator hypotheses or a different proof. Section4.1 also needs justification: m=8k+e does not by itself restrict each call to8+e terms; this example has16 per call with e=0. Re-audit dependent batching consequences and add regression before a full replay. Revised head adds checks and a proof map but says no claim changed; the flagged argument remains. Two manifest-listed logs are also absent.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 2962, + "metadata": { + "number": 2962, + "title": "Ceilings for linear rank-counting decoder certificates (360/17 on P120) and a one-sided lift bound (cost >= 72 for dim S >= 23)", + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "f6e68c9838e21b263223ae61273e381d2c0b92c7", + "isDraft": false + }, + "reviewed_head": "f6e68c9838e21b263223ae61273e381d2c0b92c7", + "current_head": "f6e68c9838e21b263223ae61273e381d2c0b92c7", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/decoder-certificate-ceilings" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2962", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2963, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "ee755e682b3b30d493e764d3be50003b13b69b4a", + "isDraft": false, + "number": 2963, + "title": "F-star family gap: the twelve tied_min v = 11 sub-decoders settled exactly - gap_named = 2 EXISTS below v = 12 (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2963" + }, + "reviewed_head": "ee755e682b3b30d493e764d3be50003b13b69b4a", + "current_head": "ee755e682b3b30d493e764d3be50003b13b69b4a", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "The revised head still ships malformed JSON at research/fstar-gap2-v11-seed42ff0611/predecessor/pr2914/CERTIFICATE.json: Expecting value: line 1 column 1 (char 0). Restore the pinned predecessor certificate or explicitly document and isolate it as inert invalid evidence. This is an integrity hold, not a mathematical rejection.", + "scope": "Changed-head source/integrity triage; no scientific replay.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 2964, + "metadata": { + "number": 2964, + "title": "Decide every odd-order character rank cut before bit-word search", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "466c65e73b3efb5f8144799792fbef0acf4369cf", + "isDraft": false + }, + "reviewed_head": "466c65e73b3efb5f8144799792fbef0acf4369cf", + "current_head": "466c65e73b3efb5f8144799792fbef0acf4369cf", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/bit-odd-character-screen" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2964", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2965, + "metadata": { + "number": 2965, + "title": "Bound completed QQ16 producer errors through the decoder", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "526f2c242202b31b15e09a7502dfb8ff757b2bad", + "isDraft": false + }, + "reviewed_head": "526f2c242202b31b15e09a7502dfb8ff757b2bad", + "current_head": "526f2c242202b31b15e09a7502dfb8ff757b2bad", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-producer-defect-transfer" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2965", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2966, + "metadata": { + "number": 2966, + "title": "Conditional κ = 0.001724034272523452: fourteen declared gate rewrites (five classes) on #2942's words and literal allocation", + "author": { + "id": "U_kgDOEKXqaA", + "is_bot": false, + "login": "jeremykothe2", + "name": "" + }, + "headRefOid": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "isDraft": false + }, + "reviewed_head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "current_head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/e62d3eb9005117d82a9babcfa937ecc53237c490" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_historical_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2966", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original commit retained in main ancestry; differing files NOT installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2968, + "metadata": { + "number": 2968, + "title": "Audit high-scaling physical scratch inventory and tape costs", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "cf4fc903951cd3f034531f7089d0a178f0f67b05", + "isDraft": false + }, + "reviewed_head": "cf4fc903951cd3f034531f7089d0a178f0f67b05", + "current_head": "cf4fc903951cd3f034531f7089d0a178f0f67b05", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/high-scaling-scratch-traffic" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2968", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2969, + "metadata": { + "number": 2969, + "title": "Compose normal-45 extraction and fourteen gate rewrites: candidate κ ≈ 0.0017240352247481", + "author": { + "id": "MDQ6VXNlcjQ5MDU0NTMy", + "is_bot": false, + "login": "Dugongue", + "name": "" + }, + "headRefOid": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "isDraft": false + }, + "reviewed_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "current_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/paired-swap-normal45" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2969", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2970, + "metadata": { + "number": 2970, + "title": "Certify the F-star one-interior-label gap on tied_min", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "bef9060f6b923577ca1d5a78266fd84df00ca93a", + "isDraft": false + }, + "reviewed_head": "bef9060f6b923577ca1d5a78266fd84df00ca93a", + "current_head": "bef9060f6b923577ca1d5a78266fd84df00ca93a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/fstar-one-interior-label" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2970", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2971, + "metadata": { + "number": 2971, + "title": "Complete native and hosted replay of the R438 bit improvement", + "author": { + "id": "MDQ6VXNlcjgwMjk5Njgz", + "is_bot": false, + "login": "CubeJerry", + "name": "" + }, + "headRefOid": "cc009708e5d7ca1e76a3263eb4e9efce57ac7d10", + "isDraft": false + }, + "reviewed_head": "cc009708e5d7ca1e76a3263eb4e9efce57ac7d10", + "current_head": "cc009708e5d7ca1e76a3263eb4e9efce57ac7d10", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/r438-native-rehost" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2971", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2972, + "metadata": { + "number": 2972, + "title": "Audit: stock-margin chain closes for the remaining cutoff pairs (no new kappa)", + "author": { + "id": "MDQ6VXNlcjE1MzM0MQ==", + "is_bot": false, + "login": "kumagi", + "name": "Hiroki KUMAZAKI" + }, + "headRefOid": "d6b883f97d2fd176171553b695005a132156d961", + "isDraft": false + }, + "reviewed_head": "d6b883f97d2fd176171553b695005a132156d961", + "current_head": "d6b883f97d2fd176171553b695005a132156d961", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/stock-margin-chain" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2972", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2973, + "metadata": { + "number": 2973, + "title": "Correct word-census parity budgets; 22 <= f(7) <= 24 in the PR943 model", + "author": { + "id": "MDQ6VXNlcjk0NjMxMDU=", + "is_bot": false, + "login": "NicholasStone", + "name": "Nicholas Stone" + }, + "headRefOid": "d48f3945dbb1ef5d06835744c4082b3bd04181c0", + "isDraft": false + }, + "reviewed_head": "d48f3945dbb1ef5d06835744c4082b3bd04181c0", + "current_head": "d48f3945dbb1ef5d06835744c4082b3bd04181c0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-weight-parity-census-correction" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2973", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2974, + "metadata": { + "number": 2974, + "title": "Independently verify PR2942 owner-to-recursive-cost bridge", + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "9cffaeb321429eb0b3f192aef05ce4ff3dae4b9f", + "isDraft": false + }, + "reviewed_head": "9cffaeb321429eb0b3f192aef05ce4ff3dae4b9f", + "current_head": "9cffaeb321429eb0b3f192aef05ce4ff3dae4b9f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/normal45-owner-cost-bridge" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2974", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2975, + "metadata": { + "number": 2975, + "title": "Accelerate exact four-flat requirement enumeration by 33x on a pinned corpus", + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "1d7b491c9efad451d49dbfd36a3be7443999bf17", + "isDraft": false + }, + "reviewed_head": "1d7b491c9efad451d49dbfd36a3be7443999bf17", + "current_head": "1d7b491c9efad451d49dbfd36a3be7443999bf17", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/two-flat-cover-branching" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2975", + "merge_commit": "47fa55b3cd8c7cf8879206f33569bc59d637dad8" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016c.json" + ] + }, + { + "number": 2977, + "metadata": { + "number": 2977, + "title": "Audit selected scatter parity across word and record checks", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "cd23d242dfe0e7a71cafba0ad5590dc4f2fbf4f2", + "isDraft": false + }, + "reviewed_head": "cd23d242dfe0e7a71cafba0ad5590dc4f2fbf4f2", + "current_head": "cd23d242dfe0e7a71cafba0ad5590dc4f2fbf4f2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/scatter-export-parity-audit" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2977", + "merge_commit": "ff9019ba07a87ce40765c6e75dc4fb82df6a7789" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016d.json" + ] + }, + { + "number": 2978, + "metadata": { + "number": 2978, + "title": "F-star family gap: Lemma BPP's without-loss question answered NO - box-completeness fails at tau >= 1, minimal counterexample v = 3 (no kappa)", + "headRefOid": "12eb7b832de9239a314a7cddf6c6033d618cd8f2", + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "isDraft": false + }, + "reviewed_head": "12eb7b832de9239a314a7cddf6c6033d618cd8f2", + "current_head": "12eb7b832de9239a314a7cddf6c6033d618cd8f2", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Repair malformed vendored predecessor/pr2963/predecessor/pr2914/CERTIFICATE.json; source-only JSON intake fails before scientific review. Retain authentic predecessor bytes and update declared source pins consistently. Mathematical claims remain unreviewed.", + "closure": null, + "scope": "Source syntax/integrity intake: malformed vendored JSON. No scientific execution or endorsement.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/pr2978-source-hold.json" + ] + }, + { + "number": 2979, + "metadata": { + "number": 2979, + "title": "Conditional κ ≈ 0.0017290339826465: joint rank-7 end frames, five paired extractions and #2957's rewrites on #2942's words (+5.00e-6 over #2969)", + "author": { + "id": "MDQ6VXNlcjMwNTExNDU2", + "is_bot": false, + "login": "mdumitrean", + "name": "aigent-marius" + }, + "headRefOid": "be191346391661f4d35fc0d1508d0a6029572576", + "isDraft": false + }, + "reviewed_head": "be191346391661f4d35fc0d1508d0a6029572576", + "current_head": "be191346391661f4d35fc0d1508d0a6029572576", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-endframes" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete native/outer replay remain open. The proposed kappa is an author claim, not the selected result.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2979", + "merge_commit": "30f016dd79ee6a23c40d7dab44a9466c148c42dd" + }, + "scope": "Exact-source archival intake only. No submitted scientific code executed and no selected-bound update.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archive-pr2979.json" + ] + }, + { + "number": 2980, + "metadata": { + "number": 2980, + "title": "Record the odd-prime depth-zero unit root as a weight, not a padded-row reversal", + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "d0aa33af7c20b2ce28ea64d615ff63a164384e4e", + "isDraft": false + }, + "reviewed_head": "d0aa33af7c20b2ce28ea64d615ff63a164384e4e", + "current_head": "d0aa33af7c20b2ce28ea64d615ff63a164384e4e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-odd-prime-unit-root" + ], + "unresolved_question": "Independent scientific review and registered source-bound replay remain open. No new supplier, selected result or theorem validation is implied by archival publication.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2980", + "merge_commit": "86b5e56d4aa0ced955ac7f059eac0c3a5633ca59" + }, + "scope": "Source-only archival intake. No submitted scientific code executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-pr2980-2981.json" + ] + }, + { + "number": 2981, + "metadata": { + "number": 2981, + "title": "Research: certify joint P104 unit-step endpoint flags (no new kappa)", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "isDraft": false + }, + "reviewed_head": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "current_head": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-joint-unit-flags" + ], + "unresolved_question": "Independent scientific review and registered source-bound replay remain open. No new supplier, selected result or theorem validation is implied by archival publication.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2981", + "merge_commit": "86b5e56d4aa0ced955ac7f059eac0c3a5633ca59" + }, + "scope": "Source-only archival intake. No submitted scientific code executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-pr2980-2981.json" + ] + }, + { + "number": 2982, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b9ac0d07eb9cdc31c4dca8dcc218943998edd3e8", + "isDraft": false, + "number": 2982, + "title": "Certify sharp linear wrapper costs for complete high routes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2982" + }, + "reviewed_head": "b9ac0d07eb9cdc31c4dca8dcc218943998edd3e8", + "current_head": "b9ac0d07eb9cdc31c4dca8dcc218943998edd3e8", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/high-route-prefix-cost" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2982", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2984, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "34d7c3feaf87b878d9524c215b678403b8afdc08", + "isDraft": false, + "number": 2984, + "title": "Tooling: 2.25x faster corrected f(7) census with identical traversal", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2984" + }, + "reviewed_head": "34d7c3feaf87b878d9524c215b678403b8afdc08", + "current_head": "34d7c3feaf87b878d9524c215b678403b8afdc08", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-parity-mask-replay" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2984", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2985, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "b07b0e3226bcbe32a90c1b43ab225c339086f7b5", + "isDraft": false, + "number": 2985, + "title": "Research: one-sided residue closures — Circuit Lemma, relative root counting and plane lemma close 480 of the 603 d>=4 residues (116 open; no kappa claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2985" + }, + "reviewed_head": "b07b0e3226bcbe32a90c1b43ab225c339086f7b5", + "current_head": "b07b0e3226bcbe32a90c1b43ab225c339086f7b5", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/one-sided-residue-closures/evidence/logs/nj4.out; missing flat manifest file research/one-sided-residue-closures/provenance/generator/land7.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 2986, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "f610bda7818df522c26b28f5766a06c5ef5c270c", + "isDraft": false, + "number": 2986, + "title": "Fix replay selection through symlinked input paths", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2986" + }, + "reviewed_head": "f610bda7818df522c26b28f5766a06c5ef5c270c", + "current_head": "f610bda7818df522c26b28f5766a06c5ef5c270c", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/replay-input-symlink-alias" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2986", + "merge_commit": "5d2f626f73aa981d67f438e424e7df79f5496586" + } + }, + { + "number": 2987, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "02c3047a1e78e6e35e7573c12434ba26f6f9bd96", + "isDraft": false, + "number": 2987, + "title": "Certify rank-seven chronological packing bound and cost-neutral repair", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2987" + }, + "reviewed_head": "02c3047a1e78e6e35e7573c12434ba26f6f9bd96", + "current_head": "02c3047a1e78e6e35e7573c12434ba26f6f9bd96", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-chronological-face" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2987", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2989, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "133cd8a7c5ce16a3d66e3372c5fdd9e88067d75b", + "isDraft": false, + "number": 2989, + "title": "Independently audit selected compiler ordering and owner guards", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2989" + }, + "reviewed_head": "133cd8a7c5ce16a3d66e3372c5fdd9e88067d75b", + "current_head": "133cd8a7c5ce16a3d66e3372c5fdd9e88067d75b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-compiler-correspondence" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2989", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2990, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9158ee6d097e8058b177c54a1f68a6c30249c8f8", + "isDraft": false, + "number": 2990, + "title": "fix(tests): prevent stale bytecode from hiding failures", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2990" + }, + "reviewed_head": "9158ee6d097e8058b177c54a1f68a6c30249c8f8", + "current_head": "9158ee6d097e8058b177c54a1f68a6c30249c8f8", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/isolated-test-bytecode" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2990", + "merge_commit": "cedad3e65c45c4ca1e00b02a2ae8055e8d2bb57a" + } + }, + { + "number": 2991, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "7d9452f7b99901c78f49fcb1244d5c3a87dbca02", + "isDraft": false, + "number": 2991, + "title": "docs: map P104 precision contracts and remaining implementation obligations", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2991" + }, + "reviewed_head": "7d9452f7b99901c78f49fcb1244d5c3a87dbca02", + "current_head": "7d9452f7b99901c78f49fcb1244d5c3a87dbca02", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/bottleneck-brief.md", + "docs/research/p104-precision-contract-map.md" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2991", + "merge_commit": "4dab22885e1d153e8258ddf96fa5566af27b3ec4" + } + }, + { + "number": 2992, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "b31bf0360ad702b1be71dea7a33edc11711084af", + "isDraft": false, + "number": 2992, + "title": "Enforce simple scatter supports at opt-in checker and exporter boundaries", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2992" + }, + "reviewed_head": "b31bf0360ad702b1be71dea7a33edc11711084af", + "current_head": "b31bf0360ad702b1be71dea7a33edc11711084af", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/simple-scatter-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2992", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2993, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "34a7003866390618b8e8006dc483e7a37a37903f", + "isDraft": false, + "number": 2993, + "title": "Independently audit #2979's joint rank-seven frame paths", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2993" + }, + "reviewed_head": "34a7003866390618b8e8006dc483e7a37a37903f", + "current_head": "34a7003866390618b8e8006dc483e7a37a37903f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-frame-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2993", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2994, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "900ab6c9e1f9cc5dcc1ca93ed7db966e7cf883a5", + "isDraft": false, + "number": 2994, + "title": "Audit case-insensitive replay inputs against Git spelling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2994" + }, + "reviewed_head": "900ab6c9e1f9cc5dcc1ca93ed7db966e7cf883a5", + "current_head": "900ab6c9e1f9cc5dcc1ca93ed7db966e7cf883a5", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/replay-input-case-alias" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2994", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2995, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "8ba0358b62edbeb16a0842473500c468d8c0759b", + "isDraft": false, + "number": 2995, + "title": "Certify an F0 scalar fault witness with exact dirty restoration", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2995" + }, + "reviewed_head": "8ba0358b62edbeb16a0842473500c468d8c0759b", + "current_head": "8ba0358b62edbeb16a0842473500c468d8c0759b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-producer-dirty-fault" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2995", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2996, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4d772802fe86e5185d5468db86b36472e6c81b96", + "isDraft": false, + "number": 2996, + "title": "Certify P104 dependency obstruction for every fixed-pair flag completion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2996" + }, + "reviewed_head": "4d772802fe86e5185d5468db86b36472e6c81b96", + "current_head": "4d772802fe86e5185d5468db86b36472e6c81b96", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-endpoint-completion-flow" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2996", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2997, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "16e790e10cc0bc737b9cd269020d3d967d36430f", + "isDraft": false, + "number": 2997, + "title": "Audit missing information paths in the fixed P104 joint flags", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2997" + }, + "reviewed_head": "16e790e10cc0bc737b9cd269020d3d967d36430f", + "current_head": "16e790e10cc0bc737b9cd269020d3d967d36430f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-flag-information-flow" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2997", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2998, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "3aa400ed59d19b9d6c08e22d1b75edb36a1d3e27", + "isDraft": false, + "number": 2998, + "title": "Research: prove a sharp S4 coordinate-cut gap for mixed targets", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2998" + }, + "reviewed_head": "3aa400ed59d19b9d6c08e22d1b75edb36a1d3e27", + "current_head": "3aa400ed59d19b9d6c08e22d1b75edb36a1d3e27", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/s4-two-premium-cut-envelope" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2998", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2999, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "ac6025235b6f1233291000d35a067198628569e9", + "isDraft": false, + "number": 2999, + "title": "Prove adaptive P104 rounding collisions and retained-history bounds", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2999" + }, + "reviewed_head": "ac6025235b6f1233291000d35a067198628569e9", + "current_head": "ac6025235b6f1233291000d35a067198628569e9", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-adaptive-rounding-collision" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2999", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3000, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "4c0cf223e3e4a06099704b34202a5015f1ab1e62", + "isDraft": false, + "number": 3000, + "title": "Tooling: 9.31x faster exact four-flat maximal-mask filtering", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3000" + }, + "reviewed_head": "4c0cf223e3e4a06099704b34202a5015f1ab1e62", + "current_head": "4c0cf223e3e4a06099704b34202a5015f1ab1e62", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/four-flat-maximal-masks" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3000", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3002, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "0bc34c304441740273e30e06cb28710bdd3d788d", + "isDraft": false, + "number": 3002, + "title": "Fix numeric task references in overlap search", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3002" + }, + "reviewed_head": "0bc34c304441740273e30e06cb28710bdd3d788d", + "current_head": "0bc34c304441740273e30e06cb28710bdd3d788d", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "autoresearch.md", + "docs/research/overlap-task-reference-matching.md", + "scripts/find_overlap.py", + "tests/test_research_overlap_terms.py" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3002", + "merge_commit": "3051cf1605606c32589c2823e0e54f017119d3f5" + } + }, + { + "number": 3003, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "38a0eddf69de8d64840353b5e1ed53bb37b6bc68", + "isDraft": false, + "number": 3003, + "title": "Add exact controls for one-sided residue dominance provenance", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3003" + }, + "reviewed_head": "38a0eddf69de8d64840353b5e1ed53bb37b6bc68", + "current_head": "38a0eddf69de8d64840353b5e1ed53bb37b6bc68", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/one-sided-landscape-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3003", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3004, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE1MzM0MQ==", + "is_bot": false, + "login": "kumagi", + "name": "Hiroki KUMAZAKI" + }, + "headRefOid": "ce08d19f6e43bbc6f552858d93154efe3aa98916", + "isDraft": false, + "number": 3004, + "title": "Audit: exact scatter parity contract at the checker/exporter boundary (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3004" + }, + "reviewed_head": "ce08d19f6e43bbc6f552858d93154efe3aa98916", + "current_head": "ce08d19f6e43bbc6f552858d93154efe3aa98916", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/scatter-parity-contract-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3004", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3005, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "68e67922294d96a42f479f80fdc352eb04a9b550", + "isDraft": false, + "number": 3005, + "title": "Independently corroborate the corrected seven-label word exclusion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3005" + }, + "reviewed_head": "68e67922294d96a42f479f80fdc352eb04a9b550", + "current_head": "68e67922294d96a42f479f80fdc352eb04a9b550", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-union-support-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3005", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3006, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1432a43a331ec857f45093a1d6e16acdbe9849e2", + "isDraft": false, + "number": 3006, + "title": "test(research): audit V45 native residual and private endpoint", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3006" + }, + "reviewed_head": "1432a43a331ec857f45093a1d6e16acdbe9849e2", + "current_head": "1432a43a331ec857f45093a1d6e16acdbe9849e2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-native-endpoint" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3006", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3007, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "3cb500b743f36e13d21b6a46f126846bf36bad32", + "isDraft": false, + "number": 3007, + "title": "fix(research): require exact Git spelling for replay inputs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3007" + }, + "reviewed_head": "3cb500b743f36e13d21b6a46f126846bf36bad32", + "current_head": "3cb500b743f36e13d21b6a46f126846bf36bad32", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/replay-input-head-spelling" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3007", + "merge_commit": "e983379b309c2389608ad7903ae7258a79a36fdd" + } + }, + { + "number": 3008, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "948a997eba1aaf13d04e2b52edf70404860d19dc", + "isDraft": false, + "number": 3008, + "title": "test(research): bind V45 helper and private-buffer events", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3008" + }, + "reviewed_head": "948a997eba1aaf13d04e2b52edf70404860d19dc", + "current_head": "948a997eba1aaf13d04e2b52edf70404860d19dc", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-event-binding" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3008", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3009, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE1MzM0MQ==", + "is_bot": false, + "login": "kumagi", + "name": "Hiroki KUMAZAKI" + }, + "headRefOid": "95568ae83a73ace578e3972a01aef55c889e58a2", + "isDraft": false, + "number": 3009, + "title": "Tooling: 1.27x faster t16 invoice-boundary replay via compresslevel=1 (identical receipt)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3009" + }, + "reviewed_head": "95568ae83a73ace578e3972a01aef55c889e58a2", + "current_head": "95568ae83a73ace578e3972a01aef55c889e58a2", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/t16-invoice-boundary-audit" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3009", + "merge_commit": "6837fa6f28d065dc43b1f7c1fef7c1e8347633ca" + } + }, + { + "number": 3010, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "87ca15cf005ab232ca0104ec5137014ac754f487", + "isDraft": false, + "number": 3010, + "title": "Certify a sharp frozen-fill boundary for rank-seven inverse swaps", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3010" + }, + "reviewed_head": "87ca15cf005ab232ca0104ec5137014ac754f487", + "current_head": "87ca15cf005ab232ca0104ec5137014ac754f487", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-face-boundary-fill" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3010", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3011, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "c5b58be95592a408d0cc42b0b829a3b543fd4b3b", + "isDraft": false, + "number": 3011, + "title": "Show the unit-weight GL2 machine reverses every column at one gap", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3011" + }, + "reviewed_head": "c5b58be95592a408d0cc42b0b829a3b543fd4b3b", + "current_head": "c5b58be95592a408d0cc42b0b829a3b543fd4b3b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-unit-weight-reversal" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3011", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3012, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "63c6525120c20543c4a7acae1a1e1ea36e099b81", + "isDraft": false, + "number": 3012, + "title": "F-star family gap: the box floor FAILS minimally at v = 3 - surviving tau >= 1 form exact (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3012" + }, + "reviewed_head": "63c6525120c20543c4a7acae1a1e1ea36e099b81", + "current_head": "63c6525120c20543c4a7acae1a1e1ea36e099b81", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: research/fstar-boxfloor-minimal-seed758ae8fe/predecessor/pr2978/data/box-search-kj-receipt.json: Expecting value: line 1 column 1 (char 0); research/fstar-boxfloor-minimal-seed758ae8fe/predecessor/pr2978/predecessor/pr2963/predecessor/pr2914/CERTIFICATE.json: Expecting value: line 1 column 1 (char 0). Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3013, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "504dc9a15f7a874a47564cdf3ae6857bbbc8d000", + "isDraft": false, + "number": 3013, + "title": "Certify the P104 matching-pool limit and a 45-missing-pair witness", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3013" + }, + "reviewed_head": "504dc9a15f7a874a47564cdf3ae6857bbbc8d000", + "current_head": "504dc9a15f7a874a47564cdf3ae6857bbbc8d000", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-rematched-dependency-screen" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3013", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3014, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "16e8db5656b4fea487a2212395f39707bf134f7a", + "isDraft": false, + "number": 3014, + "title": "test(research): certify V45's frozen-owner invoice obstruction", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3014" + }, + "reviewed_head": "16e8db5656b4fea487a2212395f39707bf134f7a", + "current_head": "16e8db5656b4fea487a2212395f39707bf134f7a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-frozen-owner-invoice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3014", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3015, + "metadata": { + "author": { + "id": "U_kgDOEKXqaA", + "is_bot": false, + "login": "jeremykothe2", + "name": "" + }, + "headRefOid": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "isDraft": false, + "number": 3015, + "title": "Conditional κ = 0.001729150973534224: one declared restore edit (R1) on PR2979's words and literal allocation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3015" + }, + "reviewed_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "current_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-endframes-restore-edit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3015", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3016, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4471aa49f9f0dd9332b0f1819bead8e331e824db", + "isDraft": false, + "number": 3016, + "title": "fix(replay): make owner verification repeatable", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3016" + }, + "reviewed_head": "4471aa49f9f0dd9332b0f1819bead8e331e824db", + "current_head": "4471aa49f9f0dd9332b0f1819bead8e331e824db", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/half-stage-evacuation", + "research/owner-replay-workspaces", + "research/source-partner-residual-exchanges" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3016", + "merge_commit": "2b43ca4a3a9c704a037718d4023214a7db48ba0a" + } + }, + { + "number": 3017, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "0f493f4c264fbc70ee14364b68af260d858c143c", + "isDraft": false, + "number": 3017, + "title": "Audit: bind the QQ16 dirty-helper fault to native execution", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3017" + }, + "reviewed_head": "0f493f4c264fbc70ee14364b68af260d858c143c", + "current_head": "0f493f4c264fbc70ee14364b68af260d858c143c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-native-dirty-fault" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3017", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3018, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "isDraft": false, + "number": 3018, + "title": "feat(research): lower the rank-seven packing moment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3018" + }, + "reviewed_head": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "current_head": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-integrality-exchange" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3018", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3019, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "44d12bdeb8ade4066645bd968bebd4756b06200a", + "isDraft": false, + "number": 3019, + "title": "Certify a single P104 matching with complete relaxed support", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3019" + }, + "reviewed_head": "44d12bdeb8ade4066645bd968bebd4756b06200a", + "current_head": "44d12bdeb8ade4066645bd968bebd4756b06200a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-coherent-support-witness" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3019", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3020, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "e49abeef32a376f9e8500999ef15594af2587779", + "isDraft": false, + "number": 3020, + "title": "Construct a four-bin relay beyond frozen direct swaps", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3020" + }, + "reviewed_head": "e49abeef32a376f9e8500999ef15594af2587779", + "current_head": "e49abeef32a376f9e8500999ef15594af2587779", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-multibin-face-relay" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3020", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3021, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "217edac2ebfa6250536bd6df153de14901a69395", + "isDraft": false, + "number": 3021, + "title": "feat(research): compose restore and packing gains", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3021" + }, + "reviewed_head": "217edac2ebfa6250536bd6df153de14901a69395", + "current_head": "217edac2ebfa6250536bd6df153de14901a69395", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-packing-composition" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3021", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3022, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "isDraft": false, + "number": 3022, + "title": "feat(research): improve doubled rank-seven packing", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3022" + }, + "reviewed_head": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "current_head": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-doubled-residual-exchange" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3022", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3023, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "02ebc2ff8243baa9febbb6954f9169e4c216a65e", + "isDraft": false, + "number": 3023, + "title": "KB3h: (12,6) A-vanish (5,1) PROVEN impossible; (4,2)/(3,3) reduced to exact walkable forms (outcome=partial; no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3023" + }, + "reviewed_head": "02ebc2ff8243baa9febbb6954f9169e4c216a65e", + "current_head": "02ebc2ff8243baa9febbb6954f9169e4c216a65e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-18point-avtail-seed010d26fa" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3023", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3024, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "isDraft": false, + "number": 3024, + "title": "Attain the joint rank-seven packing cap exactly at T740", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3024" + }, + "reviewed_head": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "current_head": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-cap740" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3024", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3025, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "a544ef068a46f4de3bc47d1d02149cbdc3ba547f", + "isDraft": false, + "number": 3025, + "title": "Construction: reversible integer-lifting cleanup for the P104 collector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3025" + }, + "reviewed_head": "a544ef068a46f4de3bc47d1d02149cbdc3ba547f", + "current_head": "a544ef068a46f4de3bc47d1d02149cbdc3ba547f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-reversible-lifting" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3025", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3026, + "metadata": { + "author": { + "id": "MDQ6VXNlcjQ0MTczMTcz", + "is_bot": false, + "login": "flyingviper", + "name": "" + }, + "headRefOid": "d323df51afdb616d73ff577179bfb76d8832450d", + "isDraft": false, + "number": 3026, + "title": "P112: sharp cost-45 floor for all low-tariff frames on five triads", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3026" + }, + "reviewed_head": "d323df51afdb616d73ff577179bfb76d8832450d", + "current_head": "d323df51afdb616d73ff577179bfb76d8832450d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-five-group-projector-lift" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3026", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3027, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "e686b4a622846c01ac80d038d1441434e9c0b13c", + "isDraft": false, + "number": 3027, + "title": "Record that the selected-grammar root rejects the unit tape", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3027" + }, + "reviewed_head": "e686b4a622846c01ac80d038d1441434e9c0b13c", + "current_head": "e686b4a622846c01ac80d038d1441434e9c0b13c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-unit-root-tape-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3027", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3028, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9d10633660a3dff5469f4e7a0a009a6c9994c0d7", + "isDraft": false, + "number": 3028, + "title": "feat(research): release the T148 restore composition", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3028" + }, + "reviewed_head": "9d10633660a3dff5469f4e7a0a009a6c9994c0d7", + "current_head": "9d10633660a3dff5469f4e7a0a009a6c9994c0d7", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-t148-restore-release" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3028", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3029, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "6a2de790fadcf87db02eaa99b19b92eed5aa0d3f", + "isDraft": false, + "number": 3029, + "title": "Two-sided deficiency budget: Theorem BX for b_Q <= 4 (conditional frame, exact residue, no κ claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3029" + }, + "reviewed_head": "6a2de790fadcf87db02eaa99b19b92eed5aa0d3f", + "current_head": "6a2de790fadcf87db02eaa99b19b92eed5aa0d3f", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/two-sided-deficiency-budget/evidence/orig_chk8_B78.log; missing flat manifest file research/two-sided-deficiency-budget/evidence/orig_chk8_B80_first40.log. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3030, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "78e77d820393c6b8648b47af219e991edfcc54e6", + "isDraft": false, + "number": 3030, + "title": "feat(research): release the T740 R1 cap composition", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3030" + }, + "reviewed_head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "current_head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-t740-release" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3030", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3031, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "e75906fc4e8b9f756a9877b2e467f4e564851c7d", + "isDraft": false, + "number": 3031, + "title": "KB5L: tau >= 1 box floor PROVEN at v = 5 - shareable class narrowed - no kappa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3031" + }, + "reviewed_head": "e75906fc4e8b9f756a9877b2e467f4e564851c7d", + "current_head": "e75906fc4e8b9f756a9877b2e467f4e564851c7d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: research/fstar-boxfloor-v5-seedab80f07c/predecessor/pr3012/predecessor/pr2978/data/box-search-kj-receipt.json: Expecting value: line 1 column 1 (char 0); research/fstar-boxfloor-v5-seedab80f07c/predecessor/pr3012/predecessor/pr2978/predecessor/pr2963/predecessor/pr2914/CERTIFICATE.json: Expecting value: line 1 column 1 (char 0). Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3032, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "5b1a7939393ef2778ec058ee8367cdad52c86fb3", + "isDraft": false, + "number": 3032, + "title": "Reject PR3019 fixed P104 matching with a monotone relay cut", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3032" + }, + "reviewed_head": "5b1a7939393ef2778ec058ee8367cdad52c86fb3", + "current_head": "5b1a7939393ef2778ec058ee8367cdad52c86fb3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-fixed-matching-flag-consistency" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3032", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3033, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "b12bbaeb5ca2e83f15433fc2dd0ba3b766595281", + "isDraft": false, + "number": 3033, + "title": "Research: exact four-bit reduction and faster P104 lifting reference", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3033" + }, + "reviewed_head": "b12bbaeb5ca2e83f15433fc2dd0ba3b766595281", + "current_head": "b12bbaeb5ca2e83f15433fc2dd0ba3b766595281", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-lifting-residue-reduction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3033", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3034, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "a05791d428f5d06802fb4c96b33732e6347c64eb", + "isDraft": false, + "number": 3034, + "title": "KB3i: the 18-point cover remainder for F2^7 - parity shortcut DEMOTED, m=5 obstruction localized (outcome=partial, no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3034" + }, + "reviewed_head": "a05791d428f5d06802fb4c96b33732e6347c64eb", + "current_head": "a05791d428f5d06802fb4c96b33732e6347c64eb", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-18point-remainder-kb3i-a1" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3034", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3035, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "0cc430349a3f3dc200666bc22e997076e0a557ed", + "isDraft": false, + "number": 3035, + "title": "Certify a 343-bit coupled residue domain for P104 lifting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3035" + }, + "reviewed_head": "0cc430349a3f3dc200666bc22e997076e0a557ed", + "current_head": "0cc430349a3f3dc200666bc22e997076e0a557ed", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-coupled-lifting-residues" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3035", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3036, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "3717c1e684553c57bc73300410df65438a9ef095", + "isDraft": false, + "number": 3036, + "title": "Audit concrete rounding in the QQ16 F0 scalar projection", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3036" + }, + "reviewed_head": "3717c1e684553c57bc73300410df65438a9ef095", + "current_head": "3717c1e684553c57bc73300410df65438a9ef095", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-f0-rounded-scalar" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3036", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3037, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "02a1c41e8e016d3d0be64c62c8b4734f9c494236", + "isDraft": false, + "number": 3037, + "title": "Prove the P104 lifting translation lattice is maximal", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3037" + }, + "reviewed_head": "02a1c41e8e016d3d0be64c62c8b4734f9c494236", + "current_head": "02a1c41e8e016d3d0be64c62c8b4734f9c494236", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-maximal-translation-lattice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3037", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3038, + "metadata": { + "author": { + "id": "MDQ6VXNlcjI3NTY4NjE3", + "is_bot": false, + "login": "ToikY", + "name": "" + }, + "headRefOid": "c7d0d7be056ba77fda1c168641b2bcffb10cf43d", + "isDraft": false, + "number": 3038, + "title": "test(research): certify the V45 closed native endpoint cone", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3038" + }, + "reviewed_head": "c7d0d7be056ba77fda1c168641b2bcffb10cf43d", + "current_head": "c7d0d7be056ba77fda1c168641b2bcffb10cf43d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-native-cone-seed78" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3038", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3039, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "f0d6a48245e44fc29cfe077d21ca2521c2a8d941", + "isDraft": false, + "number": 3039, + "title": "Block-climb complete profile: exact obstruction for charged block-climb realization - no kappa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3039" + }, + "reviewed_head": "f0d6a48245e44fc29cfe077d21ca2521c2a8d941", + "current_head": "f0d6a48245e44fc29cfe077d21ca2521c2a8d941", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "The per-group inequality does not justify excluding every mixed complete profile. PR3066 supplies a free/charged cost-alphabet counterexample; scope the obstruction to individual charged groups and re-audit the call-level inference. No physical decoder or improved supplier follows from that counterexample.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3040, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "53fc5af5b778b8bbe6472d69a4f112d76febc108", + "isDraft": false, + "number": 3040, + "title": "Rank-8 rigidity of the E8 pattern with arbitrary extra zeros after deleting any at most 8 lines (hypothesis (1) of Lemma RIGD; no kappa claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3040" + }, + "reviewed_head": "53fc5af5b778b8bbe6472d69a4f112d76febc108", + "current_head": "53fc5af5b778b8bbe6472d69a4f112d76febc108", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/e8-rank8-rigidity-small-deletions/evidence/cubev8.out; missing flat manifest file research/e8-rank8-rigidity-small-deletions/evidence/R1-RIG3/fr_40.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3041, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b89c9eef729eb1e5889e2095d59a6fbf4738447d", + "isDraft": false, + "number": 3041, + "title": "Independently prove conditional selected residual/CALL refinement", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3041" + }, + "reviewed_head": "b89c9eef729eb1e5889e2095d59a6fbf4738447d", + "current_head": "b89c9eef729eb1e5889e2095d59a6fbf4738447d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/residual-call-refinement" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3041", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3042, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "84cc406ad91ec53fff329a11a445d7effe564a77", + "isDraft": false, + "number": 3042, + "title": "Conditional κ = 0.001729736166387916: six restore carrier/pivot skips (R1_E42, R2_E7) on PR2979's words and literal allocation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3042" + }, + "reviewed_head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "current_head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-carrier-skips" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3042", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3043, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "b5cabfb02a3d8bc3121825144373b03a5648479d", + "isDraft": false, + "number": 3043, + "title": "Construct and price a reversible P104 residue extractor", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3043" + }, + "reviewed_head": "b5cabfb02a3d8bc3121825144373b03a5648479d", + "current_head": "b5cabfb02a3d8bc3121825144373b03a5648479d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-modular-residue-reducer" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3043", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3044, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1f922b25abff2d7fd87fa5b29619160862a06b59", + "isDraft": false, + "number": 3044, + "title": "feat(research): share the rank-seven restore covector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3044" + }, + "reviewed_head": "1f922b25abff2d7fd87fa5b29619160862a06b59", + "current_head": "1f922b25abff2d7fd87fa5b29619160862a06b59", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-shared-restore-fanin" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3044", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3045, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "16feea078f5542964ae85ca1b1f35bb94314ae78", + "isDraft": false, + "number": 3045, + "title": "Non-dense fitting B: every E8 term with x·y ≠ 0 has rank ≥ 9; square root-code floors E8 ≥ 72, P112 ≥ 64, P104 ≥ 56, D4 ≥ 12 for any fitting B (no κ claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3045" + }, + "reviewed_head": "16feea078f5542964ae85ca1b1f35bb94314ae78", + "current_head": "16feea078f5542964ae85ca1b1f35bb94314ae78", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/nondense-pairing-square-floors/evidence/a1_brute.log; missing flat manifest file research/nondense-pairing-square-floors/evidence/a1_e8.log. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3046, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "5549524f7894120b7e993522eb3a59956df5c5c3", + "isDraft": false, + "number": 3046, + "title": "Reuse the forward P104 residue basis for the exact inverse", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3046" + }, + "reviewed_head": "5549524f7894120b7e993522eb3a59956df5c5c3", + "current_head": "5549524f7894120b7e993522eb3a59956df5c5c3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-inverse-residue-permutation" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3046", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3047, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "8beaff37e90aa63141ec148ba85da4d6fc80c935", + "isDraft": false, + "number": 3047, + "title": "fix(tooling): name offending keys, caps and shapes in research package checks", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3047" + }, + "reviewed_head": "8beaff37e90aa63141ec148ba85da4d6fc80c935", + "current_head": "8beaff37e90aa63141ec148ba85da4d6fc80c935", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/research-package-guide.md", + "scripts/research_package.py", + "tests/test_research_package_diagnostics.py" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3047", + "merge_commit": "bc191093c71895ec9c70f238c58056e428b21847" + } + }, + { + "number": 3048, + "metadata": { + "author": { + "id": "MDQ6VXNlcjQ0MTczMTcz", + "is_bot": false, + "login": "flyingviper", + "name": "" + }, + "headRefOid": "71a0ec5012a04965826c62ad27532b5a4e014480", + "isDraft": false, + "number": 3048, + "title": "P112: exclude cost 296 in the aligned six-mode factor family", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3048" + }, + "reviewed_head": "71a0ec5012a04965826c62ad27532b5a4e014480", + "current_head": "71a0ec5012a04965826c62ad27532b5a4e014480", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-six-mode-exclusion" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3048", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3049, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "3d61d02651e4ba9d92229d9943d073e9c427ab95", + "isDraft": false, + "number": 3049, + "title": "Research: one-sided residue closures, part 2 — Lemma Q4, count lemma + E6 dim-cover and rerunnable span passes close 78 more of the 116 open residues (38 open; no kappa claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3049" + }, + "reviewed_head": "3d61d02651e4ba9d92229d9943d073e9c427ab95", + "current_head": "3d61d02651e4ba9d92229d9943d073e9c427ab95", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/one-sided-residue-closures-2/checks/all.out; missing flat manifest file research/one-sided-residue-closures-2/evidence/sc_rerun751/7-5-1-s0_M1r0J2j1.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3050, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "7c9d6b8b01606fa51032c0166f5ed522c8fa5735", + "isDraft": false, + "number": 3050, + "title": "test(research): independently audit the six restore skips", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3050" + }, + "reviewed_head": "7c9d6b8b01606fa51032c0166f5ed522c8fa5735", + "current_head": "7c9d6b8b01606fa51032c0166f5ed522c8fa5735", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-substitution-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3050", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3051, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMDk2NjQ=", + "is_bot": false, + "login": "jeremydiviney", + "name": "" + }, + "headRefOid": "10a45bd361554709840becb5bc26016ca49944c3", + "isDraft": false, + "number": 3051, + "title": "Verify six-skip/T740 release: conditional kappa 0.001729737950064279", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3051" + }, + "reviewed_head": "10a45bd361554709840becb5bc26016ca49944c3", + "current_head": "10a45bd361554709840becb5bc26016ca49944c3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-six-skip-cap-release" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3051", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3052, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "ae6dcf7e04de89198f8cd5321766d62bf6ee187b", + "isDraft": false, + "number": 3052, + "title": "Register the HPE post-wrapper uniqueness lemma (drawn card formal-interface-lemma)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3052" + }, + "reviewed_head": "ae6dcf7e04de89198f8cd5321766d62bf6ee187b", + "current_head": "ae6dcf7e04de89198f8cd5321766d62bf6ee187b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/hpe-post-wrapper-lemma" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3052", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3053, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "a977fd1989c092d6946766fe0e66625935799058", + "isDraft": false, + "number": 3053, + "title": "Independent verification (no κ): #3015's R1 restore edit on #2979's words is exact and correctly priced; R1 unique in its rewrite class; #3018 journal and #3021 composition reproduced; no defect found", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3053" + }, + "reviewed_head": "a977fd1989c092d6946766fe0e66625935799058", + "current_head": "a977fd1989c092d6946766fe0e66625935799058", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/t74-3015-restore-edit-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3053", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3054, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4773c3ea67b471415870e38411fae313ec44a675", + "isDraft": false, + "number": 3054, + "title": "feat(research): release the T740 six-skip composition", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3054" + }, + "reviewed_head": "4773c3ea67b471415870e38411fae313ec44a675", + "current_head": "4773c3ea67b471415870e38411fae313ec44a675", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-t740-carrier-skips" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3054", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3055, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "9dc841c9a101435fdd15e0f7623bf16b6d0363e9", + "isDraft": false, + "number": 3055, + "title": "Implement encoded physical Compact operations through B1", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3055" + }, + "reviewed_head": "9dc841c9a101435fdd15e0f7623bf16b6d0363e9", + "current_head": "9dc841c9a101435fdd15e0f7623bf16b6d0363e9", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-complex-compact" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3055", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3056, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9e4acb6049a6c1897ad8d515892f67204ab1d8c0", + "isDraft": false, + "number": 3056, + "title": "Contract PR3042's four-ADD restore block to three", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3056" + }, + "reviewed_head": "9e4acb6049a6c1897ad8d515892f67204ab1d8c0", + "current_head": "9e4acb6049a6c1897ad8d515892f67204ab1d8c0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-contraction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3056", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3057, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "8892832224cffb73553cc921e4e3b1ae75d7b886", + "isDraft": false, + "number": 3057, + "title": "Prove the complete restore-frame optimum of the six-skip words", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3057" + }, + "reviewed_head": "8892832224cffb73553cc921e4e3b1ae75d7b886", + "current_head": "8892832224cffb73553cc921e4e3b1ae75d7b886", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-frame-optimum" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3057", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3058, + "metadata": { + "author": { + "id": "MDQ6VXNlcjg2NDE2NTcy", + "is_bot": false, + "login": "conorholds", + "name": "conorholds" + }, + "headRefOid": "e67ca5f26351e09c5bb314821633e511212f88ec", + "isDraft": false, + "number": 3058, + "title": "Research: exact seven-source singleton minimum f(7) = 24", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3058" + }, + "reviewed_head": "e67ca5f26351e09c5bb314821633e511212f88ec", + "current_head": "e67ca5f26351e09c5bb314821633e511212f88ec", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/connector-covering-code" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3058", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3059, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "0b8b44c6cc367725a8737f8b3cd997f42d3bd0d9", + "isDraft": false, + "number": 3059, + "title": "Test pointwise P104 defect codes and the code-only update limit", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3059" + }, + "reviewed_head": "0b8b44c6cc367725a8737f8b3cd997f42d3bd0d9", + "current_head": "0b8b44c6cc367725a8737f8b3cd997f42d3bd0d9", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-pointwise-defect-consumer" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3059", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3060, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "df16ae619b858c5344a797c4424e0bafc2e69f62", + "isDraft": false, + "number": 3060, + "title": "Prove an optimal native tariff for the rank-seven restore block", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3060" + }, + "reviewed_head": "df16ae619b858c5344a797c4424e0bafc2e69f62", + "current_head": "df16ae619b858c5344a797c4424e0bafc2e69f62", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-native-tariff-optimum" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3060", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3063, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "3f384b8b7daccb2c8e12013fd81a738202ce0f8d", + "isDraft": false, + "number": 3063, + "title": "Prove exact dirty-output anchor child/ADD tariff frontier", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3063" + }, + "reviewed_head": "3f384b8b7daccb2c8e12013fd81a738202ce0f8d", + "current_head": "3f384b8b7daccb2c8e12013fd81a738202ce0f8d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/dirty-anchor-tradeoff" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3063", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3064, + "metadata": { + "author": { + "id": "U_kgDOFEm3gg", + "is_bot": false, + "login": "dataisfire", + "name": "dataisfire" + }, + "headRefOid": "239447f19b9365194bca2583014c947db5de8ea4", + "isDraft": false, + "number": 3064, + "title": "Propose conditional κ ≈ 0.001729737530919310 via T148 carrier skips (full replay pending)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3064" + }, + "reviewed_head": "239447f19b9365194bca2583014c947db5de8ea4", + "current_head": "239447f19b9365194bca2583014c947db5de8ea4", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-t148-restore-release", + "research/t148-carrier-skips" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Author reports resource-stopped full release; schedule a separately budgeted replay. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and 150-minute limit. No dispatch.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3064", + "merge_commit": "d6da9c46abfe949674a2ed5d6029dd6219f93434" + } + }, + { + "number": 3065, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1cd7d3af6f41dc53e02c26f0b2cf6ffb11106fc8", + "isDraft": false, + "number": 3065, + "title": "Prove the complete joint A/B/restore frame optimum", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3065" + }, + "reviewed_head": "1cd7d3af6f41dc53e02c26f0b2cf6ffb11106fc8", + "current_head": "1cd7d3af6f41dc53e02c26f0b2cf6ffb11106fc8", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-frame-optimum" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3065", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3066, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "8aa53674536727123436d3f76adb8f5dac6ddea1", + "isDraft": false, + "number": 3066, + "title": "Correct the mixed-profile inference in the block-climb screen", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3066" + }, + "reviewed_head": "8aa53674536727123436d3f76adb8f5dac6ddea1", + "current_head": "8aa53674536727123436d3f76adb8f5dac6ddea1", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/mixed-block-climb-overhead" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3066", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3067, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "e1e28b4070ae52efa5a9d0aa826bc588be7206f2", + "isDraft": false, + "number": 3067, + "title": "Bind the QQ16 F0 rounding witness to physical native execution", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3067" + }, + "reviewed_head": "e1e28b4070ae52efa5a9d0aa826bc588be7206f2", + "current_head": "e1e28b4070ae52efa5a9d0aa826bc588be7206f2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-f0-physical-rounding" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3067", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3068, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "7d2c519a1fdcc6bf66f6f08757eed7c48762d3f2", + "isDraft": false, + "number": 3068, + "title": "Certify a common invariant period lattice for P104 lifting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3068" + }, + "reviewed_head": "7d2c519a1fdcc6bf66f6f08757eed7c48762d3f2", + "current_head": "7d2c519a1fdcc6bf66f6f08757eed7c48762d3f2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-invariant-lifting-lattice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3068", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3069, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "cd02d94c5eb3c0e1452cc94aeb2231c4d704a684", + "isDraft": false, + "number": 3069, + "title": "Price signed dependent-source delivery over characteristic zero", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3069" + }, + "reviewed_head": "cd02d94c5eb3c0e1452cc94aeb2231c4d704a684", + "current_head": "cd02d94c5eb3c0e1452cc94aeb2231c4d704a684", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/signed-dependent-delivery" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3069", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3070, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "3e9445ed10067912838bd83222ea4066dcfbc62d", + "isDraft": false, + "number": 3070, + "title": "Test P104 defect codes under restricted coordinate updates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3070" + }, + "reviewed_head": "3e9445ed10067912838bd83222ea4066dcfbc62d", + "current_head": "3e9445ed10067912838bd83222ea4066dcfbc62d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-restricted-update-codes" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3070", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3071, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "6730b594ad6b0164d484ff1570d774d510fad130", + "isDraft": false, + "number": 3071, + "title": "Prove sharp selected-centre repair dimension for owner blocks up to six", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3071" + }, + "reviewed_head": "6730b594ad6b0164d484ff1570d774d510fad130", + "current_head": "6730b594ad6b0164d484ff1570d774d510fad130", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/centre-block-repair-information" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3071", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3072, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "cd1bbd05251f9d8e15cbb0192f1bfe83dc138f5e", + "isDraft": false, + "number": 3072, + "title": "Research: conditional blockwise P104 lifting at linear precision", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3072" + }, + "reviewed_head": "cd1bbd05251f9d8e15cbb0192f1bfe83dc138f5e", + "current_head": "cd1bbd05251f9d8e15cbb0192f1bfe83dc138f5e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-blockwise-lifting" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3072", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3073, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "9e808b67bc395dc91b55493a6fdce0863240bf1c", + "isDraft": false, + "number": 3073, + "title": "Factor P104 lifting defects through 201 exact real output channels", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3073" + }, + "reviewed_head": "9e808b67bc395dc91b55493a6fdce0863240bf1c", + "current_head": "9e808b67bc395dc91b55493a6fdce0863240bf1c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-defect-output-channels" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3073", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3074, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "3cc41f260c31052c933d0e75ea02f2b7677e780c", + "isDraft": false, + "number": 3074, + "title": "One-sided padding lemma: P112 to P120 at cost exactly +8 (L120 suffices for Delta >= n_nf)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3074" + }, + "reviewed_head": "3cc41f260c31052c933d0e75ea02f2b7677e780c", + "current_head": "3cc41f260c31052c933d0e75ea02f2b7677e780c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/one-sided-padding-lemma/expected/pad_audit.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3075, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "378b8e47fc01412cbc0bc49f0d7a3d40eb1d9442", + "isDraft": false, + "number": 3075, + "title": "Fully charged favourable relaxation for a k-call shared centre window", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3075" + }, + "reviewed_head": "378b8e47fc01412cbc0bc49f0d7a3d40eb1d9442", + "current_head": "378b8e47fc01412cbc0bc49f0d7a3d40eb1d9442", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/centre-shared-kcall-charged-seed615415" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3075", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3076, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "2037b8e4a8c03c2015f88904449f60d1fdf58ef3", + "isDraft": false, + "number": 3076, + "title": "Lower the complete rank-seven native bound by 340", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3076" + }, + "reviewed_head": "2037b8e4a8c03c2015f88904449f60d1fdf58ef3", + "current_head": "2037b8e4a8c03c2015f88904449f60d1fdf58ef3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-commuting-contractions" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3076", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3077, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "9e52b244e07b1d981dd945bba7ac6c16fa7fdd43", + "isDraft": false, + "number": 3077, + "title": "Research: dirty-output anchor; no selected kappa improvement", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3077" + }, + "reviewed_head": "9e52b244e07b1d981dd945bba7ac6c16fa7fdd43", + "current_head": "9e52b244e07b1d981dd945bba7ac6c16fa7fdd43", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/complex-dirty-output-temporary-sum-anchor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3077", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3078, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "3da2ea9729f70b074713a5d0f69f0bdab32f2b47", + "isDraft": false, + "number": 3078, + "title": "Materialize rank-seven scalar lowerings with explicit width guards", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3078" + }, + "reviewed_head": "3da2ea9729f70b074713a5d0f69f0bdab32f2b47", + "current_head": "3da2ea9729f70b074713a5d0f69f0bdab32f2b47", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-primitive-lowering" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3078", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3079, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "8aee45e6a918c99cdca98431c3e791d2b3fd4206", + "isDraft": false, + "number": 3079, + "title": "Research: independently replay #2979 staged rank profile and T74 aggregate", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3079" + }, + "reviewed_head": "8aee45e6a918c99cdca98431c3e791d2b3fd4206", + "current_head": "8aee45e6a918c99cdca98431c3e791d2b3fd4206", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-profile-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3079", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3080, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "fd5ff58c6c438c438481bc4bff8c86e2d4fbe865", + "isDraft": false, + "number": 3080, + "title": "Implement aligned bit circuits for the rank-seven ADD layer", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3080" + }, + "reviewed_head": "fd5ff58c6c438c438481bc4bff8c86e2d4fbe865", + "current_head": "fd5ff58c6c438c438481bc4bff8c86e2d4fbe865", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-aligned-bit-adders" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3080", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3081, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "d764f9c11c86c40d35fd67811e60284feb1b8f10", + "isDraft": false, + "number": 3081, + "title": "Implement a guarded bit caller for rank-seven dyadic ADDs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3081" + }, + "reviewed_head": "d764f9c11c86c40d35fd67811e60284feb1b8f10", + "current_head": "d764f9c11c86c40d35fd67811e60284feb1b8f10", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-fixed-width-half-add" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3081", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3082, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "c9c6b59ce5f526a0082d06b24470b7ac946e62da", + "isDraft": false, + "number": 3082, + "title": "Research: exact screen for kappa > 0.1 on selected suppliers", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3082" + }, + "reviewed_head": "c9c6b59ce5f526a0082d06b24470b7ac946e62da", + "current_head": "c9c6b59ce5f526a0082d06b24470b7ac946e62da", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/kappa01-target-screen" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3082", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3083, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "a2ff82111b42aa4abe38e2f8f0386c804111d17f", + "isDraft": false, + "number": 3083, + "title": "Certify rank-seven scalar grids and 77-bit endpoint formats", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3083" + }, + "reviewed_head": "a2ff82111b42aa4abe38e2f8f0386c804111d17f", + "current_head": "a2ff82111b42aa4abe38e2f8f0386c804111d17f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-coefficient-grid" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3083", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3084, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4b763c20da54e4e29e3edfdd1c3e251f5ede37e0", + "isDraft": false, + "number": 3084, + "title": "Prove exact alignment envelopes for rank-seven scalar streams", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3084" + }, + "reviewed_head": "4b763c20da54e4e29e3edfdd1c3e251f5ede37e0", + "current_head": "4b763c20da54e4e29e3edfdd1c3e251f5ede37e0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-scalar-lattice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3084", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3085, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "6d5db23b5ba34b20493fe9eea98d08682495a821", + "isDraft": false, + "number": 3085, + "title": "PR1 source and credit retention receipt (research consolidation, no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3085" + }, + "reviewed_head": "6d5db23b5ba34b20493fe9eea98d08682495a821", + "current_head": "6d5db23b5ba34b20493fe9eea98d08682495a821", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/pr1-retention-receipt" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3085", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3086, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1e47220c44a90976f1b53289f643794bad1aadfe", + "isDraft": false, + "number": 3086, + "title": "Prove the sharp native format at the rank-seven A13 half-ADD", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3086" + }, + "reviewed_head": "1e47220c44a90976f1b53289f643794bad1aadfe", + "current_head": "1e47220c44a90976f1b53289f643794bad1aadfe", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-native-half-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3086", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3087, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "e7e49fb8176772c71ad7006920a407109a89e440", + "isDraft": false, + "number": 3087, + "title": "Implement encoded physical Gaussian monomial phases", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3087" + }, + "reviewed_head": "e7e49fb8176772c71ad7006920a407109a89e440", + "current_head": "e7e49fb8176772c71ad7006920a407109a89e440", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-gaussian-monomial" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3087", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3088, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "19fefab093b802a58d0c432debfa72fa4b381b2d", + "isDraft": false, + "number": 3088, + "title": "Bind a physical four-ADD boundary and save 6,144 CNOTs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3088" + }, + "reviewed_head": "19fefab093b802a58d0c432debfa72fa4b381b2d", + "current_head": "19fefab093b802a58d0c432debfa72fa4b381b2d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-physical-a13" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3088", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3089, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4a5ce834638534a5bfab1b5169c4a7210b2c0656", + "isDraft": false, + "number": 3089, + "title": "Certify an 84-bit conditional rank-seven A-stage format", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3089" + }, + "reviewed_head": "4a5ce834638534a5bfab1b5169c4a7210b2c0656", + "current_head": "4a5ce834638534a5bfab1b5169c4a7210b2c0656", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-native-a-format" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3089", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3090, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "47a2bcec53667f490df6d40550e14a8ae465cba4", + "isDraft": false, + "number": 3090, + "title": "Certify coefficient construction within the 84-bit A-stage bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3090" + }, + "reviewed_head": "47a2bcec53667f490df6d40550e14a8ae465cba4", + "current_head": "47a2bcec53667f490df6d40550e14a8ae465cba4", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-coefficient-capacity" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3090", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3091, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "d546815f4b116a79bd0ecec6661d2b2b3de29377", + "isDraft": false, + "number": 3091, + "title": "Implement fused physical Gaussian coefficient arithmetic", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3091" + }, + "reviewed_head": "d546815f4b116a79bd0ecec6661d2b2b3de29377", + "current_head": "d546815f4b116a79bd0ecec6661d2b2b3de29377", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-gaussian-leaf" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3091", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3092, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "764123a9e18c9a838aee917af7657aa639804680", + "isDraft": false, + "number": 3092, + "title": "Independently audit the rank-seven coefficient-capacity claim", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3092" + }, + "reviewed_head": "764123a9e18c9a838aee917af7657aa639804680", + "current_head": "764123a9e18c9a838aee917af7657aa639804680", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-scalar-microstates" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3092", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3093, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf", + "isDraft": false, + "number": 3093, + "title": "Research: audit #2979 profile against kappa=0.1", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3093" + }, + "reviewed_head": "d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf", + "current_head": "d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Complete original version retained in Git ancestry; existing main-tree package unchanged.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_historical_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3093", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3094, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b7a761ce2d6198509adb4b09ebf22b5b17ea2f55", + "isDraft": false, + "number": 3094, + "title": "Implement a guarded Boolean caller for the rank-seven scalar layer", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3094" + }, + "reviewed_head": "b7a761ce2d6198509adb4b09ebf22b5b17ea2f55", + "current_head": "b7a761ce2d6198509adb4b09ebf22b5b17ea2f55", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-boolean-scalar-caller" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3094", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3095, + "metadata": { + "author": { + "id": "MDQ6VXNlcjgwMjk5Njgz", + "is_bot": false, + "login": "CubeJerry", + "name": "" + }, + "headRefOid": "41826461eaceb25b77c026148b50b884e3c9780e", + "isDraft": false, + "number": 3095, + "title": "Audit one-sided padding: exact field scope and normalization costs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3095" + }, + "reviewed_head": "41826461eaceb25b77c026148b50b884e3c9780e", + "current_head": "41826461eaceb25b77c026148b50b884e3c9780e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/one-sided-padding-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3095", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3096, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "b5bb91b123697d9a818ae35d2e165478756c960a", + "isDraft": false, + "number": 3096, + "title": "Record the bit-0 census false prune on 01021323", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3096" + }, + "reviewed_head": "b5bb91b123697d9a818ae35d2e165478756c960a", + "current_head": "b5bb91b123697d9a818ae35d2e165478756c960a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-bit0-false-prune" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3096", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3097, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "ef7a52f4b0acf7cc8c51f9d81274d106abeffa24", + "isDraft": false, + "number": 3097, + "title": "Research: rule out seven-owner centre information compression", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3097" + }, + "reviewed_head": "ef7a52f4b0acf7cc8c51f9d81274d106abeffa24", + "current_head": "ef7a52f4b0acf7cc8c51f9d81274d106abeffa24", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/centre-seven-owner-information-floor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3097", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3098, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "ae54061980ef6a956d1276c7775aa833c1f669ca", + "isDraft": false, + "number": 3098, + "title": "Execute scalar recipes on encoded sequential tapes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3098" + }, + "reviewed_head": "ae54061980ef6a956d1276c7775aa833c1f669ca", + "current_head": "ae54061980ef6a956d1276c7775aa833c1f669ca", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-scalar-stream" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3098", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3099, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "80b7b0b452de3c9fa4306f49d12e904a40cfbe2e", + "isDraft": false, + "number": 3099, + "title": "Record the selected scatter duplicate boundary", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3099" + }, + "reviewed_head": "80b7b0b452de3c9fa4306f49d12e904a40cfbe2e", + "current_head": "80b7b0b452de3c9fa4306f49d12e904a40cfbe2e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/scatter-duplicate-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3099", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3100, + "metadata": { + "author": { + "id": "U_kgDOE8HONA", + "is_bot": false, + "login": "josecarlosgonzalezroque-design", + "name": "" + }, + "headRefOid": "72380f027199199ed4b4dbfc252ec39163acc56c", + "isDraft": false, + "number": 3100, + "title": "Audit fractional label coercion at the bit checker/exporter boundary", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3100" + }, + "reviewed_head": "72380f027199199ed4b4dbfc252ec39163acc56c", + "current_head": "72380f027199199ed4b4dbfc252ec39163acc56c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/label-coordinate-boundary-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3100", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3101, + "metadata": { + "author": { + "id": "U_kgDOB5L2iw", + "is_bot": false, + "login": "theon199", + "name": "Sricharan Vagvala" + }, + "headRefOid": "9a6d3b4e62cd41e25557511fa9b7ef270698c605", + "isDraft": false, + "number": 3101, + "title": "Research/qq16 native rounded audit", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3101" + }, + "reviewed_head": "9a6d3b4e62cd41e25557511fa9b7ef270698c605", + "current_head": "9a6d3b4e62cd41e25557511fa9b7ef270698c605", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-native-rounded-components" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3101", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3102, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "39bb449ef136cb3899ca16a6933abba52decf021", + "isDraft": false, + "number": 3102, + "title": "Allow research task selection from sparse checkouts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3102" + }, + "reviewed_head": "39bb449ef136cb3899ca16a6933abba52decf021", + "current_head": "39bb449ef136cb3899ca16a6933abba52decf021", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/agent-procedure.md", + "scripts/choose_research_task.py", + "tests/test_research_assignment.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3102", + "merge_commit": "66d0410ce73397c9eee825ef28276d49b397ffb1" + } + }, + { + "number": 3103, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "de12c885fb742735af90b496d30760b639fd6e5a", + "isDraft": false, + "number": 3103, + "title": "Independently verify all patterns in the T740 six-skip packing cap", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3103" + }, + "reviewed_head": "de12c885fb742735af90b496d30760b639fd6e5a", + "current_head": "de12c885fb742735af90b496d30760b639fd6e5a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/t740-independent-packing-cap" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3103", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3104, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "107dd53ba63afb49688b830fc855829a1336a860", + "isDraft": false, + "number": 3104, + "title": "Fix stale commit attribution in PR path overlap reports", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3104" + }, + "reviewed_head": "107dd53ba63afb49688b830fc855829a1336a860", + "current_head": "107dd53ba63afb49688b830fc855829a1336a860", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/agent-procedure.md", + "scripts/find_overlap.py", + "tests/test_research_onboarding.py", + "tests/test_research_pr_file_pages.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3104", + "merge_commit": "e25b9809c0857a117537629188fd62264b411400" + } + }, + { + "number": 3105, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "7f6b0c765ffeaa6c75e692f73dbbad414e3d2453", + "isDraft": false, + "number": 3105, + "title": "Close the three-line F-star census remainder with a correct joint quotient", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3105" + }, + "reviewed_head": "7f6b0c765ffeaa6c75e692f73dbbad414e3d2453", + "current_head": "7f6b0c765ffeaa6c75e692f73dbbad414e3d2453", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/fstar-joint-label-census" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3105", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3106, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "1a9da866330d31d7b6edc5f514802a3ab2176f88", + "isDraft": false, + "number": 3106, + "title": "Bind and execute the first selected whole-family prefix", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3106" + }, + "reviewed_head": "1a9da866330d31d7b6edc5f514802a3ab2176f88", + "current_head": "1a9da866330d31d7b6edc5f514802a3ab2176f88", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-first-prefix" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3106", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3107, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "7d40236bf22109ad64ae95a1d25eff7fa40478b5", + "isDraft": false, + "number": 3107, + "title": "Kappa 0.1 budget screens; corrected paired-plane route", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3107" + }, + "reviewed_head": "7d40236bf22109ad64ae95a1d25eff7fa40478b5", + "current_head": "7d40236bf22109ad64ae95a1d25eff7fa40478b5", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/7d40236bf22109ad64ae95a1d25eff7fa40478b5" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Complete original version retained in Git ancestry; existing main-tree package unchanged.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_historical_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3107", + "merge_commit": "970ea2f6cc0fe5b7fa44787bee6b8fa4d059980b" + } + }, + { + "number": 3108, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "996a37e21d676a71d7f6df7e00513ce25d7f0f6d", + "isDraft": false, + "number": 3108, + "title": "KB3j: the (4,2) and (3,3) A-vanish walks - budget-honest partial with receipts; even-half self-sum profiles classified (outcome=partial; no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3108" + }, + "reviewed_head": "996a37e21d676a71d7f6df7e00513ce25d7f0f6d", + "current_head": "996a37e21d676a71d7f6df7e00513ce25d7f0f6d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-18point-av42-kb3j-b1" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3108", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3109, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "15eac811648182bdac7254a91fd9b841b1414ebc", + "isDraft": false, + "number": 3109, + "title": "Derive a batched reversible lifting bound with paid history", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3109" + }, + "reviewed_head": "15eac811648182bdac7254a91fd9b841b1414ebc", + "current_head": "15eac811648182bdac7254a91fd9b841b1414ebc", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/batched-spaced-lifting" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3109", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3110, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "f01a1bb3910cf27fd9ebacecaf90f503ca75e535", + "isDraft": false, + "number": 3110, + "title": "Rank-shape fully charged block-climb gate screen: exact zero-charge thresholds - no new kappa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3110" + }, + "reviewed_head": "f01a1bb3910cf27fd9ebacecaf90f503ca75e535", + "current_head": "f01a1bb3910cf27fd9ebacecaf90f503ca75e535", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank-shape-coframe-bill-seed850bc3" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3110", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3111, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "fcba8eab38c51f4cdb685559be505222d44f8ddc", + "isDraft": false, + "number": 3111, + "title": "Selected bit profile alone exceeds the κ=0.1 moment budget", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3111" + }, + "reviewed_head": "fcba8eab38c51f4cdb685559be505222d44f8ddc", + "current_head": "fcba8eab38c51f4cdb685559be505222d44f8ddc", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/fcba8eab38c51f4cdb685559be505222d44f8ddc" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Complete original version retained in Git ancestry; existing main-tree package unchanged. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3112, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "965072717fb8d168f294ef6998c1badb9ae14e17", + "isDraft": false, + "number": 3112, + "title": "Record the V45 single-lowering margin", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3112" + }, + "reviewed_head": "965072717fb8d168f294ef6998c1badb9ae14e17", + "current_head": "965072717fb8d168f294ef6998c1badb9ae14e17", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-v45-single-lowering" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3113, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "725d9ba226b388737fd02e636f10cd69701e8d58", + "isDraft": false, + "number": 3113, + "title": "Selected stock envelope at m=73: bound quantities and the exact missing shape lemma", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3113" + }, + "reviewed_head": "725d9ba226b388737fd02e636f10cd69701e8d58", + "current_head": "725d9ba226b388737fd02e636f10cd69701e8d58", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/selected-stock-envelope-m73" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3114, + "metadata": { + "author": { + "id": "MDQ6VXNlcjMwNTExNDU2", + "is_bot": false, + "login": "mdumitrean", + "name": "aigent-marius" + }, + "headRefOid": "c88769c350977d9ed4f90fe5c652d582cfe2782a", + "isDraft": false, + "number": 3114, + "title": "research: restore-only optimum for PR #3042's six-skip words (scoped exact negative, no new κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3114" + }, + "reviewed_head": "c88769c350977d9ed4f90fe5c652d582cfe2782a", + "current_head": "c88769c350977d9ed4f90fe5c652d582cfe2782a", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-skip-restore-optimum" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3115, + "metadata": { + "author": { + "id": "U_kgDOFEm3gg", + "is_bot": false, + "login": "dataisfire", + "name": "dataisfire" + }, + "headRefOid": "400bc83669f86917f69b6249cd0356d3a913293c", + "isDraft": false, + "number": 3115, + "title": "research: κ = 0.001729737950064278551242895823 − 10^-52 − 10^-76", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3115" + }, + "reviewed_head": "400bc83669f86917f69b6249cd0356d3a913293c", + "current_head": "400bc83669f86917f69b6249cd0356d3a913293c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/t740-six-skip-precision30" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3116, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "2ebdcfebd6d3da023dc45ddf68729f0771ccb77c", + "isDraft": false, + "number": 3116, + "title": "Research: source-bound weighted diagonal rank-batching screen", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3116" + }, + "reviewed_head": "2ebdcfebd6d3da023dc45ddf68729f0771ccb77c", + "current_head": "2ebdcfebd6d3da023dc45ddf68729f0771ccb77c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/complex-weighted-diagonal-rank51" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3117, + "metadata": { + "author": { + "id": "MDQ6VXNlcjgwMjk5Njgz", + "is_bot": false, + "login": "CubeJerry", + "name": "" + }, + "headRefOid": "e0cc74ffa679b073f99644bd71b915b38abb7136", + "isDraft": false, + "number": 3117, + "title": "Certify R439 disjoint-helper optimum: 17,933 ADDs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3117" + }, + "reviewed_head": "e0cc74ffa679b073f99644bd71b915b38abb7136", + "current_head": "e0cc74ffa679b073f99644bd71b915b38abb7136", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/r439-copyshare-optimal-matching" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3118, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "269e27082ff78677b588daf19e0632ba0502655b", + "isDraft": false, + "number": 3118, + "title": "KB3k: demote the mu2-constant even-half condition; (4,2) walk shard 29 (outcome=partial)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3118" + }, + "reviewed_head": "269e27082ff78677b588daf19e0632ba0502655b", + "current_head": "269e27082ff78677b588daf19e0632ba0502655b", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/f7-mu2-evenhalf-kb3k-88a1" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3119, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "57cdb0e372d0dc1de6bbf705da24727b111e7f40", + "isDraft": false, + "number": 3119, + "title": "Record V45 in the shipped words and cap brackets", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3119" + }, + "reviewed_head": "57cdb0e372d0dc1de6bbf705da24727b111e7f40", + "current_head": "57cdb0e372d0dc1de6bbf705da24727b111e7f40", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-v45-shipped-invoice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3120, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "6e36982ccc888bdb4dc15982322d8fe1aed392b4", + "isDraft": false, + "number": 3120, + "title": "Copied-information floor of the selected centre path", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3120" + }, + "reviewed_head": "6e36982ccc888bdb4dc15982322d8fe1aed392b4", + "current_head": "6e36982ccc888bdb4dc15982322d8fe1aed392b4", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "PR3147 identifies an owner lookup error (local role indices treated as global owner IDs): 16/1152 becomes 1152/1152 with positional indexing. Correct the physical-map evidence and revisit the independent-call sharing premise before intake; isolated per-call rank evidence is not rejected.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3121, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "eea0861aff47df568be4bb4a4db43c2da390d351", + "isDraft": false, + "number": 3121, + "title": "Prove optimal edge-priced dirty-output fanout", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3121" + }, + "reviewed_head": "eea0861aff47df568be4bb4a4db43c2da390d351", + "current_head": "eea0861aff47df568be4bb4a4db43c2da390d351", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/dirty-anchor-edge-tariffs" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3122, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "bd06efe0c53280c585d0f3b2f21c52d036f40902", + "isDraft": false, + "number": 3122, + "title": "Research: reduce batched lifting clean workspace with paid checkpoints", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3122" + }, + "reviewed_head": "bd06efe0c53280c585d0f3b2f21c52d036f40902", + "current_head": "bd06efe0c53280c585d0f3b2f21c52d036f40902", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/lifting-checkpoint-space" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3123, + "metadata": { + "author": { + "id": "U_kgDOCcbgOg", + "is_bot": false, + "login": "1337isnot1337", + "name": "Cinna Davis" + }, + "headRefOid": "195dcb14fb2e2b4de72d8e573ab6cbe120c844ba", + "isDraft": false, + "number": 3123, + "title": "Correct the κ=0.1 complex cost screen and bound scalar-query repairs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3123" + }, + "reviewed_head": "195dcb14fb2e2b4de72d8e573ab6cbe120c844ba", + "current_head": "195dcb14fb2e2b4de72d8e573ab6cbe120c844ba", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/kappa01-bit-repair", + "research/kappa01-fieldline-repair", + "research/kappa01-haemers-repair", + "research/kappa01-outer-repair", + "research/kappa01-plane-audit", + "research/kappa01-repair" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3124, + "metadata": { + "author": { + "id": "U_kgDOCcbgOg", + "is_bot": false, + "login": "1337isnot1337", + "name": "Cinna Davis" + }, + "headRefOid": "ce468c5cf22f59db3071adda269ac4cc16469c8c", + "isDraft": false, + "number": 3124, + "title": "Find a P104 short-cycle matching that survives the helper-91 screen", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3124" + }, + "reviewed_head": "ce468c5cf22f59db3071adda269ac4cc16469c8c", + "current_head": "ce468c5cf22f59db3071adda269ac4cc16469c8c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p104-alternating-cycle-neighborhood" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. PR3182 excludes extensions of these matching candidates at other helpers; the original one-helper result already leaves them relaxed. Retained only within that stated narrow scope.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3125, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "18f7accb8297610e3ef0489c9ca51b18944c650c", + "isDraft": false, + "number": 3125, + "title": "Changed helper inventories screened against the packing ceiling (complex-new-helper-inventory)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3125" + }, + "reviewed_head": "18f7accb8297610e3ef0489c9ca51b18944c650c", + "current_head": "18f7accb8297610e3ef0489c9ca51b18944c650c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/helper-inventory-moment-seede64193c0" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3126, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "831a5d8f34f83c6231d10abca162c128d9d733f4", + "isDraft": false, + "number": 3126, + "title": "Record V45 widths and the inherited call order", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3126" + }, + "reviewed_head": "831a5d8f34f83c6231d10abca162c128d9d733f4", + "current_head": "831a5d8f34f83c6231d10abca162c128d9d733f4", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-v45-idle-chronology" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3127, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "2d685e0dbdcc8c9a370bc77c2f36ccaa7636e37d", + "isDraft": false, + "number": 3127, + "title": "Implement encoded one-pass Gaussian normalization", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3127" + }, + "reviewed_head": "2d685e0dbdcc8c9a370bc77c2f36ccaa7636e37d", + "current_head": "2d685e0dbdcc8c9a370bc77c2f36ccaa7636e37d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/gaussian-normalization-stream" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3128, + "metadata": { + "author": { + "id": "U_kgDOB5L2iw", + "is_bot": false, + "login": "theon199", + "name": "Sricharan Vagvala" + }, + "headRefOid": "2bf13e5b55f8318ae74a8f17db36a19447ba8c7f", + "isDraft": false, + "number": 3128, + "title": "Audit retained-helper independence in scatter parity", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3128" + }, + "reviewed_head": "2bf13e5b55f8318ae74a8f17db36a19447ba8c7f", + "current_head": "2bf13e5b55f8318ae74a8f17db36a19447ba8c7f", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/retained-alias-parity-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3129, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "3276dd7022332e199c4f973df09f85063eb99e94", + "isDraft": false, + "number": 3129, + "title": "Research: near-input clean workspace for batched lifting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3129" + }, + "reviewed_head": "3276dd7022332e199c4f973df09f85063eb99e94", + "current_head": "3276dd7022332e199c4f973df09f85063eb99e94", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/lifting-relative-history" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3130, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "d34c1142f914c477708d1bb03db11691b0341070", + "isDraft": false, + "number": 3130, + "title": "Tooling: synthesize optimal dirty fanout with direct cut certificates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3130" + }, + "reviewed_head": "d34c1142f914c477708d1bb03db11691b0341070", + "current_head": "d34c1142f914c477708d1bb03db11691b0341070", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/dirty-fanout-cut-certificate" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3131, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "0c9e344d5a5295a218558fa4a51d867f39ff5311", + "isDraft": false, + "number": 3131, + "title": "Construct fast dense execution of the original paired collector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3131" + }, + "reviewed_head": "0c9e344d5a5295a218558fa4a51d867f39ff5311", + "current_head": "0c9e344d5a5295a218558fa4a51d867f39ff5311", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/dense-paired-collector" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3132, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "d63c41cfdc8b1e4046b2e92bbabd688d702f4fa9", + "isDraft": false, + "number": 3132, + "title": "Research: native warp relations add no paired-extraction directions", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3132" + }, + "reviewed_head": "d63c41cfdc8b1e4046b2e92bbabd688d702f4fa9", + "current_head": "d63c41cfdc8b1e4046b2e92bbabd688d702f4fa9", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/native-warp-extraction-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3133, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "51eb9c4ee9e4722010d308aa3309e039d3940cc2", + "isDraft": false, + "number": 3133, + "title": "research(rank7-coupled-586-588-carrier-fold): lower helpers 586 & 588 via coupled B+restore carrier folds (κ = 0.0017297760894)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3133" + }, + "reviewed_head": "51eb9c4ee9e4722010d308aa3309e039d3940cc2", + "current_head": "51eb9c4ee9e4722010d308aa3309e039d3940cc2", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-coupled-586-588-carrier-fold" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3134, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "d8c0e3e88e501da6c19f858b7debf0c2e3e0be69", + "isDraft": false, + "number": 3134, + "title": "Construction: cut paired-collector wrapper lifting calls from 416 to 104", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3134" + }, + "reviewed_head": "d8c0e3e88e501da6c19f858b7debf0c2e3e0be69", + "current_head": "d8c0e3e88e501da6c19f858b7debf0c2e3e0be69", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/guarded-wrapper-refinement" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3135, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "776ae75d640e6a5672e8ea798677a2cd3ae2d53c", + "isDraft": false, + "number": 3135, + "title": "research: release T740 precision35 kappa refinement", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3135" + }, + "reviewed_head": "776ae75d640e6a5672e8ea798677a2cd3ae2d53c", + "current_head": "776ae75d640e6a5672e8ea798677a2cd3ae2d53c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/t740-six-skip-precision35" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3136, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "3e73133a7b6a73d9433a2e33dc3404d8d049f20d", + "isDraft": false, + "number": 3136, + "title": "Independently audit the coupled helper 586/588 carrier folds", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3136" + }, + "reviewed_head": "3e73133a7b6a73d9433a2e33dc3404d8d049f20d", + "current_head": "3e73133a7b6a73d9433a2e33dc3404d8d049f20d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/coupled-carrier-independent-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3137, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "2e69ca272de81e92e91aabac3b4652382b5794f6", + "isDraft": false, + "number": 3137, + "title": "Research: compile Q8 dirty couplings with a sparse array invoice", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3137" + }, + "reviewed_head": "2e69ca272de81e92e91aabac3b4652382b5794f6", + "current_head": "2e69ca272de81e92e91aabac3b4652382b5794f6", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/q8-affine-dirty-compiler" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3138, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "2a4a17457e21de2de684bd8ad19938e9aef2319f", + "isDraft": false, + "number": 3138, + "title": "Tooling: export committed research packages with offline integrity checks", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3138" + }, + "reviewed_head": "2a4a17457e21de2de684bd8ad19938e9aef2319f", + "current_head": "2a4a17457e21de2de684bd8ad19938e9aef2319f", + "disposition": "incorporated", + "github_state": "OPEN", + "integration_location": [ + "docs/research/package-export.md", + "docs/research/research-package-guide.md", + "scripts/export_research_package.py", + "tests/test_research_export.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3139, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "54bbb81cc884819154776900830eeb4d9db4dc5e", + "isDraft": false, + "number": 3139, + "title": "Tooling: bound hung isolated test modules without dropping coverage", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3139" + }, + "reviewed_head": "54bbb81cc884819154776900830eeb4d9db4dc5e", + "current_head": "54bbb81cc884819154776900830eeb4d9db4dc5e", + "disposition": "incorporated", + "github_state": "OPEN", + "integration_location": [ + "docs/ci-verification.md", + "scripts/run_isolated_tests.py", + "tests/test_isolated_test_deadlines.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3140, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "495f4b924596a4c78eaae32ae91872940ca0d9d8", + "isDraft": false, + "number": 3140, + "title": "Tooling: explain every registered replay selection", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3140" + }, + "reviewed_head": "495f4b924596a4c78eaae32ae91872940ca0d9d8", + "current_head": "495f4b924596a4c78eaae32ae91872940ca0d9d8", + "disposition": "incorporated", + "github_state": "OPEN", + "integration_location": [ + "docs/research/research-package-guide.md", + "scripts/research_package.py", + "tests/test_research_plan_explanations.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3141, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "6c8d1615f94c3615b2d23a424d3bf72ebe6009e4", + "isDraft": false, + "number": 3141, + "title": "Tooling: reject changed-base mixtures in PR file overlap snapshots", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3141" + }, + "reviewed_head": "6c8d1615f94c3615b2d23a424d3bf72ebe6009e4", + "current_head": "6c8d1615f94c3615b2d23a424d3bf72ebe6009e4", + "disposition": "incorporated", + "github_state": "OPEN", + "integration_location": [ + "docs/research/coordination.md", + "scripts/find_overlap.py", + "tests/test_research_onboarding.py", + "tests/test_research_pr_base_binding.py", + "tests/test_research_pr_file_pages.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3142, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "c28ab1decefe9be591cb30894d6bf15216ec2979", + "isDraft": false, + "number": 3142, + "title": "Tooling: preserve complete replay selection in sparse checkouts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3142" + }, + "reviewed_head": "c28ab1decefe9be591cb30894d6bf15216ec2979", + "current_head": "c28ab1decefe9be591cb30894d6bf15216ec2979", + "disposition": "incorporated", + "github_state": "OPEN", + "integration_location": [ + "docs/research/research-package-guide.md", + "scripts/research_package.py", + "tests/test_research_matrix_batches.py", + "tests/test_research_sparse_planning.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3143, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "dcfaf1d1a7cfebaab22b95776a36a543bc684d50", + "isDraft": false, + "number": 3143, + "title": "research(rank7): certify precision-40 κ above PR3133", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3143" + }, + "reviewed_head": "dcfaf1d1a7cfebaab22b95776a36a543bc684d50", + "current_head": "dcfaf1d1a7cfebaab22b95776a36a543bc684d50", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source integrity: missing manifest file research/rank7-coupled-586-588-carrier-fold-precision40/evidence/logs/release-verify/audit-local-566-base.log; missing manifest file research/rank7-coupled-586-588-carrier-fold-precision40/evidence/logs/release-verify/audit-local-566-extra.log; missing manifest file research/rank7-coupled-586-588-carrier-fold-precision40/evidence/logs/release-verify/declared-edit-review.log. Restore the manifest-listed files or explicitly correct the manifest scope without silently dropping claimed evidence.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3146, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE1MzM0MQ==", + "is_bot": false, + "login": "kumagi", + "name": "Hiroki KUMAZAKI" + }, + "headRefOid": "e9271f2c916ae07078d46aaea851834ce7906747", + "isDraft": false, + "number": 3146, + "title": "Audit PR3044 cold release with independent local and invoice checks", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3146" + }, + "reviewed_head": "e9271f2c916ae07078d46aaea851834ce7906747", + "current_head": "e9271f2c916ae07078d46aaea851834ce7906747", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/pr3044-independent-cold-replay" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3147, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "5cbc48b18cb05327a8dacab3f626412d3bc5e924", + "isDraft": false, + "number": 3147, + "title": "research: centre sink duality, dependent-triple braid sparsity (|B| <= 12), and circle-cancellation sharing ceilings", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3147" + }, + "reviewed_head": "5cbc48b18cb05327a8dacab3f626412d3bc5e924", + "current_head": "5cbc48b18cb05327a8dacab3f626412d3bc5e924", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "PR3151 supplies a target-only nonzero F2 witness and 48 later hosted bridges, contradicting the unchanged-endpoint circle elision/zero-feedback interpretation. Revise the schedule claim and distinguish relaxed pricing from a valid unchanged-endpoint construction. Other scoped results remain eligible after correction.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3148, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMDk2NjQ=", + "is_bot": false, + "login": "jeremydiviney", + "name": "" + }, + "headRefOid": "f2927a4b8afcf0701a6b945e14f30de1d94f5176", + "isDraft": false, + "number": 3148, + "title": "Realize the coupled-carrier T740 packing cap: κ ≈ 0.001729777494678597", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3148" + }, + "reviewed_head": "f2927a4b8afcf0701a6b945e14f30de1d94f5176", + "current_head": "f2927a4b8afcf0701a6b945e14f30de1d94f5176", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/coupled-carrier-cap740" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3150, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "e5c265f1be9cd0593f49628ec6552e52bd90af61", + "isDraft": false, + "number": 3150, + "title": "Research: execute the A13 native climb with 209,920 fewer CNOTs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3150" + }, + "reviewed_head": "e5c265f1be9cd0593f49628ec6552e52bd90af61", + "current_head": "e5c265f1be9cd0593f49628ec6552e52bd90af61", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-reversible-native-climb" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3151, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "ff21ddd5f801eccabb14fa88b76724a8d55c1e26", + "isDraft": false, + "number": 3151, + "title": "test(research): audit centre-circle demands and late responses", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3151" + }, + "reviewed_head": "ff21ddd5f801eccabb14fa88b76724a8d55c1e26", + "current_head": "ff21ddd5f801eccabb14fa88b76724a8d55c1e26", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/centre-circle-endpoint-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3152, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "66ee36401536625714c9937e36bbe7ef115da05f", + "isDraft": false, + "number": 3152, + "title": "Research: complete the scalar layer with one clean carry", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3152" + }, + "reviewed_head": "66ee36401536625714c9937e36bbe7ef115da05f", + "current_head": "66ee36401536625714c9937e36bbe7ef115da05f", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-one-carry-scalars" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3153, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "c509607d1208396ec0045f0ab79f8392fce40b01", + "isDraft": false, + "number": 3153, + "title": "test(research): independently audit the coupled-carrier packing cap", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3153" + }, + "reviewed_head": "c509607d1208396ec0045f0ab79f8392fce40b01", + "current_head": "c509607d1208396ec0045f0ab79f8392fce40b01", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/coupled-cap-independent" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3154, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "708f0ad8928c383de8294aea3c126e9461d2066d", + "isDraft": false, + "number": 3154, + "title": "C(P112) >= 64: complete reduction to stated conjectures", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3154" + }, + "reviewed_head": "708f0ad8928c383de8294aea3c126e9461d2066d", + "current_head": "708f0ad8928c383de8294aea3c126e9461d2066d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source integrity: missing manifest file research/p112-reduction-to-conjectures/checks/FINITE2/one_150.out; missing manifest file research/p112-reduction-to-conjectures/checks/FINITE2/one_151.out; missing manifest file research/p112-reduction-to-conjectures/checks/FINITE2/one_152.out. Restore the manifest-listed files or explicitly correct the manifest scope without silently dropping claimed evidence.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3157, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNjU5ODM5", + "is_bot": false, + "login": "rohanarun", + "name": "" + }, + "headRefOid": "313ede7cfd0002b3884e235730a564e8ec7c2e05", + "isDraft": false, + "number": 3157, + "title": "Conditional κ ≈ 0.0017291527560043: R1 words at their packing cap (T740), +1.55e-9 over #3021", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3157" + }, + "reviewed_head": "313ede7cfd0002b3884e235730a564e8ec7c2e05", + "current_head": "313ede7cfd0002b3884e235730a564e8ec7c2e05", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-r1-t740-cap" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3158, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "8e2167bac550bd653bb74c50c1f7c3f14b6c1f70", + "isDraft": false, + "number": 3158, + "title": "test(research): certify the P112 deletion quantifier separation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3158" + }, + "reviewed_head": "8e2167bac550bd653bb74c50c1f7c3f14b6c1f70", + "current_head": "8e2167bac550bd653bb74c50c1f7c3f14b6c1f70", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-four-deletion-counterexample" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3159, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "f107d7331233c66c49579fdaa80c619e015cf245", + "isDraft": false, + "number": 3159, + "title": "Research: remove the separate SCALE bank and save 700,392 gates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3159" + }, + "reviewed_head": "f107d7331233c66c49579fdaa80c619e015cf245", + "current_head": "f107d7331233c66c49579fdaa80c619e015cf245", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-paired-scale" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3160, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9ab8c4cc2aed4a87293d7d04b2abfdf854ae43e2", + "isDraft": false, + "number": 3160, + "title": "test(research): certify the P112 common-deletion span", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3160" + }, + "reviewed_head": "9ab8c4cc2aed4a87293d7d04b2abfdf854ae43e2", + "current_head": "9ab8c4cc2aed4a87293d7d04b2abfdf854ae43e2", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-common-deletion-span" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3161, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "a1aba8389b87412e6f72ccf4d11f31e0ea232327", + "isDraft": false, + "number": 3161, + "title": "Research: close the P112 (5,3) beta residue", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3161" + }, + "reviewed_head": "a1aba8389b87412e6f72ccf4d11f31e0ea232327", + "current_head": "a1aba8389b87412e6f72ccf4d11f31e0ea232327", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-mixed-rank-reduction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Schedule any complete replay separately. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and explicit 10/15/20-minute limits. No dispatch. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3162, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "ebd7fd275288e4a9f658e77fa77a0119a8322e74", + "isDraft": false, + "number": 3162, + "title": "Research: prove a ten-deletion P112 span bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3162" + }, + "reviewed_head": "ebd7fd275288e4a9f658e77fa77a0119a8322e74", + "current_head": "ebd7fd275288e4a9f658e77fa77a0119a8322e74", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-ten-deletion-span" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Schedule any complete replay separately. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and explicit 10/15/20-minute limits. No dispatch. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3163, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "89419106cd86896c366e853795978f1bc85f9112", + "isDraft": false, + "number": 3163, + "title": "test(research): certify a complete P112 common-deletion slice", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3163" + }, + "reviewed_head": "89419106cd86896c366e853795978f1bc85f9112", + "current_head": "89419106cd86896c366e853795978f1bc85f9112", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-common-deletion-slice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Schedule any complete replay separately. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and explicit 10/15/20-minute limits. No dispatch. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3164, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "857384079ab640a949fb7618b7909664d3e737e5", + "isDraft": false, + "number": 3164, + "title": "Research: exclude the final two P112 (5,4) beta shapes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3164" + }, + "reviewed_head": "857384079ab640a949fb7618b7909664d3e737e5", + "current_head": "857384079ab640a949fb7618b7909664d3e737e5", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-root-simplex-exclusion" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3165, + "metadata": { + "author": { + "id": "U_kgDOE8HONA", + "is_bot": false, + "login": "josecarlosgonzalezroque-design", + "name": "" + }, + "headRefOid": "9bdba17f90e7c2a3092186f55f06d019c2823546", + "isDraft": false, + "number": 3165, + "title": "Audit ten PR3114 departure obstructions with independent minors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3165" + }, + "reviewed_head": "9bdba17f90e7c2a3092186f55f06d019c2823546", + "current_head": "9bdba17f90e7c2a3092186f55f06d019c2823546", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-departure-minor-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3166, + "metadata": { + "author": { + "id": "MDQ6VXNlcjg2NDE2NTcy", + "is_bot": false, + "login": "conorholds", + "name": "conorholds" + }, + "headRefOid": "7c2a62363ad4945e8803fedea6ead78e1ad412b2", + "isDraft": false, + "number": 3166, + "title": "Prove the E8 d=0 kernel floor and scoped rigid C1 bounds", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3166" + }, + "reviewed_head": "7c2a62363ad4945e8803fedea6ead78e1ad412b2", + "current_head": "7c2a62363ad4945e8803fedea6ead78e1ad412b2", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/e8-d0-root-swaps" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3167, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "c2c7508f2d731feea550f1628601aebd35c6e147", + "isDraft": false, + "number": 3167, + "title": "Research: prove a sharp P112 mixed-rank anchor bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3167" + }, + "reviewed_head": "c2c7508f2d731feea550f1628601aebd35c6e147", + "current_head": "c2c7508f2d731feea550f1628601aebd35c6e147", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-mixed-rank-anchor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3168, + "metadata": { + "author": { + "id": "MDQ6VXNlcjg0ODUxNjc4", + "is_bot": false, + "login": "Sudarsh3301", + "name": "Sudarsh Chaturvedi" + }, + "headRefOid": "b8844f08d8832eb87f8a5725f50d9c5eaac953d8", + "isDraft": false, + "number": 3168, + "title": "Independently check the seven-owner centre-repair Fano exclusion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3168" + }, + "reviewed_head": "b8844f08d8832eb87f8a5725f50d9c5eaac953d8", + "current_head": "b8844f08d8832eb87f8a5725f50d9c5eaac953d8", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/centre-seven-owner-fano-independent" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3169, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "2dbbd3004b70772cef200e341037c7c05b094fbc", + "isDraft": false, + "number": 3169, + "title": "Research: exclude five P112 beta shapes with a coordinate budget", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3169" + }, + "reviewed_head": "2dbbd3004b70772cef200e341037c7c05b094fbc", + "current_head": "2dbbd3004b70772cef200e341037c7c05b094fbc", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-ten-piece-simplex" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3170, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "182168c4a7af570902b231aa6d35bbf4139098f2", + "isDraft": false, + "number": 3170, + "title": "Research: exclude three larger-simplex P112 beta shapes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3170" + }, + "reviewed_head": "182168c4a7af570902b231aa6d35bbf4139098f2", + "current_head": "182168c4a7af570902b231aa6d35bbf4139098f2", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-larger-root-simplices" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3171, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "95b683196950efea6f3d7ac66745e00dba73425e", + "isDraft": false, + "number": 3171, + "title": "Research: exclude P112 4,5^9 with quotient parity", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3171" + }, + "reviewed_head": "95b683196950efea6f3d7ac66745e00dba73425e", + "current_head": "95b683196950efea6f3d7ac66745e00dba73425e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-quotient-parity" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3172, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "0a632b00ef59a9f43b1f6c7965ff1ca7a3f188f3", + "isDraft": false, + "number": 3172, + "title": "research: all-endpoint nonlinear recovery obstruction for PR2918", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3172" + }, + "reviewed_head": "0a632b00ef59a9f43b1f6c7965ff1ca7a3f188f3", + "current_head": "0a632b00ef59a9f43b1f6c7965ff1ca7a3f188f3", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-terminal-information-barrier" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3173, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "fb731630083bece860c0c46ef3a25542385a83dc", + "isDraft": false, + "number": 3173, + "title": "Research: exclude six P112 profiles with a coordinate-sensitive bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3173" + }, + "reviewed_head": "fb731630083bece860c0c46ef3a25542385a83dc", + "current_head": "fb731630083bece860c0c46ef3a25542385a83dc", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-simplex-coordinate-bound" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3174, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "e38c9cff85f2af817b403291285468ca3899f9c7", + "isDraft": false, + "number": 3174, + "title": "Research: exclude three eleven-piece P112 beta profiles", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3174" + }, + "reviewed_head": "e38c9cff85f2af817b403291285468ca3899f9c7", + "current_head": "e38c9cff85f2af817b403291285468ca3899f9c7", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-eleven-piece-quotient" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3175, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "2393963d835a60b8524e986b969c8a87b26a07e3", + "isDraft": false, + "number": 3175, + "title": "Research: exclude four P112 profiles with simplex support budgets", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3175" + }, + "reviewed_head": "2393963d835a60b8524e986b969c8a87b26a07e3", + "current_head": "2393963d835a60b8524e986b969c8a87b26a07e3", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-simplex-support-budget" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3176, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1111a074414c4d2be8b4e230133d873432780814", + "isDraft": false, + "number": 3176, + "title": "Research: exclude the P112 support-72 mixed-edge profile", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3176" + }, + "reviewed_head": "1111a074414c4d2be8b4e230133d873432780814", + "current_head": "1111a074414c4d2be8b4e230133d873432780814", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-mixed-edge-simplex" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3177, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "47558b8d6e296b15496edd19dbf3fb0f5f9f6ed5", + "isDraft": false, + "number": 3177, + "title": "Research: exclude P112 2,4,5^9 by D7 support saturation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3177" + }, + "reviewed_head": "47558b8d6e296b15496edd19dbf3fb0f5f9f6ed5", + "current_head": "47558b8d6e296b15496edd19dbf3fb0f5f9f6ed5", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-d7-saturation" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3179, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "27c4c1d4a9f752fe732e0a82bcadac89f770056a", + "isDraft": false, + "number": 3179, + "title": "Research: exclude the P112 eight-vertex support-union profile", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3179" + }, + "reviewed_head": "27c4c1d4a9f752fe732e0a82bcadac89f770056a", + "current_head": "27c4c1d4a9f752fe732e0a82bcadac89f770056a", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-eight-vertex-union" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3180, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "595a78f7925c8802f764792098806ebfbff1f27a", + "isDraft": false, + "number": 3180, + "title": "Research: exclude P112 4,5^2,6^8 by weighted flat pairs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3180" + }, + "reviewed_head": "595a78f7925c8802f764792098806ebfbff1f27a", + "current_head": "595a78f7925c8802f764792098806ebfbff1f27a", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-weighted-flat-pair" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3181, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "80fc72d14546088e9fce3c06dc12bc67270da0af", + "isDraft": false, + "number": 3181, + "title": "research: QQ16 52-bit interior dynamic-range collapse, backward adjoint ledger, and dyadic grid exactness", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3181" + }, + "reviewed_head": "80fc72d14546088e9fce3c06dc12bc67270da0af", + "current_head": "80fc72d14546088e9fce3c06dc12bc67270da0af", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "PR3189 identifies missing child-error columns in the grid-exactness argument: projected backward guard is 18, not 17. Revise the approximate-child lattice hypothesis and resulting precision claim; ideal-input arithmetic alone does not establish exact subsequent half-ADDs.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3182, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "ad848966cd62e13de5ad8d4b5169c221d74d2fcd", + "isDraft": false, + "number": 3182, + "title": "research: P104 pooled 2,309-edge 1-hop obstruction, PR3124 cycle refutation, and 9-stage consumer bill", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3182" + }, + "reviewed_head": "ad848966cd62e13de5ad8d4b5169c221d74d2fcd", + "current_head": "ad848966cd62e13de5ad8d4b5169c221d74d2fcd", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p104-pooled-onehop-and-physical-consumer-bill" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3183, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "2a20f0a508c833825a67188c5233ce222c079a19", + "isDraft": false, + "number": 3183, + "title": "research: R439 sub-10k six-way composition (9,974 ADDs), whole-A star duals, and UT4/dyadic floors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3183" + }, + "reviewed_head": "2a20f0a508c833825a67188c5233ce222c079a19", + "current_head": "2a20f0a508c833825a67188c5233ce222c079a19", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/r439-sub10k-sixway-and-star-dual-witnesses" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3184, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNjU5ODM5", + "is_bot": false, + "login": "rohanarun", + "name": "" + }, + "headRefOid": "ffab383a5f78eb1a4ad4c7c7259a4f32b86f9481", + "isDraft": false, + "number": 3184, + "title": "Conditional κ = 0.001730189061233850760095: idle rank-48 star exchanges on #3148's T740 fill (+4.12e-7)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3184" + }, + "reviewed_head": "ffab383a5f78eb1a4ad4c7c7259a4f32b86f9481", + "current_head": "ffab383a5f78eb1a4ad4c7c7259a4f32b86f9481", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "PR3187 supplies an exact physical-stream operator counterexample to the first committed idle-star move. Commutation and preserved axis multisets do not establish the needed intertwining identity. Repair the operator proof/candidate and replay the complete overlay-aware construction before claiming this kappa.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3185, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "f4fa017730cb3d9978c31b3fe57a751fc15b505a", + "isDraft": false, + "number": 3185, + "title": "Research: prove the sharp fifteen-line P112 two-six-flat cover floor", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3185" + }, + "reviewed_head": "f4fa017730cb3d9978c31b3fe57a751fc15b505a", + "current_head": "f4fa017730cb3d9978c31b3fe57a751fc15b505a", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-two-six-flat-cover" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3186, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "92675b36a8e0ea41b40f0bcda2a3dd9f313abb0e", + "isDraft": false, + "number": 3186, + "title": "Research: exclude P112 3,4,6^8 with a weighted A6 cover", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3186" + }, + "reviewed_head": "92675b36a8e0ea41b40f0bcda2a3dd9f313abb0e", + "current_head": "92675b36a8e0ea41b40f0bcda2a3dd9f313abb0e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a6-weighted-cover" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3187, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "85cc6be02f5f912ac203449e06523ad53e6054d2", + "isDraft": false, + "number": 3187, + "title": "Research: certify the current idle-star physical counterexample", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3187" + }, + "reviewed_head": "85cc6be02f5f912ac203449e06523ad53e6054d2", + "current_head": "85cc6be02f5f912ac203449e06523ad53e6054d2", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-idle-star-stream-obstruction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3188, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "93f1fb95a2ab1413b2e9c90a6be4f3a2c4090034", + "isDraft": false, + "number": 3188, + "title": "Research: exclude P112 2,3,4^4,6^5 with a six-vertex budget", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3188" + }, + "reviewed_head": "93f1fb95a2ab1413b2e9c90a6be4f3a2c4090034", + "current_head": "93f1fb95a2ab1413b2e9c90a6be4f3a2c4090034", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-six-vertex-budget" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3189, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "70537595e46444c8a63455523d9851a5efe55385", + "isDraft": false, + "number": 3189, + "title": "Audit QQ16 child-error grid closure and certify sharp projected guards", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3189" + }, + "reviewed_head": "70537595e46444c8a63455523d9851a5efe55385", + "current_head": "70537595e46444c8a63455523d9851a5efe55385", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/qq16-noise-lattice-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3190, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNjU5ODM5", + "is_bot": false, + "login": "rohanarun", + "name": "" + }, + "headRefOid": "5e4a3235169edddd033889da4e9f47635ff50c3e", + "isDraft": false, + "number": 3190, + "title": "Conditional κ = 0.001733427039589844234749 (bit-bound): idle-remainder donors on #3148's T740 fill (+3.24e-6 over #3184)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3190" + }, + "reviewed_head": "5e4a3235169edddd033889da4e9f47635ff50c3e", + "current_head": "5e4a3235169edddd033889da4e9f47635ff50c3e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Inherits the idle-transfer soundness gap identified for PR3184 by PR3187, and adds hosted-remainder donors without a controller argument. Establish the physical intertwining identity for the actual new moves, hosted correctness, bit-binding outer branch and complete replay; histogram/root arithmetic is insufficient.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3192, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "79864770165fe0d7b72c864be4d5a6e2af5e35b5", + "isDraft": false, + "number": 3192, + "title": "Research: exclude P112 5,6^8 with an affine cover transfer", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3192" + }, + "reviewed_head": "79864770165fe0d7b72c864be4d5a6e2af5e35b5", + "current_head": "79864770165fe0d7b72c864be4d5a6e2af5e35b5", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a6-five-flat" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3193, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "a8eec63ecb495b2969d4962b4d4d1a35706b8cb2", + "isDraft": false, + "number": 3193, + "title": "Research: exclude P112 2,3,4,6^8 with a common-cut span bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3193" + }, + "reviewed_head": "a8eec63ecb495b2969d4962b4d4d1a35706b8cb2", + "current_head": "a8eec63ecb495b2969d4962b4d4d1a35706b8cb2", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-common-fourteen-cut" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3194, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "080309ba9e29449ea4f29971e0ce1d9278703350", + "isDraft": false, + "number": 3194, + "title": "Prove native F2 innovation beyond the earlier centre history", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3194" + }, + "reviewed_head": "080309ba9e29449ea4f29971e0ce1d9278703350", + "current_head": "080309ba9e29449ea4f29971e0ce1d9278703350", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/centre-history-innovation" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3195, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "22f1479db213b1ed0de68cbc61ba15f6352d3276", + "isDraft": false, + "number": 3195, + "title": "Research: exclude P112 5,5,6^6,7 by deleting one piece", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3195" + }, + "reviewed_head": "22f1479db213b1ed0de68cbc61ba15f6352d3276", + "current_head": "22f1479db213b1ed0de68cbc61ba15f6352d3276", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-five-five-slice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3196, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "ac3c90fb09a15c509c5d693f6bc24ec03574afc6", + "isDraft": false, + "number": 3196, + "title": "Audit paired idle-axis transfers across T740 ports", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3196" + }, + "reviewed_head": "ac3c90fb09a15c509c5d693f6bc24ec03574afc6", + "current_head": "ac3c90fb09a15c509c5d693f6bc24ec03574afc6", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/idle-star-paired-axis-census" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + } + ] +} diff --git a/scripts/historical-ci-inputs/intake-starting-heads/24db9bfffd4a7c812545ea6ae58853cb9ef094b2.json b/scripts/historical-ci-inputs/intake-starting-heads/24db9bfffd4a7c812545ea6ae58853cb9ef094b2.json new file mode 100644 index 0000000000..021141eaa9 --- /dev/null +++ b/scripts/historical-ci-inputs/intake-starting-heads/24db9bfffd4a7c812545ea6ae58853cb9ef094b2.json @@ -0,0 +1,12350 @@ +{ + "schema_version": 1, + "scope": "Incremental exact-head decisions. Only changed entries are updated; historical decisions remain in the Git history and central ledger sources.", + "pull_requests": [ + { + "number": 275, + "metadata": { + "number": 275, + "title": "Finite assembly theorem and source-bound PR799 application", + "author": { + "id": "MDQ6VXNlcjE2NDk0NDU=", + "is_bot": false, + "login": "lydakis", + "name": "George Lydakis" + }, + "headRefOid": "524375c61b75dc10cef68a71d504e79e7e7f138c", + "isDraft": false + }, + "reviewed_head": "524375c61b75dc10cef68a71d504e79e7e7f138c", + "current_head": "524375c61b75dc10cef68a71d504e79e7e7f138c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/524375c61b75dc10cef68a71d504e79e7e7f138c" + ], + "unresolved_question": "Two primary finite-assembly packages previously passed, including the pinned PR799 application. Eleven additional research/tooling packages still require scientific review and execution. Historical source retention does not admit the submitted test wrappers, CI configuration or certificate replacement.", + "closure": { + "kind": "merged_for_historical_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/275", + "merge_commit": "fadae6f469e0d5c9c03bbe047a4d383dac254448" + }, + "scope": "Complete historical source retention only: all 734 original changed-file entries and full original commit remain accessible in main ancestry. No proposed scientific files, test wrappers, workflows, certificate or attributes are installed in the default tree. Existing main source stays unchanged. Two primary finite-assembly package reviews previously passed and remain credited; eleven other packages retain independent proof/replay obligations.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/275.json", + "research/community-efficient1900-audit/packets/275.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/275.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/275.json", + "docs/research/pr-intake-evidence/pr275-historical-retention.json" + ] + }, + { + "number": 826, + "metadata": { + "number": 826, + "title": "Independent audit: confirm κ of #699 (0.001660666354374641) and #685 (0.001660339298410333)", + "author": { + "id": "MDQ6VXNlcjk4Mzc5MDc=", + "is_bot": false, + "login": "Rohansguliani", + "name": "Rohan Guliani" + }, + "headRefOid": "ea3ceae40d5fa19dc0361d3f15546df0182459c4", + "isDraft": false + }, + "reviewed_head": "ea3ceae40d5fa19dc0361d3f15546df0182459c4", + "current_head": "ea3ceae40d5fa19dc0361d3f15546df0182459c4", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/pr-record699-685-audit" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/826", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change. Generated contributor/ledger metadata resolved against current authoritative dispositions; original self-attested validation text retained only at original author commit.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 1252, + "metadata": { + "number": 1252, + "title": "Idle pair exchanges improve the #1094 κ candidate", + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "1b9db2faf82b8866b0bb0164501c9a627c7dca9b", + "isDraft": false + }, + "reviewed_head": "1b9db2faf82b8866b0bb0164501c9a627c7dca9b", + "current_head": "1b9db2faf82b8866b0bb0164501c9a627c7dca9b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/frontier1094-idle-exchanges" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1252", + "merge_commit": "47fa55b3cd8c7cf8879206f33569bc59d637dad8" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change. The older README candidate note is retained at its original author commit; current README and selected result are unchanged.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016c.json" + ] + }, + { + "number": 1786, + "metadata": { + "number": 1786, + "title": "Conditional κ = 0.001679754788150048 from fine source-prime padding", + "author": { + "id": "MDQ6VXNlcjQ0MDA1Mjc=", + "is_bot": false, + "login": "chafreaky", + "name": "chafreaky" + }, + "headRefOid": "c52345caa318fc6b1b6e2659c57d746317a72823", + "isDraft": false + }, + "reviewed_head": "c52345caa318fc6b1b6e2659c57d746317a72823", + "current_head": "c52345caa318fc6b1b6e2659c57d746317a72823", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity hold: a changed-file MANIFEST.json does not match the vendored PR1673 CAPPED-LAYOUT-CONTROLS.json. The same inconsistency exists upstream; provenance does not repair the package pin. Resolve the frozen manifest/byte contract before integration; mathematical proof/replay review remains open.", + "closure": null, + "scope": "Exact-head source/configuration revision gate. No new scientific execution or approval. Prior scoped evidence is retained.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/1786.json", + "research/community-efficient1900-audit/packets/1786.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/1786.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/1786.json", + "docs/research/pr-intake-evidence/remaining-holds-20261016d.json", + "docs/research/pr-intake-evidence/archives-20261016d.json" + ] + }, + { + "number": 1897, + "metadata": { + "number": 1897, + "title": "Conditional kappa refinement: 500-digit enclosures and complete native-proof reuse", + "author": { + "id": "U_kgDOBdOLfA", + "is_bot": false, + "login": "M6LI", + "name": "Muhammed Ali Mehmood" + }, + "headRefOid": "fdf717a838bb3d4c78396474131bd1ab5f18165d", + "isDraft": false + }, + "reviewed_head": "fdf717a838bb3d4c78396474131bd1ab5f18165d", + "current_head": "fdf717a838bb3d4c78396474131bd1ab5f18165d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity hold: a changed-file MANIFEST.json does not match the vendored PR1673 CAPPED-LAYOUT-CONTROLS.json. The same inconsistency exists upstream; provenance does not repair the package pin. Resolve the frozen manifest/byte contract before integration; mathematical proof/replay review remains open.", + "closure": null, + "scope": "Exact-head source/configuration revision gate. No new scientific execution or approval. Prior scoped evidence is retained.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/1897.json", + "research/community-efficient1900-audit/packets/1897.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/1897.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/1897.json", + "docs/research/pr-intake-evidence/remaining-holds-20261016d.json", + "docs/research/pr-intake-evidence/archives-20261016d.json" + ] + }, + { + "number": 2361, + "metadata": { + "number": 2361, + "title": "ci: select affected verification inputs and preserve historical replays", + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "b15a55ba1cecf985a584ad5926bc67ebb940b8d3", + "isDraft": false + }, + "reviewed_head": "b15a55ba1cecf985a584ad5926bc67ebb940b8d3", + "current_head": "b15a55ba1cecf985a584ad5926bc67ebb940b8d3", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Revise CI adoption against current manual-only historical sweeps: submitted verify.yml enables push/PR runs and a full scheduled matrix every six hours, including formal work. Preserve the current opt-in/no-automatic-Lean policy. Current historical-adapter reconciliation and native Linux strace coverage remain required.", + "closure": null, + "scope": "Exact-head source/configuration revision gate. No new scientific execution or approval. Prior scoped evidence is retained.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/2361.json", + "research/community-efficient1900-audit/packets/2361.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/2361.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/2361.json", + "docs/research/pr-intake-evidence/remaining-holds-20261016d.json" + ] + }, + { + "number": 2452, + "metadata": { + "number": 2452, + "title": "Test native Windows replay descendant cleanup", + "author": { + "id": "U_kgDOCTONGQ", + "is_bot": false, + "login": "ywz65", + "name": "" + }, + "headRefOid": "5208ab2780550273b1d8933ff584ce7581fb242d", + "isDraft": false + }, + "reviewed_head": "5208ab2780550273b1d8933ff584ce7581fb242d", + "current_head": "5208ab2780550273b1d8933ff584ce7581fb242d", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/windows-replay-timeout-audit.md", + "tests/test_research_windows_process_tree.py" + ], + "unresolved_question": "", + "closure": { + "kind": "merged_with_scoped_review", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2452", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Native Windows tooling review: exact composed source passed eight current Job Object tests and three frozen historical taskkill observer tests, normal and optimized on Windows/Python 3.12 and 3.14. Non-Windows AST preserved; no mathematical replay.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json", + "docs/research/pr-intake-evidence/windows-native-20261016.log" + ] + }, + { + "number": 2469, + "metadata": { + "number": 2469, + "title": "Fix Windows replay lifetime with gated Job Object ownership", + "author": { + "id": "U_kgDOCTONGQ", + "is_bot": false, + "login": "ywz65", + "name": "" + }, + "headRefOid": "65080e406c9edb0e93daa631f90b3fa4e4461910", + "isDraft": false + }, + "reviewed_head": "65080e406c9edb0e93daa631f90b3fa4e4461910", + "current_head": "65080e406c9edb0e93daa631f90b3fa4e4461910", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/windows-replay-lifetime.md", + "scripts/research_package.py", + "tests/test_research_windows_job.py" + ], + "unresolved_question": "", + "closure": { + "kind": "merged_with_scoped_review", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2469", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Native Windows tooling review: exact composed source passed eight current Job Object tests and three frozen historical taskkill observer tests, normal and optimized on Windows/Python 3.12 and 3.14. Non-Windows AST preserved; no mathematical replay.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json", + "docs/research/pr-intake-evidence/windows-native-20261016.log" + ] + }, + { + "number": 2780, + "metadata": { + "number": 2780, + "title": "Prove paid return of every physical head for the clean six-tape multiplier", + "author": { + "id": "MDQ6VXNlcjQ5MDU0NTMy", + "is_bot": false, + "login": "Dugongue", + "name": "" + }, + "headRefOid": "59f336094958b51b312e54deb85347e1b671172d", + "isDraft": false + }, + "reviewed_head": "59f336094958b51b312e54deb85347e1b671172d", + "current_head": "59f336094958b51b312e54deb85347e1b671172d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "multitape-origin-return/LICENSE", + "multitape-origin-return/MANIFEST.json", + "multitape-origin-return/MODULES.json", + "multitape-origin-return/NOTICE.md", + "multitape-origin-return/PORTING.json", + "multitape-origin-return/README.md", + "multitape-origin-return/REUSE.json", + "multitape-origin-return/SOURCES.json", + "multitape-origin-return/TASK.json", + "multitape-origin-return/VERIFY.json", + "multitape-origin-return/expected", + "multitape-origin-return/lean", + "multitape-origin-return/replay.py", + "multitape-origin-return/verify.py" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2780", + "merge_commit": "47fa55b3cd8c7cf8879206f33569bc59d637dad8" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016c.json" + ] + }, + { + "number": 2832, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "0da81b22178e70dbf59a23dda02371c6201fa4f3", + "isDraft": false, + "number": 2832, + "title": "Decoder floors: universality, projection transfer and batching reductions; C(P112) ≥ 64 reduced to named conjectures, C(P120) ≥ 72 restated on N₀ (no κ claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2832" + }, + "reviewed_head": "0da81b22178e70dbf59a23dda02371c6201fa4f3", + "current_head": "0da81b22178e70dbf59a23dda02371c6201fa4f3", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Theorem TF consequence uses a single fold parameter to cancel all proportional MD terms, but proportionality ratios may differ. The retained P112 decoder has16 MD terms p=(x_i,+/-x_i),q=p/8, exact target diag(G/2,G/2), and total cost128; ratios+1 and-1 require incompatible cancelling parameters. This exposes a gap in the conditional-under-H argument, not a proof or refutation of H. Supply common-ratio/common-annihilator hypotheses or a different proof. Section4.1 also needs justification: m=8k+e does not by itself restrict each call to8+e terms; this example has16 per call with e=0. Re-audit dependent batching consequences and add regression before a full replay. Revised head adds checks and a proof map but says no claim changed; the flagged argument remains. Two manifest-listed logs are also absent.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 2962, + "metadata": { + "number": 2962, + "title": "Ceilings for linear rank-counting decoder certificates (360/17 on P120) and a one-sided lift bound (cost >= 72 for dim S >= 23)", + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "f6e68c9838e21b263223ae61273e381d2c0b92c7", + "isDraft": false + }, + "reviewed_head": "f6e68c9838e21b263223ae61273e381d2c0b92c7", + "current_head": "f6e68c9838e21b263223ae61273e381d2c0b92c7", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/decoder-certificate-ceilings" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2962", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2963, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "ee755e682b3b30d493e764d3be50003b13b69b4a", + "isDraft": false, + "number": 2963, + "title": "F-star family gap: the twelve tied_min v = 11 sub-decoders settled exactly - gap_named = 2 EXISTS below v = 12 (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2963" + }, + "reviewed_head": "ee755e682b3b30d493e764d3be50003b13b69b4a", + "current_head": "ee755e682b3b30d493e764d3be50003b13b69b4a", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "The revised head still ships malformed JSON at research/fstar-gap2-v11-seed42ff0611/predecessor/pr2914/CERTIFICATE.json: Expecting value: line 1 column 1 (char 0). Restore the pinned predecessor certificate or explicitly document and isolate it as inert invalid evidence. This is an integrity hold, not a mathematical rejection.", + "scope": "Changed-head source/integrity triage; no scientific replay.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 2964, + "metadata": { + "number": 2964, + "title": "Decide every odd-order character rank cut before bit-word search", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "466c65e73b3efb5f8144799792fbef0acf4369cf", + "isDraft": false + }, + "reviewed_head": "466c65e73b3efb5f8144799792fbef0acf4369cf", + "current_head": "466c65e73b3efb5f8144799792fbef0acf4369cf", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/bit-odd-character-screen" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2964", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2965, + "metadata": { + "number": 2965, + "title": "Bound completed QQ16 producer errors through the decoder", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "526f2c242202b31b15e09a7502dfb8ff757b2bad", + "isDraft": false + }, + "reviewed_head": "526f2c242202b31b15e09a7502dfb8ff757b2bad", + "current_head": "526f2c242202b31b15e09a7502dfb8ff757b2bad", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-producer-defect-transfer" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2965", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2966, + "metadata": { + "number": 2966, + "title": "Conditional κ = 0.001724034272523452: fourteen declared gate rewrites (five classes) on #2942's words and literal allocation", + "author": { + "id": "U_kgDOEKXqaA", + "is_bot": false, + "login": "jeremykothe2", + "name": "" + }, + "headRefOid": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "isDraft": false + }, + "reviewed_head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "current_head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/e62d3eb9005117d82a9babcfa937ecc53237c490" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_historical_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2966", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original commit retained in main ancestry; differing files NOT installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2968, + "metadata": { + "number": 2968, + "title": "Audit high-scaling physical scratch inventory and tape costs", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "cf4fc903951cd3f034531f7089d0a178f0f67b05", + "isDraft": false + }, + "reviewed_head": "cf4fc903951cd3f034531f7089d0a178f0f67b05", + "current_head": "cf4fc903951cd3f034531f7089d0a178f0f67b05", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/high-scaling-scratch-traffic" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2968", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2969, + "metadata": { + "number": 2969, + "title": "Compose normal-45 extraction and fourteen gate rewrites: candidate κ ≈ 0.0017240352247481", + "author": { + "id": "MDQ6VXNlcjQ5MDU0NTMy", + "is_bot": false, + "login": "Dugongue", + "name": "" + }, + "headRefOid": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "isDraft": false + }, + "reviewed_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "current_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/paired-swap-normal45" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2969", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2970, + "metadata": { + "number": 2970, + "title": "Certify the F-star one-interior-label gap on tied_min", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "bef9060f6b923577ca1d5a78266fd84df00ca93a", + "isDraft": false + }, + "reviewed_head": "bef9060f6b923577ca1d5a78266fd84df00ca93a", + "current_head": "bef9060f6b923577ca1d5a78266fd84df00ca93a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/fstar-one-interior-label" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2970", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2971, + "metadata": { + "number": 2971, + "title": "Complete native and hosted replay of the R438 bit improvement", + "author": { + "id": "MDQ6VXNlcjgwMjk5Njgz", + "is_bot": false, + "login": "CubeJerry", + "name": "" + }, + "headRefOid": "cc009708e5d7ca1e76a3263eb4e9efce57ac7d10", + "isDraft": false + }, + "reviewed_head": "cc009708e5d7ca1e76a3263eb4e9efce57ac7d10", + "current_head": "cc009708e5d7ca1e76a3263eb4e9efce57ac7d10", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/r438-native-rehost" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2971", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2972, + "metadata": { + "number": 2972, + "title": "Audit: stock-margin chain closes for the remaining cutoff pairs (no new kappa)", + "author": { + "id": "MDQ6VXNlcjE1MzM0MQ==", + "is_bot": false, + "login": "kumagi", + "name": "Hiroki KUMAZAKI" + }, + "headRefOid": "d6b883f97d2fd176171553b695005a132156d961", + "isDraft": false + }, + "reviewed_head": "d6b883f97d2fd176171553b695005a132156d961", + "current_head": "d6b883f97d2fd176171553b695005a132156d961", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/stock-margin-chain" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2972", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2973, + "metadata": { + "number": 2973, + "title": "Correct word-census parity budgets; 22 <= f(7) <= 24 in the PR943 model", + "author": { + "id": "MDQ6VXNlcjk0NjMxMDU=", + "is_bot": false, + "login": "NicholasStone", + "name": "Nicholas Stone" + }, + "headRefOid": "d48f3945dbb1ef5d06835744c4082b3bd04181c0", + "isDraft": false + }, + "reviewed_head": "d48f3945dbb1ef5d06835744c4082b3bd04181c0", + "current_head": "d48f3945dbb1ef5d06835744c4082b3bd04181c0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-weight-parity-census-correction" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2973", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2974, + "metadata": { + "number": 2974, + "title": "Independently verify PR2942 owner-to-recursive-cost bridge", + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "9cffaeb321429eb0b3f192aef05ce4ff3dae4b9f", + "isDraft": false + }, + "reviewed_head": "9cffaeb321429eb0b3f192aef05ce4ff3dae4b9f", + "current_head": "9cffaeb321429eb0b3f192aef05ce4ff3dae4b9f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/normal45-owner-cost-bridge" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2974", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2975, + "metadata": { + "number": 2975, + "title": "Accelerate exact four-flat requirement enumeration by 33x on a pinned corpus", + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "1d7b491c9efad451d49dbfd36a3be7443999bf17", + "isDraft": false + }, + "reviewed_head": "1d7b491c9efad451d49dbfd36a3be7443999bf17", + "current_head": "1d7b491c9efad451d49dbfd36a3be7443999bf17", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/two-flat-cover-branching" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2975", + "merge_commit": "47fa55b3cd8c7cf8879206f33569bc59d637dad8" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016c.json" + ] + }, + { + "number": 2977, + "metadata": { + "number": 2977, + "title": "Audit selected scatter parity across word and record checks", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "cd23d242dfe0e7a71cafba0ad5590dc4f2fbf4f2", + "isDraft": false + }, + "reviewed_head": "cd23d242dfe0e7a71cafba0ad5590dc4f2fbf4f2", + "current_head": "cd23d242dfe0e7a71cafba0ad5590dc4f2fbf4f2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/scatter-export-parity-audit" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2977", + "merge_commit": "ff9019ba07a87ce40765c6e75dc4fb82df6a7789" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016d.json" + ] + }, + { + "number": 2978, + "metadata": { + "number": 2978, + "title": "F-star family gap: Lemma BPP's without-loss question answered NO - box-completeness fails at tau >= 1, minimal counterexample v = 3 (no kappa)", + "headRefOid": "12eb7b832de9239a314a7cddf6c6033d618cd8f2", + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "isDraft": false + }, + "reviewed_head": "12eb7b832de9239a314a7cddf6c6033d618cd8f2", + "current_head": "12eb7b832de9239a314a7cddf6c6033d618cd8f2", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Repair malformed vendored predecessor/pr2963/predecessor/pr2914/CERTIFICATE.json; source-only JSON intake fails before scientific review. Retain authentic predecessor bytes and update declared source pins consistently. Mathematical claims remain unreviewed.", + "closure": null, + "scope": "Source syntax/integrity intake: malformed vendored JSON. No scientific execution or endorsement.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/pr2978-source-hold.json" + ] + }, + { + "number": 2979, + "metadata": { + "number": 2979, + "title": "Conditional κ ≈ 0.0017290339826465: joint rank-7 end frames, five paired extractions and #2957's rewrites on #2942's words (+5.00e-6 over #2969)", + "author": { + "id": "MDQ6VXNlcjMwNTExNDU2", + "is_bot": false, + "login": "mdumitrean", + "name": "aigent-marius" + }, + "headRefOid": "be191346391661f4d35fc0d1508d0a6029572576", + "isDraft": false + }, + "reviewed_head": "be191346391661f4d35fc0d1508d0a6029572576", + "current_head": "be191346391661f4d35fc0d1508d0a6029572576", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-endframes" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete native/outer replay remain open. The proposed kappa is an author claim, not the selected result.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2979", + "merge_commit": "30f016dd79ee6a23c40d7dab44a9466c148c42dd" + }, + "scope": "Exact-source archival intake only. No submitted scientific code executed and no selected-bound update.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archive-pr2979.json" + ] + }, + { + "number": 2980, + "metadata": { + "number": 2980, + "title": "Record the odd-prime depth-zero unit root as a weight, not a padded-row reversal", + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "d0aa33af7c20b2ce28ea64d615ff63a164384e4e", + "isDraft": false + }, + "reviewed_head": "d0aa33af7c20b2ce28ea64d615ff63a164384e4e", + "current_head": "d0aa33af7c20b2ce28ea64d615ff63a164384e4e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-odd-prime-unit-root" + ], + "unresolved_question": "Independent scientific review and registered source-bound replay remain open. No new supplier, selected result or theorem validation is implied by archival publication.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2980", + "merge_commit": "86b5e56d4aa0ced955ac7f059eac0c3a5633ca59" + }, + "scope": "Source-only archival intake. No submitted scientific code executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-pr2980-2981.json" + ] + }, + { + "number": 2981, + "metadata": { + "number": 2981, + "title": "Research: certify joint P104 unit-step endpoint flags (no new kappa)", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "isDraft": false + }, + "reviewed_head": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "current_head": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-joint-unit-flags" + ], + "unresolved_question": "Independent scientific review and registered source-bound replay remain open. No new supplier, selected result or theorem validation is implied by archival publication.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2981", + "merge_commit": "86b5e56d4aa0ced955ac7f059eac0c3a5633ca59" + }, + "scope": "Source-only archival intake. No submitted scientific code executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-pr2980-2981.json" + ] + }, + { + "number": 2982, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b9ac0d07eb9cdc31c4dca8dcc218943998edd3e8", + "isDraft": false, + "number": 2982, + "title": "Certify sharp linear wrapper costs for complete high routes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2982" + }, + "reviewed_head": "b9ac0d07eb9cdc31c4dca8dcc218943998edd3e8", + "current_head": "b9ac0d07eb9cdc31c4dca8dcc218943998edd3e8", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/high-route-prefix-cost" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2982", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2984, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "34d7c3feaf87b878d9524c215b678403b8afdc08", + "isDraft": false, + "number": 2984, + "title": "Tooling: 2.25x faster corrected f(7) census with identical traversal", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2984" + }, + "reviewed_head": "34d7c3feaf87b878d9524c215b678403b8afdc08", + "current_head": "34d7c3feaf87b878d9524c215b678403b8afdc08", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-parity-mask-replay" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2984", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2985, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "b07b0e3226bcbe32a90c1b43ab225c339086f7b5", + "isDraft": false, + "number": 2985, + "title": "Research: one-sided residue closures — Circuit Lemma, relative root counting and plane lemma close 480 of the 603 d>=4 residues (116 open; no kappa claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2985" + }, + "reviewed_head": "b07b0e3226bcbe32a90c1b43ab225c339086f7b5", + "current_head": "b07b0e3226bcbe32a90c1b43ab225c339086f7b5", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/one-sided-residue-closures/evidence/logs/nj4.out; missing flat manifest file research/one-sided-residue-closures/provenance/generator/land7.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 2986, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "f610bda7818df522c26b28f5766a06c5ef5c270c", + "isDraft": false, + "number": 2986, + "title": "Fix replay selection through symlinked input paths", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2986" + }, + "reviewed_head": "f610bda7818df522c26b28f5766a06c5ef5c270c", + "current_head": "f610bda7818df522c26b28f5766a06c5ef5c270c", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/replay-input-symlink-alias" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2986", + "merge_commit": "5d2f626f73aa981d67f438e424e7df79f5496586" + } + }, + { + "number": 2987, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "02c3047a1e78e6e35e7573c12434ba26f6f9bd96", + "isDraft": false, + "number": 2987, + "title": "Certify rank-seven chronological packing bound and cost-neutral repair", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2987" + }, + "reviewed_head": "02c3047a1e78e6e35e7573c12434ba26f6f9bd96", + "current_head": "02c3047a1e78e6e35e7573c12434ba26f6f9bd96", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-chronological-face" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2987", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2989, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "133cd8a7c5ce16a3d66e3372c5fdd9e88067d75b", + "isDraft": false, + "number": 2989, + "title": "Independently audit selected compiler ordering and owner guards", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2989" + }, + "reviewed_head": "133cd8a7c5ce16a3d66e3372c5fdd9e88067d75b", + "current_head": "133cd8a7c5ce16a3d66e3372c5fdd9e88067d75b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-compiler-correspondence" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2989", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2990, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9158ee6d097e8058b177c54a1f68a6c30249c8f8", + "isDraft": false, + "number": 2990, + "title": "fix(tests): prevent stale bytecode from hiding failures", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2990" + }, + "reviewed_head": "9158ee6d097e8058b177c54a1f68a6c30249c8f8", + "current_head": "9158ee6d097e8058b177c54a1f68a6c30249c8f8", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/isolated-test-bytecode" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2990", + "merge_commit": "cedad3e65c45c4ca1e00b02a2ae8055e8d2bb57a" + } + }, + { + "number": 2991, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "7d9452f7b99901c78f49fcb1244d5c3a87dbca02", + "isDraft": false, + "number": 2991, + "title": "docs: map P104 precision contracts and remaining implementation obligations", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2991" + }, + "reviewed_head": "7d9452f7b99901c78f49fcb1244d5c3a87dbca02", + "current_head": "7d9452f7b99901c78f49fcb1244d5c3a87dbca02", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/bottleneck-brief.md", + "docs/research/p104-precision-contract-map.md" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2991", + "merge_commit": "4dab22885e1d153e8258ddf96fa5566af27b3ec4" + } + }, + { + "number": 2992, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "b31bf0360ad702b1be71dea7a33edc11711084af", + "isDraft": false, + "number": 2992, + "title": "Enforce simple scatter supports at opt-in checker and exporter boundaries", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2992" + }, + "reviewed_head": "b31bf0360ad702b1be71dea7a33edc11711084af", + "current_head": "b31bf0360ad702b1be71dea7a33edc11711084af", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/simple-scatter-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2992", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2993, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "34a7003866390618b8e8006dc483e7a37a37903f", + "isDraft": false, + "number": 2993, + "title": "Independently audit #2979's joint rank-seven frame paths", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2993" + }, + "reviewed_head": "34a7003866390618b8e8006dc483e7a37a37903f", + "current_head": "34a7003866390618b8e8006dc483e7a37a37903f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-frame-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2993", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2994, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "900ab6c9e1f9cc5dcc1ca93ed7db966e7cf883a5", + "isDraft": false, + "number": 2994, + "title": "Audit case-insensitive replay inputs against Git spelling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2994" + }, + "reviewed_head": "900ab6c9e1f9cc5dcc1ca93ed7db966e7cf883a5", + "current_head": "900ab6c9e1f9cc5dcc1ca93ed7db966e7cf883a5", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/replay-input-case-alias" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2994", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2995, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "8ba0358b62edbeb16a0842473500c468d8c0759b", + "isDraft": false, + "number": 2995, + "title": "Certify an F0 scalar fault witness with exact dirty restoration", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2995" + }, + "reviewed_head": "8ba0358b62edbeb16a0842473500c468d8c0759b", + "current_head": "8ba0358b62edbeb16a0842473500c468d8c0759b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-producer-dirty-fault" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2995", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2996, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4d772802fe86e5185d5468db86b36472e6c81b96", + "isDraft": false, + "number": 2996, + "title": "Certify P104 dependency obstruction for every fixed-pair flag completion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2996" + }, + "reviewed_head": "4d772802fe86e5185d5468db86b36472e6c81b96", + "current_head": "4d772802fe86e5185d5468db86b36472e6c81b96", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-endpoint-completion-flow" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2996", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2997, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "16e790e10cc0bc737b9cd269020d3d967d36430f", + "isDraft": false, + "number": 2997, + "title": "Audit missing information paths in the fixed P104 joint flags", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2997" + }, + "reviewed_head": "16e790e10cc0bc737b9cd269020d3d967d36430f", + "current_head": "16e790e10cc0bc737b9cd269020d3d967d36430f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-flag-information-flow" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2997", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2998, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "3aa400ed59d19b9d6c08e22d1b75edb36a1d3e27", + "isDraft": false, + "number": 2998, + "title": "Research: prove a sharp S4 coordinate-cut gap for mixed targets", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2998" + }, + "reviewed_head": "3aa400ed59d19b9d6c08e22d1b75edb36a1d3e27", + "current_head": "3aa400ed59d19b9d6c08e22d1b75edb36a1d3e27", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/s4-two-premium-cut-envelope" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2998", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2999, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "ac6025235b6f1233291000d35a067198628569e9", + "isDraft": false, + "number": 2999, + "title": "Prove adaptive P104 rounding collisions and retained-history bounds", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2999" + }, + "reviewed_head": "ac6025235b6f1233291000d35a067198628569e9", + "current_head": "ac6025235b6f1233291000d35a067198628569e9", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-adaptive-rounding-collision" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2999", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3000, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "4c0cf223e3e4a06099704b34202a5015f1ab1e62", + "isDraft": false, + "number": 3000, + "title": "Tooling: 9.31x faster exact four-flat maximal-mask filtering", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3000" + }, + "reviewed_head": "4c0cf223e3e4a06099704b34202a5015f1ab1e62", + "current_head": "4c0cf223e3e4a06099704b34202a5015f1ab1e62", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/four-flat-maximal-masks" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3000", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3002, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "0bc34c304441740273e30e06cb28710bdd3d788d", + "isDraft": false, + "number": 3002, + "title": "Fix numeric task references in overlap search", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3002" + }, + "reviewed_head": "0bc34c304441740273e30e06cb28710bdd3d788d", + "current_head": "0bc34c304441740273e30e06cb28710bdd3d788d", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "autoresearch.md", + "docs/research/overlap-task-reference-matching.md", + "scripts/find_overlap.py", + "tests/test_research_overlap_terms.py" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3002", + "merge_commit": "3051cf1605606c32589c2823e0e54f017119d3f5" + } + }, + { + "number": 3003, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "38a0eddf69de8d64840353b5e1ed53bb37b6bc68", + "isDraft": false, + "number": 3003, + "title": "Add exact controls for one-sided residue dominance provenance", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3003" + }, + "reviewed_head": "38a0eddf69de8d64840353b5e1ed53bb37b6bc68", + "current_head": "38a0eddf69de8d64840353b5e1ed53bb37b6bc68", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/one-sided-landscape-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3003", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3004, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE1MzM0MQ==", + "is_bot": false, + "login": "kumagi", + "name": "Hiroki KUMAZAKI" + }, + "headRefOid": "ce08d19f6e43bbc6f552858d93154efe3aa98916", + "isDraft": false, + "number": 3004, + "title": "Audit: exact scatter parity contract at the checker/exporter boundary (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3004" + }, + "reviewed_head": "ce08d19f6e43bbc6f552858d93154efe3aa98916", + "current_head": "ce08d19f6e43bbc6f552858d93154efe3aa98916", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/scatter-parity-contract-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3004", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3005, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "68e67922294d96a42f479f80fdc352eb04a9b550", + "isDraft": false, + "number": 3005, + "title": "Independently corroborate the corrected seven-label word exclusion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3005" + }, + "reviewed_head": "68e67922294d96a42f479f80fdc352eb04a9b550", + "current_head": "68e67922294d96a42f479f80fdc352eb04a9b550", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-union-support-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3005", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3006, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1432a43a331ec857f45093a1d6e16acdbe9849e2", + "isDraft": false, + "number": 3006, + "title": "test(research): audit V45 native residual and private endpoint", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3006" + }, + "reviewed_head": "1432a43a331ec857f45093a1d6e16acdbe9849e2", + "current_head": "1432a43a331ec857f45093a1d6e16acdbe9849e2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-native-endpoint" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3006", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3007, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "3cb500b743f36e13d21b6a46f126846bf36bad32", + "isDraft": false, + "number": 3007, + "title": "fix(research): require exact Git spelling for replay inputs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3007" + }, + "reviewed_head": "3cb500b743f36e13d21b6a46f126846bf36bad32", + "current_head": "3cb500b743f36e13d21b6a46f126846bf36bad32", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/replay-input-head-spelling" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3007", + "merge_commit": "e983379b309c2389608ad7903ae7258a79a36fdd" + } + }, + { + "number": 3008, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "948a997eba1aaf13d04e2b52edf70404860d19dc", + "isDraft": false, + "number": 3008, + "title": "test(research): bind V45 helper and private-buffer events", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3008" + }, + "reviewed_head": "948a997eba1aaf13d04e2b52edf70404860d19dc", + "current_head": "948a997eba1aaf13d04e2b52edf70404860d19dc", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-event-binding" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3008", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3009, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE1MzM0MQ==", + "is_bot": false, + "login": "kumagi", + "name": "Hiroki KUMAZAKI" + }, + "headRefOid": "95568ae83a73ace578e3972a01aef55c889e58a2", + "isDraft": false, + "number": 3009, + "title": "Tooling: 1.27x faster t16 invoice-boundary replay via compresslevel=1 (identical receipt)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3009" + }, + "reviewed_head": "95568ae83a73ace578e3972a01aef55c889e58a2", + "current_head": "95568ae83a73ace578e3972a01aef55c889e58a2", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/t16-invoice-boundary-audit" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3009", + "merge_commit": "6837fa6f28d065dc43b1f7c1fef7c1e8347633ca" + } + }, + { + "number": 3010, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "87ca15cf005ab232ca0104ec5137014ac754f487", + "isDraft": false, + "number": 3010, + "title": "Certify a sharp frozen-fill boundary for rank-seven inverse swaps", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3010" + }, + "reviewed_head": "87ca15cf005ab232ca0104ec5137014ac754f487", + "current_head": "87ca15cf005ab232ca0104ec5137014ac754f487", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-face-boundary-fill" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3010", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3011, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "c5b58be95592a408d0cc42b0b829a3b543fd4b3b", + "isDraft": false, + "number": 3011, + "title": "Show the unit-weight GL2 machine reverses every column at one gap", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3011" + }, + "reviewed_head": "c5b58be95592a408d0cc42b0b829a3b543fd4b3b", + "current_head": "c5b58be95592a408d0cc42b0b829a3b543fd4b3b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-unit-weight-reversal" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3011", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3012, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "63c6525120c20543c4a7acae1a1e1ea36e099b81", + "isDraft": false, + "number": 3012, + "title": "F-star family gap: the box floor FAILS minimally at v = 3 - surviving tau >= 1 form exact (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3012" + }, + "reviewed_head": "63c6525120c20543c4a7acae1a1e1ea36e099b81", + "current_head": "63c6525120c20543c4a7acae1a1e1ea36e099b81", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: research/fstar-boxfloor-minimal-seed758ae8fe/predecessor/pr2978/data/box-search-kj-receipt.json: Expecting value: line 1 column 1 (char 0); research/fstar-boxfloor-minimal-seed758ae8fe/predecessor/pr2978/predecessor/pr2963/predecessor/pr2914/CERTIFICATE.json: Expecting value: line 1 column 1 (char 0). Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3013, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "504dc9a15f7a874a47564cdf3ae6857bbbc8d000", + "isDraft": false, + "number": 3013, + "title": "Certify the P104 matching-pool limit and a 45-missing-pair witness", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3013" + }, + "reviewed_head": "504dc9a15f7a874a47564cdf3ae6857bbbc8d000", + "current_head": "504dc9a15f7a874a47564cdf3ae6857bbbc8d000", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-rematched-dependency-screen" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3013", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3014, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "16e8db5656b4fea487a2212395f39707bf134f7a", + "isDraft": false, + "number": 3014, + "title": "test(research): certify V45's frozen-owner invoice obstruction", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3014" + }, + "reviewed_head": "16e8db5656b4fea487a2212395f39707bf134f7a", + "current_head": "16e8db5656b4fea487a2212395f39707bf134f7a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-frozen-owner-invoice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3014", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3015, + "metadata": { + "author": { + "id": "U_kgDOEKXqaA", + "is_bot": false, + "login": "jeremykothe2", + "name": "" + }, + "headRefOid": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "isDraft": false, + "number": 3015, + "title": "Conditional κ = 0.001729150973534224: one declared restore edit (R1) on PR2979's words and literal allocation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3015" + }, + "reviewed_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "current_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-endframes-restore-edit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3015", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3016, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4471aa49f9f0dd9332b0f1819bead8e331e824db", + "isDraft": false, + "number": 3016, + "title": "fix(replay): make owner verification repeatable", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3016" + }, + "reviewed_head": "4471aa49f9f0dd9332b0f1819bead8e331e824db", + "current_head": "4471aa49f9f0dd9332b0f1819bead8e331e824db", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/half-stage-evacuation", + "research/owner-replay-workspaces", + "research/source-partner-residual-exchanges" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3016", + "merge_commit": "2b43ca4a3a9c704a037718d4023214a7db48ba0a" + } + }, + { + "number": 3017, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "0f493f4c264fbc70ee14364b68af260d858c143c", + "isDraft": false, + "number": 3017, + "title": "Audit: bind the QQ16 dirty-helper fault to native execution", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3017" + }, + "reviewed_head": "0f493f4c264fbc70ee14364b68af260d858c143c", + "current_head": "0f493f4c264fbc70ee14364b68af260d858c143c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-native-dirty-fault" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3017", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3018, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "isDraft": false, + "number": 3018, + "title": "feat(research): lower the rank-seven packing moment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3018" + }, + "reviewed_head": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "current_head": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-integrality-exchange" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3018", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3019, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "44d12bdeb8ade4066645bd968bebd4756b06200a", + "isDraft": false, + "number": 3019, + "title": "Certify a single P104 matching with complete relaxed support", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3019" + }, + "reviewed_head": "44d12bdeb8ade4066645bd968bebd4756b06200a", + "current_head": "44d12bdeb8ade4066645bd968bebd4756b06200a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-coherent-support-witness" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3019", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3020, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "e49abeef32a376f9e8500999ef15594af2587779", + "isDraft": false, + "number": 3020, + "title": "Construct a four-bin relay beyond frozen direct swaps", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3020" + }, + "reviewed_head": "e49abeef32a376f9e8500999ef15594af2587779", + "current_head": "e49abeef32a376f9e8500999ef15594af2587779", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-multibin-face-relay" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3020", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3021, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "217edac2ebfa6250536bd6df153de14901a69395", + "isDraft": false, + "number": 3021, + "title": "feat(research): compose restore and packing gains", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3021" + }, + "reviewed_head": "217edac2ebfa6250536bd6df153de14901a69395", + "current_head": "217edac2ebfa6250536bd6df153de14901a69395", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-packing-composition" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3021", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3022, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "isDraft": false, + "number": 3022, + "title": "feat(research): improve doubled rank-seven packing", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3022" + }, + "reviewed_head": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "current_head": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-doubled-residual-exchange" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3022", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3023, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "02ebc2ff8243baa9febbb6954f9169e4c216a65e", + "isDraft": false, + "number": 3023, + "title": "KB3h: (12,6) A-vanish (5,1) PROVEN impossible; (4,2)/(3,3) reduced to exact walkable forms (outcome=partial; no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3023" + }, + "reviewed_head": "02ebc2ff8243baa9febbb6954f9169e4c216a65e", + "current_head": "02ebc2ff8243baa9febbb6954f9169e4c216a65e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-18point-avtail-seed010d26fa" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3023", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3024, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "isDraft": false, + "number": 3024, + "title": "Attain the joint rank-seven packing cap exactly at T740", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3024" + }, + "reviewed_head": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "current_head": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-cap740" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3024", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3025, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "a544ef068a46f4de3bc47d1d02149cbdc3ba547f", + "isDraft": false, + "number": 3025, + "title": "Construction: reversible integer-lifting cleanup for the P104 collector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3025" + }, + "reviewed_head": "a544ef068a46f4de3bc47d1d02149cbdc3ba547f", + "current_head": "a544ef068a46f4de3bc47d1d02149cbdc3ba547f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-reversible-lifting" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3025", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3026, + "metadata": { + "author": { + "id": "MDQ6VXNlcjQ0MTczMTcz", + "is_bot": false, + "login": "flyingviper", + "name": "" + }, + "headRefOid": "d323df51afdb616d73ff577179bfb76d8832450d", + "isDraft": false, + "number": 3026, + "title": "P112: sharp cost-45 floor for all low-tariff frames on five triads", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3026" + }, + "reviewed_head": "d323df51afdb616d73ff577179bfb76d8832450d", + "current_head": "d323df51afdb616d73ff577179bfb76d8832450d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-five-group-projector-lift" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3026", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3027, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "e686b4a622846c01ac80d038d1441434e9c0b13c", + "isDraft": false, + "number": 3027, + "title": "Record that the selected-grammar root rejects the unit tape", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3027" + }, + "reviewed_head": "e686b4a622846c01ac80d038d1441434e9c0b13c", + "current_head": "e686b4a622846c01ac80d038d1441434e9c0b13c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-unit-root-tape-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3027", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3028, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9d10633660a3dff5469f4e7a0a009a6c9994c0d7", + "isDraft": false, + "number": 3028, + "title": "feat(research): release the T148 restore composition", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3028" + }, + "reviewed_head": "9d10633660a3dff5469f4e7a0a009a6c9994c0d7", + "current_head": "9d10633660a3dff5469f4e7a0a009a6c9994c0d7", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-t148-restore-release" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3028", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3029, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "6a2de790fadcf87db02eaa99b19b92eed5aa0d3f", + "isDraft": false, + "number": 3029, + "title": "Two-sided deficiency budget: Theorem BX for b_Q <= 4 (conditional frame, exact residue, no κ claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3029" + }, + "reviewed_head": "6a2de790fadcf87db02eaa99b19b92eed5aa0d3f", + "current_head": "6a2de790fadcf87db02eaa99b19b92eed5aa0d3f", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/two-sided-deficiency-budget/evidence/orig_chk8_B78.log; missing flat manifest file research/two-sided-deficiency-budget/evidence/orig_chk8_B80_first40.log. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3030, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "78e77d820393c6b8648b47af219e991edfcc54e6", + "isDraft": false, + "number": 3030, + "title": "feat(research): release the T740 R1 cap composition", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3030" + }, + "reviewed_head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "current_head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-t740-release" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3030", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3031, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "e75906fc4e8b9f756a9877b2e467f4e564851c7d", + "isDraft": false, + "number": 3031, + "title": "KB5L: tau >= 1 box floor PROVEN at v = 5 - shareable class narrowed - no kappa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3031" + }, + "reviewed_head": "e75906fc4e8b9f756a9877b2e467f4e564851c7d", + "current_head": "e75906fc4e8b9f756a9877b2e467f4e564851c7d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: research/fstar-boxfloor-v5-seedab80f07c/predecessor/pr3012/predecessor/pr2978/data/box-search-kj-receipt.json: Expecting value: line 1 column 1 (char 0); research/fstar-boxfloor-v5-seedab80f07c/predecessor/pr3012/predecessor/pr2978/predecessor/pr2963/predecessor/pr2914/CERTIFICATE.json: Expecting value: line 1 column 1 (char 0). Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3032, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "5b1a7939393ef2778ec058ee8367cdad52c86fb3", + "isDraft": false, + "number": 3032, + "title": "Reject PR3019 fixed P104 matching with a monotone relay cut", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3032" + }, + "reviewed_head": "5b1a7939393ef2778ec058ee8367cdad52c86fb3", + "current_head": "5b1a7939393ef2778ec058ee8367cdad52c86fb3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-fixed-matching-flag-consistency" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3032", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3033, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "b12bbaeb5ca2e83f15433fc2dd0ba3b766595281", + "isDraft": false, + "number": 3033, + "title": "Research: exact four-bit reduction and faster P104 lifting reference", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3033" + }, + "reviewed_head": "b12bbaeb5ca2e83f15433fc2dd0ba3b766595281", + "current_head": "b12bbaeb5ca2e83f15433fc2dd0ba3b766595281", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-lifting-residue-reduction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3033", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3034, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "a05791d428f5d06802fb4c96b33732e6347c64eb", + "isDraft": false, + "number": 3034, + "title": "KB3i: the 18-point cover remainder for F2^7 - parity shortcut DEMOTED, m=5 obstruction localized (outcome=partial, no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3034" + }, + "reviewed_head": "a05791d428f5d06802fb4c96b33732e6347c64eb", + "current_head": "a05791d428f5d06802fb4c96b33732e6347c64eb", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-18point-remainder-kb3i-a1" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3034", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3035, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "0cc430349a3f3dc200666bc22e997076e0a557ed", + "isDraft": false, + "number": 3035, + "title": "Certify a 343-bit coupled residue domain for P104 lifting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3035" + }, + "reviewed_head": "0cc430349a3f3dc200666bc22e997076e0a557ed", + "current_head": "0cc430349a3f3dc200666bc22e997076e0a557ed", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-coupled-lifting-residues" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3035", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3036, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "3717c1e684553c57bc73300410df65438a9ef095", + "isDraft": false, + "number": 3036, + "title": "Audit concrete rounding in the QQ16 F0 scalar projection", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3036" + }, + "reviewed_head": "3717c1e684553c57bc73300410df65438a9ef095", + "current_head": "3717c1e684553c57bc73300410df65438a9ef095", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-f0-rounded-scalar" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3036", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3037, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "02a1c41e8e016d3d0be64c62c8b4734f9c494236", + "isDraft": false, + "number": 3037, + "title": "Prove the P104 lifting translation lattice is maximal", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3037" + }, + "reviewed_head": "02a1c41e8e016d3d0be64c62c8b4734f9c494236", + "current_head": "02a1c41e8e016d3d0be64c62c8b4734f9c494236", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-maximal-translation-lattice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3037", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3038, + "metadata": { + "author": { + "id": "MDQ6VXNlcjI3NTY4NjE3", + "is_bot": false, + "login": "ToikY", + "name": "" + }, + "headRefOid": "c7d0d7be056ba77fda1c168641b2bcffb10cf43d", + "isDraft": false, + "number": 3038, + "title": "test(research): certify the V45 closed native endpoint cone", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3038" + }, + "reviewed_head": "c7d0d7be056ba77fda1c168641b2bcffb10cf43d", + "current_head": "c7d0d7be056ba77fda1c168641b2bcffb10cf43d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-native-cone-seed78" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3038", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3039, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "f0d6a48245e44fc29cfe077d21ca2521c2a8d941", + "isDraft": false, + "number": 3039, + "title": "Block-climb complete profile: exact obstruction for charged block-climb realization - no kappa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3039" + }, + "reviewed_head": "f0d6a48245e44fc29cfe077d21ca2521c2a8d941", + "current_head": "f0d6a48245e44fc29cfe077d21ca2521c2a8d941", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "The per-group inequality does not justify excluding every mixed complete profile. PR3066 supplies a free/charged cost-alphabet counterexample; scope the obstruction to individual charged groups and re-audit the call-level inference. No physical decoder or improved supplier follows from that counterexample.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3040, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "53fc5af5b778b8bbe6472d69a4f112d76febc108", + "isDraft": false, + "number": 3040, + "title": "Rank-8 rigidity of the E8 pattern with arbitrary extra zeros after deleting any at most 8 lines (hypothesis (1) of Lemma RIGD; no kappa claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3040" + }, + "reviewed_head": "53fc5af5b778b8bbe6472d69a4f112d76febc108", + "current_head": "53fc5af5b778b8bbe6472d69a4f112d76febc108", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/e8-rank8-rigidity-small-deletions/evidence/cubev8.out; missing flat manifest file research/e8-rank8-rigidity-small-deletions/evidence/R1-RIG3/fr_40.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3041, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b89c9eef729eb1e5889e2095d59a6fbf4738447d", + "isDraft": false, + "number": 3041, + "title": "Independently prove conditional selected residual/CALL refinement", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3041" + }, + "reviewed_head": "b89c9eef729eb1e5889e2095d59a6fbf4738447d", + "current_head": "b89c9eef729eb1e5889e2095d59a6fbf4738447d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/residual-call-refinement" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3041", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3042, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "84cc406ad91ec53fff329a11a445d7effe564a77", + "isDraft": false, + "number": 3042, + "title": "Conditional κ = 0.001729736166387916: six restore carrier/pivot skips (R1_E42, R2_E7) on PR2979's words and literal allocation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3042" + }, + "reviewed_head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "current_head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-carrier-skips" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3042", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3043, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "b5cabfb02a3d8bc3121825144373b03a5648479d", + "isDraft": false, + "number": 3043, + "title": "Construct and price a reversible P104 residue extractor", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3043" + }, + "reviewed_head": "b5cabfb02a3d8bc3121825144373b03a5648479d", + "current_head": "b5cabfb02a3d8bc3121825144373b03a5648479d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-modular-residue-reducer" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3043", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3044, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1f922b25abff2d7fd87fa5b29619160862a06b59", + "isDraft": false, + "number": 3044, + "title": "feat(research): share the rank-seven restore covector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3044" + }, + "reviewed_head": "1f922b25abff2d7fd87fa5b29619160862a06b59", + "current_head": "1f922b25abff2d7fd87fa5b29619160862a06b59", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-shared-restore-fanin" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3044", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3045, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "16feea078f5542964ae85ca1b1f35bb94314ae78", + "isDraft": false, + "number": 3045, + "title": "Non-dense fitting B: every E8 term with x·y ≠ 0 has rank ≥ 9; square root-code floors E8 ≥ 72, P112 ≥ 64, P104 ≥ 56, D4 ≥ 12 for any fitting B (no κ claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3045" + }, + "reviewed_head": "16feea078f5542964ae85ca1b1f35bb94314ae78", + "current_head": "16feea078f5542964ae85ca1b1f35bb94314ae78", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/nondense-pairing-square-floors/evidence/a1_brute.log; missing flat manifest file research/nondense-pairing-square-floors/evidence/a1_e8.log. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3046, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "5549524f7894120b7e993522eb3a59956df5c5c3", + "isDraft": false, + "number": 3046, + "title": "Reuse the forward P104 residue basis for the exact inverse", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3046" + }, + "reviewed_head": "5549524f7894120b7e993522eb3a59956df5c5c3", + "current_head": "5549524f7894120b7e993522eb3a59956df5c5c3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-inverse-residue-permutation" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3046", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3047, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "8beaff37e90aa63141ec148ba85da4d6fc80c935", + "isDraft": false, + "number": 3047, + "title": "fix(tooling): name offending keys, caps and shapes in research package checks", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3047" + }, + "reviewed_head": "8beaff37e90aa63141ec148ba85da4d6fc80c935", + "current_head": "8beaff37e90aa63141ec148ba85da4d6fc80c935", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/research-package-guide.md", + "scripts/research_package.py", + "tests/test_research_package_diagnostics.py" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3047", + "merge_commit": "bc191093c71895ec9c70f238c58056e428b21847" + } + }, + { + "number": 3048, + "metadata": { + "author": { + "id": "MDQ6VXNlcjQ0MTczMTcz", + "is_bot": false, + "login": "flyingviper", + "name": "" + }, + "headRefOid": "71a0ec5012a04965826c62ad27532b5a4e014480", + "isDraft": false, + "number": 3048, + "title": "P112: exclude cost 296 in the aligned six-mode factor family", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3048" + }, + "reviewed_head": "71a0ec5012a04965826c62ad27532b5a4e014480", + "current_head": "71a0ec5012a04965826c62ad27532b5a4e014480", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-six-mode-exclusion" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3048", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3049, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "3d61d02651e4ba9d92229d9943d073e9c427ab95", + "isDraft": false, + "number": 3049, + "title": "Research: one-sided residue closures, part 2 — Lemma Q4, count lemma + E6 dim-cover and rerunnable span passes close 78 more of the 116 open residues (38 open; no kappa claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3049" + }, + "reviewed_head": "3d61d02651e4ba9d92229d9943d073e9c427ab95", + "current_head": "3d61d02651e4ba9d92229d9943d073e9c427ab95", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/one-sided-residue-closures-2/checks/all.out; missing flat manifest file research/one-sided-residue-closures-2/evidence/sc_rerun751/7-5-1-s0_M1r0J2j1.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3050, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "7c9d6b8b01606fa51032c0166f5ed522c8fa5735", + "isDraft": false, + "number": 3050, + "title": "test(research): independently audit the six restore skips", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3050" + }, + "reviewed_head": "7c9d6b8b01606fa51032c0166f5ed522c8fa5735", + "current_head": "7c9d6b8b01606fa51032c0166f5ed522c8fa5735", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-substitution-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3050", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3051, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMDk2NjQ=", + "is_bot": false, + "login": "jeremydiviney", + "name": "" + }, + "headRefOid": "10a45bd361554709840becb5bc26016ca49944c3", + "isDraft": false, + "number": 3051, + "title": "Verify six-skip/T740 release: conditional kappa 0.001729737950064279", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3051" + }, + "reviewed_head": "10a45bd361554709840becb5bc26016ca49944c3", + "current_head": "10a45bd361554709840becb5bc26016ca49944c3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-six-skip-cap-release" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3051", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3052, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "ae6dcf7e04de89198f8cd5321766d62bf6ee187b", + "isDraft": false, + "number": 3052, + "title": "Register the HPE post-wrapper uniqueness lemma (drawn card formal-interface-lemma)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3052" + }, + "reviewed_head": "ae6dcf7e04de89198f8cd5321766d62bf6ee187b", + "current_head": "ae6dcf7e04de89198f8cd5321766d62bf6ee187b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/hpe-post-wrapper-lemma" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3052", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3053, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "a977fd1989c092d6946766fe0e66625935799058", + "isDraft": false, + "number": 3053, + "title": "Independent verification (no κ): #3015's R1 restore edit on #2979's words is exact and correctly priced; R1 unique in its rewrite class; #3018 journal and #3021 composition reproduced; no defect found", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3053" + }, + "reviewed_head": "a977fd1989c092d6946766fe0e66625935799058", + "current_head": "a977fd1989c092d6946766fe0e66625935799058", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/t74-3015-restore-edit-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3053", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3054, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4773c3ea67b471415870e38411fae313ec44a675", + "isDraft": false, + "number": 3054, + "title": "feat(research): release the T740 six-skip composition", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3054" + }, + "reviewed_head": "4773c3ea67b471415870e38411fae313ec44a675", + "current_head": "4773c3ea67b471415870e38411fae313ec44a675", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-t740-carrier-skips" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3054", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3055, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "9dc841c9a101435fdd15e0f7623bf16b6d0363e9", + "isDraft": false, + "number": 3055, + "title": "Implement encoded physical Compact operations through B1", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3055" + }, + "reviewed_head": "9dc841c9a101435fdd15e0f7623bf16b6d0363e9", + "current_head": "9dc841c9a101435fdd15e0f7623bf16b6d0363e9", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-complex-compact" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3055", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3056, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9e4acb6049a6c1897ad8d515892f67204ab1d8c0", + "isDraft": false, + "number": 3056, + "title": "Contract PR3042's four-ADD restore block to three", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3056" + }, + "reviewed_head": "9e4acb6049a6c1897ad8d515892f67204ab1d8c0", + "current_head": "9e4acb6049a6c1897ad8d515892f67204ab1d8c0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-contraction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3056", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3057, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "8892832224cffb73553cc921e4e3b1ae75d7b886", + "isDraft": false, + "number": 3057, + "title": "Prove the complete restore-frame optimum of the six-skip words", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3057" + }, + "reviewed_head": "8892832224cffb73553cc921e4e3b1ae75d7b886", + "current_head": "8892832224cffb73553cc921e4e3b1ae75d7b886", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-frame-optimum" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3057", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3058, + "metadata": { + "author": { + "id": "MDQ6VXNlcjg2NDE2NTcy", + "is_bot": false, + "login": "conorholds", + "name": "conorholds" + }, + "headRefOid": "e67ca5f26351e09c5bb314821633e511212f88ec", + "isDraft": false, + "number": 3058, + "title": "Research: exact seven-source singleton minimum f(7) = 24", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3058" + }, + "reviewed_head": "e67ca5f26351e09c5bb314821633e511212f88ec", + "current_head": "e67ca5f26351e09c5bb314821633e511212f88ec", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/connector-covering-code" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3058", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3059, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "0b8b44c6cc367725a8737f8b3cd997f42d3bd0d9", + "isDraft": false, + "number": 3059, + "title": "Test pointwise P104 defect codes and the code-only update limit", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3059" + }, + "reviewed_head": "0b8b44c6cc367725a8737f8b3cd997f42d3bd0d9", + "current_head": "0b8b44c6cc367725a8737f8b3cd997f42d3bd0d9", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-pointwise-defect-consumer" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3059", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3060, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "df16ae619b858c5344a797c4424e0bafc2e69f62", + "isDraft": false, + "number": 3060, + "title": "Prove an optimal native tariff for the rank-seven restore block", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3060" + }, + "reviewed_head": "df16ae619b858c5344a797c4424e0bafc2e69f62", + "current_head": "df16ae619b858c5344a797c4424e0bafc2e69f62", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-native-tariff-optimum" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3060", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3063, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "3f384b8b7daccb2c8e12013fd81a738202ce0f8d", + "isDraft": false, + "number": 3063, + "title": "Prove exact dirty-output anchor child/ADD tariff frontier", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3063" + }, + "reviewed_head": "3f384b8b7daccb2c8e12013fd81a738202ce0f8d", + "current_head": "3f384b8b7daccb2c8e12013fd81a738202ce0f8d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/dirty-anchor-tradeoff" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3063", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3064, + "metadata": { + "author": { + "id": "U_kgDOFEm3gg", + "is_bot": false, + "login": "dataisfire", + "name": "dataisfire" + }, + "headRefOid": "239447f19b9365194bca2583014c947db5de8ea4", + "isDraft": false, + "number": 3064, + "title": "Propose conditional κ ≈ 0.001729737530919310 via T148 carrier skips (full replay pending)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3064" + }, + "reviewed_head": "239447f19b9365194bca2583014c947db5de8ea4", + "current_head": "239447f19b9365194bca2583014c947db5de8ea4", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-t148-restore-release", + "research/t148-carrier-skips" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Author reports resource-stopped full release; schedule a separately budgeted replay. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and 150-minute limit. No dispatch.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3064", + "merge_commit": "d6da9c46abfe949674a2ed5d6029dd6219f93434" + } + }, + { + "number": 3065, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1cd7d3af6f41dc53e02c26f0b2cf6ffb11106fc8", + "isDraft": false, + "number": 3065, + "title": "Prove the complete joint A/B/restore frame optimum", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3065" + }, + "reviewed_head": "1cd7d3af6f41dc53e02c26f0b2cf6ffb11106fc8", + "current_head": "1cd7d3af6f41dc53e02c26f0b2cf6ffb11106fc8", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-frame-optimum" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3065", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3066, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "8aa53674536727123436d3f76adb8f5dac6ddea1", + "isDraft": false, + "number": 3066, + "title": "Correct the mixed-profile inference in the block-climb screen", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3066" + }, + "reviewed_head": "8aa53674536727123436d3f76adb8f5dac6ddea1", + "current_head": "8aa53674536727123436d3f76adb8f5dac6ddea1", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/mixed-block-climb-overhead" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3066", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3067, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "e1e28b4070ae52efa5a9d0aa826bc588be7206f2", + "isDraft": false, + "number": 3067, + "title": "Bind the QQ16 F0 rounding witness to physical native execution", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3067" + }, + "reviewed_head": "e1e28b4070ae52efa5a9d0aa826bc588be7206f2", + "current_head": "e1e28b4070ae52efa5a9d0aa826bc588be7206f2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-f0-physical-rounding" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3067", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3068, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "7d2c519a1fdcc6bf66f6f08757eed7c48762d3f2", + "isDraft": false, + "number": 3068, + "title": "Certify a common invariant period lattice for P104 lifting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3068" + }, + "reviewed_head": "7d2c519a1fdcc6bf66f6f08757eed7c48762d3f2", + "current_head": "7d2c519a1fdcc6bf66f6f08757eed7c48762d3f2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-invariant-lifting-lattice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3068", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3069, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "cd02d94c5eb3c0e1452cc94aeb2231c4d704a684", + "isDraft": false, + "number": 3069, + "title": "Price signed dependent-source delivery over characteristic zero", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3069" + }, + "reviewed_head": "cd02d94c5eb3c0e1452cc94aeb2231c4d704a684", + "current_head": "cd02d94c5eb3c0e1452cc94aeb2231c4d704a684", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/signed-dependent-delivery" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3069", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3070, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "3e9445ed10067912838bd83222ea4066dcfbc62d", + "isDraft": false, + "number": 3070, + "title": "Test P104 defect codes under restricted coordinate updates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3070" + }, + "reviewed_head": "3e9445ed10067912838bd83222ea4066dcfbc62d", + "current_head": "3e9445ed10067912838bd83222ea4066dcfbc62d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-restricted-update-codes" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3070", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3071, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "6730b594ad6b0164d484ff1570d774d510fad130", + "isDraft": false, + "number": 3071, + "title": "Prove sharp selected-centre repair dimension for owner blocks up to six", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3071" + }, + "reviewed_head": "6730b594ad6b0164d484ff1570d774d510fad130", + "current_head": "6730b594ad6b0164d484ff1570d774d510fad130", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/centre-block-repair-information" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3071", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3072, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "cd1bbd05251f9d8e15cbb0192f1bfe83dc138f5e", + "isDraft": false, + "number": 3072, + "title": "Research: conditional blockwise P104 lifting at linear precision", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3072" + }, + "reviewed_head": "cd1bbd05251f9d8e15cbb0192f1bfe83dc138f5e", + "current_head": "cd1bbd05251f9d8e15cbb0192f1bfe83dc138f5e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-blockwise-lifting" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3072", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3073, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "9e808b67bc395dc91b55493a6fdce0863240bf1c", + "isDraft": false, + "number": 3073, + "title": "Factor P104 lifting defects through 201 exact real output channels", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3073" + }, + "reviewed_head": "9e808b67bc395dc91b55493a6fdce0863240bf1c", + "current_head": "9e808b67bc395dc91b55493a6fdce0863240bf1c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-defect-output-channels" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3073", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3074, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "3cc41f260c31052c933d0e75ea02f2b7677e780c", + "isDraft": false, + "number": 3074, + "title": "One-sided padding lemma: P112 to P120 at cost exactly +8 (L120 suffices for Delta >= n_nf)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3074" + }, + "reviewed_head": "3cc41f260c31052c933d0e75ea02f2b7677e780c", + "current_head": "3cc41f260c31052c933d0e75ea02f2b7677e780c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/one-sided-padding-lemma/expected/pad_audit.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3075, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "378b8e47fc01412cbc0bc49f0d7a3d40eb1d9442", + "isDraft": false, + "number": 3075, + "title": "Fully charged favourable relaxation for a k-call shared centre window", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3075" + }, + "reviewed_head": "378b8e47fc01412cbc0bc49f0d7a3d40eb1d9442", + "current_head": "378b8e47fc01412cbc0bc49f0d7a3d40eb1d9442", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/centre-shared-kcall-charged-seed615415" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3075", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3076, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "2037b8e4a8c03c2015f88904449f60d1fdf58ef3", + "isDraft": false, + "number": 3076, + "title": "Lower the complete rank-seven native bound by 340", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3076" + }, + "reviewed_head": "2037b8e4a8c03c2015f88904449f60d1fdf58ef3", + "current_head": "2037b8e4a8c03c2015f88904449f60d1fdf58ef3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-commuting-contractions" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3076", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3077, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "9e52b244e07b1d981dd945bba7ac6c16fa7fdd43", + "isDraft": false, + "number": 3077, + "title": "Research: dirty-output anchor; no selected kappa improvement", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3077" + }, + "reviewed_head": "9e52b244e07b1d981dd945bba7ac6c16fa7fdd43", + "current_head": "9e52b244e07b1d981dd945bba7ac6c16fa7fdd43", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/complex-dirty-output-temporary-sum-anchor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3077", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3078, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "3da2ea9729f70b074713a5d0f69f0bdab32f2b47", + "isDraft": false, + "number": 3078, + "title": "Materialize rank-seven scalar lowerings with explicit width guards", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3078" + }, + "reviewed_head": "3da2ea9729f70b074713a5d0f69f0bdab32f2b47", + "current_head": "3da2ea9729f70b074713a5d0f69f0bdab32f2b47", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-primitive-lowering" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3078", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3079, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "8aee45e6a918c99cdca98431c3e791d2b3fd4206", + "isDraft": false, + "number": 3079, + "title": "Research: independently replay #2979 staged rank profile and T74 aggregate", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3079" + }, + "reviewed_head": "8aee45e6a918c99cdca98431c3e791d2b3fd4206", + "current_head": "8aee45e6a918c99cdca98431c3e791d2b3fd4206", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-profile-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3079", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3080, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "fd5ff58c6c438c438481bc4bff8c86e2d4fbe865", + "isDraft": false, + "number": 3080, + "title": "Implement aligned bit circuits for the rank-seven ADD layer", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3080" + }, + "reviewed_head": "fd5ff58c6c438c438481bc4bff8c86e2d4fbe865", + "current_head": "fd5ff58c6c438c438481bc4bff8c86e2d4fbe865", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-aligned-bit-adders" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3080", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3081, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "d764f9c11c86c40d35fd67811e60284feb1b8f10", + "isDraft": false, + "number": 3081, + "title": "Implement a guarded bit caller for rank-seven dyadic ADDs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3081" + }, + "reviewed_head": "d764f9c11c86c40d35fd67811e60284feb1b8f10", + "current_head": "d764f9c11c86c40d35fd67811e60284feb1b8f10", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-fixed-width-half-add" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3081", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3082, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "c9c6b59ce5f526a0082d06b24470b7ac946e62da", + "isDraft": false, + "number": 3082, + "title": "Research: exact screen for kappa > 0.1 on selected suppliers", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3082" + }, + "reviewed_head": "c9c6b59ce5f526a0082d06b24470b7ac946e62da", + "current_head": "c9c6b59ce5f526a0082d06b24470b7ac946e62da", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/kappa01-target-screen" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3082", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3083, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "a2ff82111b42aa4abe38e2f8f0386c804111d17f", + "isDraft": false, + "number": 3083, + "title": "Certify rank-seven scalar grids and 77-bit endpoint formats", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3083" + }, + "reviewed_head": "a2ff82111b42aa4abe38e2f8f0386c804111d17f", + "current_head": "a2ff82111b42aa4abe38e2f8f0386c804111d17f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-coefficient-grid" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3083", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3084, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4b763c20da54e4e29e3edfdd1c3e251f5ede37e0", + "isDraft": false, + "number": 3084, + "title": "Prove exact alignment envelopes for rank-seven scalar streams", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3084" + }, + "reviewed_head": "4b763c20da54e4e29e3edfdd1c3e251f5ede37e0", + "current_head": "4b763c20da54e4e29e3edfdd1c3e251f5ede37e0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-scalar-lattice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3084", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3085, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "6d5db23b5ba34b20493fe9eea98d08682495a821", + "isDraft": false, + "number": 3085, + "title": "PR1 source and credit retention receipt (research consolidation, no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3085" + }, + "reviewed_head": "6d5db23b5ba34b20493fe9eea98d08682495a821", + "current_head": "6d5db23b5ba34b20493fe9eea98d08682495a821", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/pr1-retention-receipt" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3085", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3086, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1e47220c44a90976f1b53289f643794bad1aadfe", + "isDraft": false, + "number": 3086, + "title": "Prove the sharp native format at the rank-seven A13 half-ADD", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3086" + }, + "reviewed_head": "1e47220c44a90976f1b53289f643794bad1aadfe", + "current_head": "1e47220c44a90976f1b53289f643794bad1aadfe", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-native-half-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3086", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3087, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "e7e49fb8176772c71ad7006920a407109a89e440", + "isDraft": false, + "number": 3087, + "title": "Implement encoded physical Gaussian monomial phases", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3087" + }, + "reviewed_head": "e7e49fb8176772c71ad7006920a407109a89e440", + "current_head": "e7e49fb8176772c71ad7006920a407109a89e440", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-gaussian-monomial" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3087", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3088, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "19fefab093b802a58d0c432debfa72fa4b381b2d", + "isDraft": false, + "number": 3088, + "title": "Bind a physical four-ADD boundary and save 6,144 CNOTs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3088" + }, + "reviewed_head": "19fefab093b802a58d0c432debfa72fa4b381b2d", + "current_head": "19fefab093b802a58d0c432debfa72fa4b381b2d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-physical-a13" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3088", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3089, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4a5ce834638534a5bfab1b5169c4a7210b2c0656", + "isDraft": false, + "number": 3089, + "title": "Certify an 84-bit conditional rank-seven A-stage format", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3089" + }, + "reviewed_head": "4a5ce834638534a5bfab1b5169c4a7210b2c0656", + "current_head": "4a5ce834638534a5bfab1b5169c4a7210b2c0656", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-native-a-format" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3089", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3090, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "47a2bcec53667f490df6d40550e14a8ae465cba4", + "isDraft": false, + "number": 3090, + "title": "Certify coefficient construction within the 84-bit A-stage bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3090" + }, + "reviewed_head": "47a2bcec53667f490df6d40550e14a8ae465cba4", + "current_head": "47a2bcec53667f490df6d40550e14a8ae465cba4", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-coefficient-capacity" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3090", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3091, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "d546815f4b116a79bd0ecec6661d2b2b3de29377", + "isDraft": false, + "number": 3091, + "title": "Implement fused physical Gaussian coefficient arithmetic", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3091" + }, + "reviewed_head": "d546815f4b116a79bd0ecec6661d2b2b3de29377", + "current_head": "d546815f4b116a79bd0ecec6661d2b2b3de29377", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-gaussian-leaf" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3091", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3092, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "764123a9e18c9a838aee917af7657aa639804680", + "isDraft": false, + "number": 3092, + "title": "Independently audit the rank-seven coefficient-capacity claim", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3092" + }, + "reviewed_head": "764123a9e18c9a838aee917af7657aa639804680", + "current_head": "764123a9e18c9a838aee917af7657aa639804680", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-scalar-microstates" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3092", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3093, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf", + "isDraft": false, + "number": 3093, + "title": "Research: audit #2979 profile against kappa=0.1", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3093" + }, + "reviewed_head": "d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf", + "current_head": "d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Complete original version retained in Git ancestry; existing main-tree package unchanged.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_historical_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3093", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3094, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b7a761ce2d6198509adb4b09ebf22b5b17ea2f55", + "isDraft": false, + "number": 3094, + "title": "Implement a guarded Boolean caller for the rank-seven scalar layer", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3094" + }, + "reviewed_head": "b7a761ce2d6198509adb4b09ebf22b5b17ea2f55", + "current_head": "b7a761ce2d6198509adb4b09ebf22b5b17ea2f55", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-boolean-scalar-caller" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3094", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3095, + "metadata": { + "author": { + "id": "MDQ6VXNlcjgwMjk5Njgz", + "is_bot": false, + "login": "CubeJerry", + "name": "" + }, + "headRefOid": "41826461eaceb25b77c026148b50b884e3c9780e", + "isDraft": false, + "number": 3095, + "title": "Audit one-sided padding: exact field scope and normalization costs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3095" + }, + "reviewed_head": "41826461eaceb25b77c026148b50b884e3c9780e", + "current_head": "41826461eaceb25b77c026148b50b884e3c9780e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/one-sided-padding-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3095", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3096, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "b5bb91b123697d9a818ae35d2e165478756c960a", + "isDraft": false, + "number": 3096, + "title": "Record the bit-0 census false prune on 01021323", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3096" + }, + "reviewed_head": "b5bb91b123697d9a818ae35d2e165478756c960a", + "current_head": "b5bb91b123697d9a818ae35d2e165478756c960a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-bit0-false-prune" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3096", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3097, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "ef7a52f4b0acf7cc8c51f9d81274d106abeffa24", + "isDraft": false, + "number": 3097, + "title": "Research: rule out seven-owner centre information compression", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3097" + }, + "reviewed_head": "ef7a52f4b0acf7cc8c51f9d81274d106abeffa24", + "current_head": "ef7a52f4b0acf7cc8c51f9d81274d106abeffa24", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/centre-seven-owner-information-floor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3097", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3098, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "ae54061980ef6a956d1276c7775aa833c1f669ca", + "isDraft": false, + "number": 3098, + "title": "Execute scalar recipes on encoded sequential tapes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3098" + }, + "reviewed_head": "ae54061980ef6a956d1276c7775aa833c1f669ca", + "current_head": "ae54061980ef6a956d1276c7775aa833c1f669ca", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-scalar-stream" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3098", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3099, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "80b7b0b452de3c9fa4306f49d12e904a40cfbe2e", + "isDraft": false, + "number": 3099, + "title": "Record the selected scatter duplicate boundary", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3099" + }, + "reviewed_head": "80b7b0b452de3c9fa4306f49d12e904a40cfbe2e", + "current_head": "80b7b0b452de3c9fa4306f49d12e904a40cfbe2e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/scatter-duplicate-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3099", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3100, + "metadata": { + "author": { + "id": "U_kgDOE8HONA", + "is_bot": false, + "login": "josecarlosgonzalezroque-design", + "name": "" + }, + "headRefOid": "72380f027199199ed4b4dbfc252ec39163acc56c", + "isDraft": false, + "number": 3100, + "title": "Audit fractional label coercion at the bit checker/exporter boundary", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3100" + }, + "reviewed_head": "72380f027199199ed4b4dbfc252ec39163acc56c", + "current_head": "72380f027199199ed4b4dbfc252ec39163acc56c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/label-coordinate-boundary-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3100", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3101, + "metadata": { + "author": { + "id": "U_kgDOB5L2iw", + "is_bot": false, + "login": "theon199", + "name": "Sricharan Vagvala" + }, + "headRefOid": "9a6d3b4e62cd41e25557511fa9b7ef270698c605", + "isDraft": false, + "number": 3101, + "title": "Research/qq16 native rounded audit", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3101" + }, + "reviewed_head": "9a6d3b4e62cd41e25557511fa9b7ef270698c605", + "current_head": "9a6d3b4e62cd41e25557511fa9b7ef270698c605", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-native-rounded-components" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3101", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3102, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "39bb449ef136cb3899ca16a6933abba52decf021", + "isDraft": false, + "number": 3102, + "title": "Allow research task selection from sparse checkouts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3102" + }, + "reviewed_head": "39bb449ef136cb3899ca16a6933abba52decf021", + "current_head": "39bb449ef136cb3899ca16a6933abba52decf021", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/agent-procedure.md", + "scripts/choose_research_task.py", + "tests/test_research_assignment.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3102", + "merge_commit": "66d0410ce73397c9eee825ef28276d49b397ffb1" + } + }, + { + "number": 3103, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "de12c885fb742735af90b496d30760b639fd6e5a", + "isDraft": false, + "number": 3103, + "title": "Independently verify all patterns in the T740 six-skip packing cap", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3103" + }, + "reviewed_head": "de12c885fb742735af90b496d30760b639fd6e5a", + "current_head": "de12c885fb742735af90b496d30760b639fd6e5a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/t740-independent-packing-cap" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3103", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3104, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "107dd53ba63afb49688b830fc855829a1336a860", + "isDraft": false, + "number": 3104, + "title": "Fix stale commit attribution in PR path overlap reports", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3104" + }, + "reviewed_head": "107dd53ba63afb49688b830fc855829a1336a860", + "current_head": "107dd53ba63afb49688b830fc855829a1336a860", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/agent-procedure.md", + "scripts/find_overlap.py", + "tests/test_research_onboarding.py", + "tests/test_research_pr_file_pages.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3104", + "merge_commit": "e25b9809c0857a117537629188fd62264b411400" + } + }, + { + "number": 3105, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "7f6b0c765ffeaa6c75e692f73dbbad414e3d2453", + "isDraft": false, + "number": 3105, + "title": "Close the three-line F-star census remainder with a correct joint quotient", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3105" + }, + "reviewed_head": "7f6b0c765ffeaa6c75e692f73dbbad414e3d2453", + "current_head": "7f6b0c765ffeaa6c75e692f73dbbad414e3d2453", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/fstar-joint-label-census" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3105", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3106, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "1a9da866330d31d7b6edc5f514802a3ab2176f88", + "isDraft": false, + "number": 3106, + "title": "Bind and execute the first selected whole-family prefix", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3106" + }, + "reviewed_head": "1a9da866330d31d7b6edc5f514802a3ab2176f88", + "current_head": "1a9da866330d31d7b6edc5f514802a3ab2176f88", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-first-prefix" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3106", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3107, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "7d40236bf22109ad64ae95a1d25eff7fa40478b5", + "isDraft": false, + "number": 3107, + "title": "Kappa 0.1 budget screens; corrected paired-plane route", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3107" + }, + "reviewed_head": "7d40236bf22109ad64ae95a1d25eff7fa40478b5", + "current_head": "7d40236bf22109ad64ae95a1d25eff7fa40478b5", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/7d40236bf22109ad64ae95a1d25eff7fa40478b5" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Complete original version retained in Git ancestry; existing main-tree package unchanged.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_historical_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3107", + "merge_commit": "970ea2f6cc0fe5b7fa44787bee6b8fa4d059980b" + } + }, + { + "number": 3108, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "996a37e21d676a71d7f6df7e00513ce25d7f0f6d", + "isDraft": false, + "number": 3108, + "title": "KB3j: the (4,2) and (3,3) A-vanish walks - budget-honest partial with receipts; even-half self-sum profiles classified (outcome=partial; no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3108" + }, + "reviewed_head": "996a37e21d676a71d7f6df7e00513ce25d7f0f6d", + "current_head": "996a37e21d676a71d7f6df7e00513ce25d7f0f6d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-18point-av42-kb3j-b1" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3108", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3109, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "15eac811648182bdac7254a91fd9b841b1414ebc", + "isDraft": false, + "number": 3109, + "title": "Derive a batched reversible lifting bound with paid history", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3109" + }, + "reviewed_head": "15eac811648182bdac7254a91fd9b841b1414ebc", + "current_head": "15eac811648182bdac7254a91fd9b841b1414ebc", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/batched-spaced-lifting" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3109", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3110, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "f01a1bb3910cf27fd9ebacecaf90f503ca75e535", + "isDraft": false, + "number": 3110, + "title": "Rank-shape fully charged block-climb gate screen: exact zero-charge thresholds - no new kappa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3110" + }, + "reviewed_head": "f01a1bb3910cf27fd9ebacecaf90f503ca75e535", + "current_head": "f01a1bb3910cf27fd9ebacecaf90f503ca75e535", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank-shape-coframe-bill-seed850bc3" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3110", + "merge_commit": "b168f6412ce0d508fa62cc5faf403c2d95ad7cd5" + } + }, + { + "number": 3111, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "fcba8eab38c51f4cdb685559be505222d44f8ddc", + "isDraft": false, + "number": 3111, + "title": "Selected bit profile alone exceeds the κ=0.1 moment budget", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3111" + }, + "reviewed_head": "fcba8eab38c51f4cdb685559be505222d44f8ddc", + "current_head": "fcba8eab38c51f4cdb685559be505222d44f8ddc", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/fcba8eab38c51f4cdb685559be505222d44f8ddc" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Complete original version retained in Git ancestry; existing main-tree package unchanged. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_historical_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3111", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3112, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "965072717fb8d168f294ef6998c1badb9ae14e17", + "isDraft": false, + "number": 3112, + "title": "Record the V45 single-lowering margin", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3112" + }, + "reviewed_head": "965072717fb8d168f294ef6998c1badb9ae14e17", + "current_head": "965072717fb8d168f294ef6998c1badb9ae14e17", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-single-lowering" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3112", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3113, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "725d9ba226b388737fd02e636f10cd69701e8d58", + "isDraft": false, + "number": 3113, + "title": "Selected stock envelope at m=73: bound quantities and the exact missing shape lemma", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3113" + }, + "reviewed_head": "725d9ba226b388737fd02e636f10cd69701e8d58", + "current_head": "725d9ba226b388737fd02e636f10cd69701e8d58", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-stock-envelope-m73" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3113", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3114, + "metadata": { + "author": { + "id": "MDQ6VXNlcjMwNTExNDU2", + "is_bot": false, + "login": "mdumitrean", + "name": "aigent-marius" + }, + "headRefOid": "c88769c350977d9ed4f90fe5c652d582cfe2782a", + "isDraft": false, + "number": 3114, + "title": "research: restore-only optimum for PR #3042's six-skip words (scoped exact negative, no new κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3114" + }, + "reviewed_head": "c88769c350977d9ed4f90fe5c652d582cfe2782a", + "current_head": "c88769c350977d9ed4f90fe5c652d582cfe2782a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-skip-restore-optimum" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3114", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3115, + "metadata": { + "author": { + "id": "U_kgDOFEm3gg", + "is_bot": false, + "login": "dataisfire", + "name": "dataisfire" + }, + "headRefOid": "400bc83669f86917f69b6249cd0356d3a913293c", + "isDraft": false, + "number": 3115, + "title": "research: κ = 0.001729737950064278551242895823 − 10^-52 − 10^-76", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3115" + }, + "reviewed_head": "400bc83669f86917f69b6249cd0356d3a913293c", + "current_head": "400bc83669f86917f69b6249cd0356d3a913293c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/t740-six-skip-precision30" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3115", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3116, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "2ebdcfebd6d3da023dc45ddf68729f0771ccb77c", + "isDraft": false, + "number": 3116, + "title": "Research: source-bound weighted diagonal rank-batching screen", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3116" + }, + "reviewed_head": "2ebdcfebd6d3da023dc45ddf68729f0771ccb77c", + "current_head": "2ebdcfebd6d3da023dc45ddf68729f0771ccb77c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/complex-weighted-diagonal-rank51" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3116", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3117, + "metadata": { + "author": { + "id": "MDQ6VXNlcjgwMjk5Njgz", + "is_bot": false, + "login": "CubeJerry", + "name": "" + }, + "headRefOid": "e0cc74ffa679b073f99644bd71b915b38abb7136", + "isDraft": false, + "number": 3117, + "title": "Certify R439 disjoint-helper optimum: 17,933 ADDs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3117" + }, + "reviewed_head": "e0cc74ffa679b073f99644bd71b915b38abb7136", + "current_head": "e0cc74ffa679b073f99644bd71b915b38abb7136", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/r439-copyshare-optimal-matching" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3117", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3118, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "269e27082ff78677b588daf19e0632ba0502655b", + "isDraft": false, + "number": 3118, + "title": "KB3k: demote the mu2-constant even-half condition; (4,2) walk shard 29 (outcome=partial)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3118" + }, + "reviewed_head": "269e27082ff78677b588daf19e0632ba0502655b", + "current_head": "269e27082ff78677b588daf19e0632ba0502655b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-mu2-evenhalf-kb3k-88a1" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3118", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3119, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "57cdb0e372d0dc1de6bbf705da24727b111e7f40", + "isDraft": false, + "number": 3119, + "title": "Record V45 in the shipped words and cap brackets", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3119" + }, + "reviewed_head": "57cdb0e372d0dc1de6bbf705da24727b111e7f40", + "current_head": "57cdb0e372d0dc1de6bbf705da24727b111e7f40", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-shipped-invoice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3119", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3120, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "6e36982ccc888bdb4dc15982322d8fe1aed392b4", + "isDraft": false, + "number": 3120, + "title": "Copied-information floor of the selected centre path", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3120" + }, + "reviewed_head": "6e36982ccc888bdb4dc15982322d8fe1aed392b4", + "current_head": "6e36982ccc888bdb4dc15982322d8fe1aed392b4", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "PR3147 identifies an owner lookup error (local role indices treated as global owner IDs): 16/1152 becomes 1152/1152 with positional indexing. Correct the physical-map evidence and revisit the independent-call sharing premise before intake; isolated per-call rank evidence is not rejected.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3121, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "eea0861aff47df568be4bb4a4db43c2da390d351", + "isDraft": false, + "number": 3121, + "title": "Prove optimal edge-priced dirty-output fanout", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3121" + }, + "reviewed_head": "eea0861aff47df568be4bb4a4db43c2da390d351", + "current_head": "eea0861aff47df568be4bb4a4db43c2da390d351", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/dirty-anchor-edge-tariffs" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3121", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3122, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "bd06efe0c53280c585d0f3b2f21c52d036f40902", + "isDraft": false, + "number": 3122, + "title": "Research: reduce batched lifting clean workspace with paid checkpoints", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3122" + }, + "reviewed_head": "bd06efe0c53280c585d0f3b2f21c52d036f40902", + "current_head": "bd06efe0c53280c585d0f3b2f21c52d036f40902", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/lifting-checkpoint-space" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3122", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3123, + "metadata": { + "author": { + "id": "U_kgDOCcbgOg", + "is_bot": false, + "login": "1337isnot1337", + "name": "Cinna Davis" + }, + "headRefOid": "195dcb14fb2e2b4de72d8e573ab6cbe120c844ba", + "isDraft": false, + "number": 3123, + "title": "Correct the κ=0.1 complex cost screen and bound scalar-query repairs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3123" + }, + "reviewed_head": "195dcb14fb2e2b4de72d8e573ab6cbe120c844ba", + "current_head": "195dcb14fb2e2b4de72d8e573ab6cbe120c844ba", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/kappa01-bit-repair", + "research/kappa01-fieldline-repair", + "research/kappa01-haemers-repair", + "research/kappa01-outer-repair", + "research/kappa01-plane-audit", + "research/kappa01-repair" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3123", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3124, + "metadata": { + "author": { + "id": "U_kgDOCcbgOg", + "is_bot": false, + "login": "1337isnot1337", + "name": "Cinna Davis" + }, + "headRefOid": "ce468c5cf22f59db3071adda269ac4cc16469c8c", + "isDraft": false, + "number": 3124, + "title": "Find a P104 short-cycle matching that survives the helper-91 screen", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3124" + }, + "reviewed_head": "ce468c5cf22f59db3071adda269ac4cc16469c8c", + "current_head": "ce468c5cf22f59db3071adda269ac4cc16469c8c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-alternating-cycle-neighborhood" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. PR3182 excludes extensions of these matching candidates at other helpers; the original one-helper result already leaves them relaxed. Retained only within that stated narrow scope.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3124", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3125, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "18f7accb8297610e3ef0489c9ca51b18944c650c", + "isDraft": false, + "number": 3125, + "title": "Changed helper inventories screened against the packing ceiling (complex-new-helper-inventory)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3125" + }, + "reviewed_head": "18f7accb8297610e3ef0489c9ca51b18944c650c", + "current_head": "18f7accb8297610e3ef0489c9ca51b18944c650c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/helper-inventory-moment-seede64193c0" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3125", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3126, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "831a5d8f34f83c6231d10abca162c128d9d733f4", + "isDraft": false, + "number": 3126, + "title": "Record V45 widths and the inherited call order", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3126" + }, + "reviewed_head": "831a5d8f34f83c6231d10abca162c128d9d733f4", + "current_head": "831a5d8f34f83c6231d10abca162c128d9d733f4", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-idle-chronology" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3126", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3127, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "2d685e0dbdcc8c9a370bc77c2f36ccaa7636e37d", + "isDraft": false, + "number": 3127, + "title": "Implement encoded one-pass Gaussian normalization", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3127" + }, + "reviewed_head": "2d685e0dbdcc8c9a370bc77c2f36ccaa7636e37d", + "current_head": "2d685e0dbdcc8c9a370bc77c2f36ccaa7636e37d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/gaussian-normalization-stream" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3127", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3128, + "metadata": { + "author": { + "id": "U_kgDOB5L2iw", + "is_bot": false, + "login": "theon199", + "name": "Sricharan Vagvala" + }, + "headRefOid": "2bf13e5b55f8318ae74a8f17db36a19447ba8c7f", + "isDraft": false, + "number": 3128, + "title": "Audit retained-helper independence in scatter parity", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3128" + }, + "reviewed_head": "2bf13e5b55f8318ae74a8f17db36a19447ba8c7f", + "current_head": "2bf13e5b55f8318ae74a8f17db36a19447ba8c7f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/retained-alias-parity-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3128", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3129, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "3276dd7022332e199c4f973df09f85063eb99e94", + "isDraft": false, + "number": 3129, + "title": "Research: near-input clean workspace for batched lifting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3129" + }, + "reviewed_head": "3276dd7022332e199c4f973df09f85063eb99e94", + "current_head": "3276dd7022332e199c4f973df09f85063eb99e94", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/lifting-relative-history" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3129", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3130, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "d34c1142f914c477708d1bb03db11691b0341070", + "isDraft": false, + "number": 3130, + "title": "Tooling: synthesize optimal dirty fanout with direct cut certificates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3130" + }, + "reviewed_head": "d34c1142f914c477708d1bb03db11691b0341070", + "current_head": "d34c1142f914c477708d1bb03db11691b0341070", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/dirty-fanout-cut-certificate" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3130", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3131, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "0c9e344d5a5295a218558fa4a51d867f39ff5311", + "isDraft": false, + "number": 3131, + "title": "Construct fast dense execution of the original paired collector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3131" + }, + "reviewed_head": "0c9e344d5a5295a218558fa4a51d867f39ff5311", + "current_head": "0c9e344d5a5295a218558fa4a51d867f39ff5311", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/dense-paired-collector" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3131", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3132, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "d63c41cfdc8b1e4046b2e92bbabd688d702f4fa9", + "isDraft": false, + "number": 3132, + "title": "Research: native warp relations add no paired-extraction directions", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3132" + }, + "reviewed_head": "d63c41cfdc8b1e4046b2e92bbabd688d702f4fa9", + "current_head": "d63c41cfdc8b1e4046b2e92bbabd688d702f4fa9", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/native-warp-extraction-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3132", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3133, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "51eb9c4ee9e4722010d308aa3309e039d3940cc2", + "isDraft": false, + "number": 3133, + "title": "research(rank7-coupled-586-588-carrier-fold): lower helpers 586 & 588 via coupled B+restore carrier folds (κ = 0.0017297760894)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3133" + }, + "reviewed_head": "51eb9c4ee9e4722010d308aa3309e039d3940cc2", + "current_head": "51eb9c4ee9e4722010d308aa3309e039d3940cc2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-coupled-586-588-carrier-fold" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3133", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3134, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "d8c0e3e88e501da6c19f858b7debf0c2e3e0be69", + "isDraft": false, + "number": 3134, + "title": "Construction: cut paired-collector wrapper lifting calls from 416 to 104", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3134" + }, + "reviewed_head": "d8c0e3e88e501da6c19f858b7debf0c2e3e0be69", + "current_head": "d8c0e3e88e501da6c19f858b7debf0c2e3e0be69", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/guarded-wrapper-refinement" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3134", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3135, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "776ae75d640e6a5672e8ea798677a2cd3ae2d53c", + "isDraft": false, + "number": 3135, + "title": "research: release T740 precision35 kappa refinement", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3135" + }, + "reviewed_head": "776ae75d640e6a5672e8ea798677a2cd3ae2d53c", + "current_head": "776ae75d640e6a5672e8ea798677a2cd3ae2d53c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/t740-six-skip-precision35" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3135", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3136, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "3e73133a7b6a73d9433a2e33dc3404d8d049f20d", + "isDraft": false, + "number": 3136, + "title": "Independently audit the coupled helper 586/588 carrier folds", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3136" + }, + "reviewed_head": "3e73133a7b6a73d9433a2e33dc3404d8d049f20d", + "current_head": "3e73133a7b6a73d9433a2e33dc3404d8d049f20d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/coupled-carrier-independent-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3136", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3137, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "2e69ca272de81e92e91aabac3b4652382b5794f6", + "isDraft": false, + "number": 3137, + "title": "Research: compile Q8 dirty couplings with a sparse array invoice", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3137" + }, + "reviewed_head": "2e69ca272de81e92e91aabac3b4652382b5794f6", + "current_head": "2e69ca272de81e92e91aabac3b4652382b5794f6", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/q8-affine-dirty-compiler" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3137", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3138, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "2a4a17457e21de2de684bd8ad19938e9aef2319f", + "isDraft": false, + "number": 3138, + "title": "Tooling: export committed research packages with offline integrity checks", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3138" + }, + "reviewed_head": "2a4a17457e21de2de684bd8ad19938e9aef2319f", + "current_head": "2a4a17457e21de2de684bd8ad19938e9aef2319f", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/package-export.md", + "docs/research/research-package-guide.md", + "scripts/export_research_package.py", + "tests/test_research_export.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3138", + "merge_commit": "b4273541908438ecf7921a81bb586620cfdce78a" + } + }, + { + "number": 3139, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "54bbb81cc884819154776900830eeb4d9db4dc5e", + "isDraft": false, + "number": 3139, + "title": "Tooling: bound hung isolated test modules without dropping coverage", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3139" + }, + "reviewed_head": "54bbb81cc884819154776900830eeb4d9db4dc5e", + "current_head": "54bbb81cc884819154776900830eeb4d9db4dc5e", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/ci-verification.md", + "scripts/run_isolated_tests.py", + "tests/test_isolated_test_deadlines.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3139", + "merge_commit": "dc9b61bfbda92fd3b94556080da1c99e0d9f7dde" + } + }, + { + "number": 3140, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "495f4b924596a4c78eaae32ae91872940ca0d9d8", + "isDraft": false, + "number": 3140, + "title": "Tooling: explain every registered replay selection", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3140" + }, + "reviewed_head": "495f4b924596a4c78eaae32ae91872940ca0d9d8", + "current_head": "495f4b924596a4c78eaae32ae91872940ca0d9d8", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/research-package-guide.md", + "scripts/research_package.py", + "tests/test_research_plan_explanations.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3140", + "merge_commit": "5267e364cdc31d0de9680e70b034ed8a7d1839b7" + } + }, + { + "number": 3141, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "6c8d1615f94c3615b2d23a424d3bf72ebe6009e4", + "isDraft": false, + "number": 3141, + "title": "Tooling: reject changed-base mixtures in PR file overlap snapshots", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3141" + }, + "reviewed_head": "6c8d1615f94c3615b2d23a424d3bf72ebe6009e4", + "current_head": "6c8d1615f94c3615b2d23a424d3bf72ebe6009e4", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/coordination.md", + "scripts/find_overlap.py", + "tests/test_research_onboarding.py", + "tests/test_research_pr_base_binding.py", + "tests/test_research_pr_file_pages.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3141", + "merge_commit": "6c809827340e8b15ba0caf47d6f82b8619300b3a" + } + }, + { + "number": 3142, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "c28ab1decefe9be591cb30894d6bf15216ec2979", + "isDraft": false, + "number": 3142, + "title": "Tooling: preserve complete replay selection in sparse checkouts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3142" + }, + "reviewed_head": "c28ab1decefe9be591cb30894d6bf15216ec2979", + "current_head": "c28ab1decefe9be591cb30894d6bf15216ec2979", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/research-package-guide.md", + "scripts/research_package.py", + "tests/test_research_matrix_batches.py", + "tests/test_research_sparse_planning.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3142", + "merge_commit": "93a8c73ceda815aba507a8e3c1e0788a6dd95f91" + } + }, + { + "number": 3143, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "dcfaf1d1a7cfebaab22b95776a36a543bc684d50", + "isDraft": false, + "number": 3143, + "title": "research(rank7): certify precision-40 κ above PR3133", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3143" + }, + "reviewed_head": "dcfaf1d1a7cfebaab22b95776a36a543bc684d50", + "current_head": "dcfaf1d1a7cfebaab22b95776a36a543bc684d50", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source integrity: missing manifest file research/rank7-coupled-586-588-carrier-fold-precision40/evidence/logs/release-verify/audit-local-566-base.log; missing manifest file research/rank7-coupled-586-588-carrier-fold-precision40/evidence/logs/release-verify/audit-local-566-extra.log; missing manifest file research/rank7-coupled-586-588-carrier-fold-precision40/evidence/logs/release-verify/declared-edit-review.log. Restore the manifest-listed files or explicitly correct the manifest scope without silently dropping claimed evidence.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3146, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE1MzM0MQ==", + "is_bot": false, + "login": "kumagi", + "name": "Hiroki KUMAZAKI" + }, + "headRefOid": "e9271f2c916ae07078d46aaea851834ce7906747", + "isDraft": false, + "number": 3146, + "title": "Audit PR3044 cold release with independent local and invoice checks", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3146" + }, + "reviewed_head": "e9271f2c916ae07078d46aaea851834ce7906747", + "current_head": "e9271f2c916ae07078d46aaea851834ce7906747", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/pr3044-independent-cold-replay" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3146", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3147, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "5cbc48b18cb05327a8dacab3f626412d3bc5e924", + "isDraft": false, + "number": 3147, + "title": "research: centre sink duality, dependent-triple braid sparsity (|B| <= 12), and circle-cancellation sharing ceilings", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3147" + }, + "reviewed_head": "5cbc48b18cb05327a8dacab3f626412d3bc5e924", + "current_head": "5cbc48b18cb05327a8dacab3f626412d3bc5e924", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "PR3151 supplies a target-only nonzero F2 witness and 48 later hosted bridges, contradicting the unchanged-endpoint circle elision/zero-feedback interpretation. Revise the schedule claim and distinguish relaxed pricing from a valid unchanged-endpoint construction. Other scoped results remain eligible after correction.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3148, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMDk2NjQ=", + "is_bot": false, + "login": "jeremydiviney", + "name": "" + }, + "headRefOid": "f2927a4b8afcf0701a6b945e14f30de1d94f5176", + "isDraft": false, + "number": 3148, + "title": "Realize the coupled-carrier T740 packing cap: κ ≈ 0.001729777494678597", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3148" + }, + "reviewed_head": "f2927a4b8afcf0701a6b945e14f30de1d94f5176", + "current_head": "f2927a4b8afcf0701a6b945e14f30de1d94f5176", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/coupled-carrier-cap740" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3148", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3150, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "e5c265f1be9cd0593f49628ec6552e52bd90af61", + "isDraft": false, + "number": 3150, + "title": "Research: execute the A13 native climb with 209,920 fewer CNOTs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3150" + }, + "reviewed_head": "e5c265f1be9cd0593f49628ec6552e52bd90af61", + "current_head": "e5c265f1be9cd0593f49628ec6552e52bd90af61", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-reversible-native-climb" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3150", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3151, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "ff21ddd5f801eccabb14fa88b76724a8d55c1e26", + "isDraft": false, + "number": 3151, + "title": "test(research): audit centre-circle demands and late responses", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3151" + }, + "reviewed_head": "ff21ddd5f801eccabb14fa88b76724a8d55c1e26", + "current_head": "ff21ddd5f801eccabb14fa88b76724a8d55c1e26", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/centre-circle-endpoint-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3151", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3152, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "66ee36401536625714c9937e36bbe7ef115da05f", + "isDraft": false, + "number": 3152, + "title": "Research: complete the scalar layer with one clean carry", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3152" + }, + "reviewed_head": "66ee36401536625714c9937e36bbe7ef115da05f", + "current_head": "66ee36401536625714c9937e36bbe7ef115da05f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-one-carry-scalars" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3152", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3153, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "c509607d1208396ec0045f0ab79f8392fce40b01", + "isDraft": false, + "number": 3153, + "title": "test(research): independently audit the coupled-carrier packing cap", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3153" + }, + "reviewed_head": "c509607d1208396ec0045f0ab79f8392fce40b01", + "current_head": "c509607d1208396ec0045f0ab79f8392fce40b01", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/coupled-cap-independent" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3153", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3154, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "708f0ad8928c383de8294aea3c126e9461d2066d", + "isDraft": false, + "number": 3154, + "title": "C(P112) >= 64: complete reduction to stated conjectures", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3154" + }, + "reviewed_head": "708f0ad8928c383de8294aea3c126e9461d2066d", + "current_head": "708f0ad8928c383de8294aea3c126e9461d2066d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source integrity: missing manifest file research/p112-reduction-to-conjectures/checks/FINITE2/one_150.out; missing manifest file research/p112-reduction-to-conjectures/checks/FINITE2/one_151.out; missing manifest file research/p112-reduction-to-conjectures/checks/FINITE2/one_152.out. Restore the manifest-listed files or explicitly correct the manifest scope without silently dropping claimed evidence.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3157, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNjU5ODM5", + "is_bot": false, + "login": "rohanarun", + "name": "" + }, + "headRefOid": "313ede7cfd0002b3884e235730a564e8ec7c2e05", + "isDraft": false, + "number": 3157, + "title": "Conditional κ ≈ 0.0017291527560043: R1 words at their packing cap (T740), +1.55e-9 over #3021", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3157" + }, + "reviewed_head": "313ede7cfd0002b3884e235730a564e8ec7c2e05", + "current_head": "313ede7cfd0002b3884e235730a564e8ec7c2e05", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-r1-t740-cap" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3157", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3158, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "8e2167bac550bd653bb74c50c1f7c3f14b6c1f70", + "isDraft": false, + "number": 3158, + "title": "test(research): certify the P112 deletion quantifier separation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3158" + }, + "reviewed_head": "8e2167bac550bd653bb74c50c1f7c3f14b6c1f70", + "current_head": "8e2167bac550bd653bb74c50c1f7c3f14b6c1f70", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-four-deletion-counterexample" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3158", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3159, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "f107d7331233c66c49579fdaa80c619e015cf245", + "isDraft": false, + "number": 3159, + "title": "Research: remove the separate SCALE bank and save 700,392 gates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3159" + }, + "reviewed_head": "f107d7331233c66c49579fdaa80c619e015cf245", + "current_head": "f107d7331233c66c49579fdaa80c619e015cf245", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-paired-scale" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3159", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3160, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9ab8c4cc2aed4a87293d7d04b2abfdf854ae43e2", + "isDraft": false, + "number": 3160, + "title": "test(research): certify the P112 common-deletion span", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3160" + }, + "reviewed_head": "9ab8c4cc2aed4a87293d7d04b2abfdf854ae43e2", + "current_head": "9ab8c4cc2aed4a87293d7d04b2abfdf854ae43e2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-common-deletion-span" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3160", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3161, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "a1aba8389b87412e6f72ccf4d11f31e0ea232327", + "isDraft": false, + "number": 3161, + "title": "Research: close the P112 (5,3) beta residue", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3161" + }, + "reviewed_head": "a1aba8389b87412e6f72ccf4d11f31e0ea232327", + "current_head": "a1aba8389b87412e6f72ccf4d11f31e0ea232327", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-mixed-rank-reduction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Schedule any complete replay separately. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and explicit 10/15/20-minute limits. No dispatch. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3161", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3162, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "ebd7fd275288e4a9f658e77fa77a0119a8322e74", + "isDraft": false, + "number": 3162, + "title": "Research: prove a ten-deletion P112 span bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3162" + }, + "reviewed_head": "ebd7fd275288e4a9f658e77fa77a0119a8322e74", + "current_head": "ebd7fd275288e4a9f658e77fa77a0119a8322e74", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-ten-deletion-span" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Schedule any complete replay separately. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and explicit 10/15/20-minute limits. No dispatch. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3162", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3163, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "89419106cd86896c366e853795978f1bc85f9112", + "isDraft": false, + "number": 3163, + "title": "test(research): certify a complete P112 common-deletion slice", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3163" + }, + "reviewed_head": "89419106cd86896c366e853795978f1bc85f9112", + "current_head": "89419106cd86896c366e853795978f1bc85f9112", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-common-deletion-slice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Schedule any complete replay separately. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and explicit 10/15/20-minute limits. No dispatch. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3163", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3164, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "857384079ab640a949fb7618b7909664d3e737e5", + "isDraft": false, + "number": 3164, + "title": "Research: exclude the final two P112 (5,4) beta shapes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3164" + }, + "reviewed_head": "857384079ab640a949fb7618b7909664d3e737e5", + "current_head": "857384079ab640a949fb7618b7909664d3e737e5", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-root-simplex-exclusion" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3164", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3165, + "metadata": { + "author": { + "id": "U_kgDOE8HONA", + "is_bot": false, + "login": "josecarlosgonzalezroque-design", + "name": "" + }, + "headRefOid": "9bdba17f90e7c2a3092186f55f06d019c2823546", + "isDraft": false, + "number": 3165, + "title": "Audit ten PR3114 departure obstructions with independent minors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3165" + }, + "reviewed_head": "9bdba17f90e7c2a3092186f55f06d019c2823546", + "current_head": "9bdba17f90e7c2a3092186f55f06d019c2823546", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-departure-minor-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3165", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3166, + "metadata": { + "author": { + "id": "MDQ6VXNlcjg2NDE2NTcy", + "is_bot": false, + "login": "conorholds", + "name": "conorholds" + }, + "headRefOid": "7c2a62363ad4945e8803fedea6ead78e1ad412b2", + "isDraft": false, + "number": 3166, + "title": "Prove the E8 d=0 kernel floor and scoped rigid C1 bounds", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3166" + }, + "reviewed_head": "7c2a62363ad4945e8803fedea6ead78e1ad412b2", + "current_head": "7c2a62363ad4945e8803fedea6ead78e1ad412b2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/e8-d0-root-swaps" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3166", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3167, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "c2c7508f2d731feea550f1628601aebd35c6e147", + "isDraft": false, + "number": 3167, + "title": "Research: prove a sharp P112 mixed-rank anchor bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3167" + }, + "reviewed_head": "c2c7508f2d731feea550f1628601aebd35c6e147", + "current_head": "c2c7508f2d731feea550f1628601aebd35c6e147", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-mixed-rank-anchor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3167", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3168, + "metadata": { + "author": { + "id": "MDQ6VXNlcjg0ODUxNjc4", + "is_bot": false, + "login": "Sudarsh3301", + "name": "Sudarsh Chaturvedi" + }, + "headRefOid": "b8844f08d8832eb87f8a5725f50d9c5eaac953d8", + "isDraft": false, + "number": 3168, + "title": "Independently check the seven-owner centre-repair Fano exclusion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3168" + }, + "reviewed_head": "b8844f08d8832eb87f8a5725f50d9c5eaac953d8", + "current_head": "b8844f08d8832eb87f8a5725f50d9c5eaac953d8", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/centre-seven-owner-fano-independent" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3168", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3169, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "2dbbd3004b70772cef200e341037c7c05b094fbc", + "isDraft": false, + "number": 3169, + "title": "Research: exclude five P112 beta shapes with a coordinate budget", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3169" + }, + "reviewed_head": "2dbbd3004b70772cef200e341037c7c05b094fbc", + "current_head": "2dbbd3004b70772cef200e341037c7c05b094fbc", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-ten-piece-simplex" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3169", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3170, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "182168c4a7af570902b231aa6d35bbf4139098f2", + "isDraft": false, + "number": 3170, + "title": "Research: exclude three larger-simplex P112 beta shapes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3170" + }, + "reviewed_head": "182168c4a7af570902b231aa6d35bbf4139098f2", + "current_head": "182168c4a7af570902b231aa6d35bbf4139098f2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-larger-root-simplices" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3170", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3171, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "95b683196950efea6f3d7ac66745e00dba73425e", + "isDraft": false, + "number": 3171, + "title": "Research: exclude P112 4,5^9 with quotient parity", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3171" + }, + "reviewed_head": "95b683196950efea6f3d7ac66745e00dba73425e", + "current_head": "95b683196950efea6f3d7ac66745e00dba73425e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-quotient-parity" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3171", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3172, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "0a632b00ef59a9f43b1f6c7965ff1ca7a3f188f3", + "isDraft": false, + "number": 3172, + "title": "research: all-endpoint nonlinear recovery obstruction for PR2918", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3172" + }, + "reviewed_head": "0a632b00ef59a9f43b1f6c7965ff1ca7a3f188f3", + "current_head": "0a632b00ef59a9f43b1f6c7965ff1ca7a3f188f3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-terminal-information-barrier" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3172", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3173, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "fb731630083bece860c0c46ef3a25542385a83dc", + "isDraft": false, + "number": 3173, + "title": "Research: exclude six P112 profiles with a coordinate-sensitive bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3173" + }, + "reviewed_head": "fb731630083bece860c0c46ef3a25542385a83dc", + "current_head": "fb731630083bece860c0c46ef3a25542385a83dc", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-simplex-coordinate-bound" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3173", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3174, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "e38c9cff85f2af817b403291285468ca3899f9c7", + "isDraft": false, + "number": 3174, + "title": "Research: exclude three eleven-piece P112 beta profiles", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3174" + }, + "reviewed_head": "e38c9cff85f2af817b403291285468ca3899f9c7", + "current_head": "e38c9cff85f2af817b403291285468ca3899f9c7", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-eleven-piece-quotient" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3174", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3175, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "2393963d835a60b8524e986b969c8a87b26a07e3", + "isDraft": false, + "number": 3175, + "title": "Research: exclude four P112 profiles with simplex support budgets", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3175" + }, + "reviewed_head": "2393963d835a60b8524e986b969c8a87b26a07e3", + "current_head": "2393963d835a60b8524e986b969c8a87b26a07e3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-simplex-support-budget" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3175", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3176, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1111a074414c4d2be8b4e230133d873432780814", + "isDraft": false, + "number": 3176, + "title": "Research: exclude the P112 support-72 mixed-edge profile", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3176" + }, + "reviewed_head": "1111a074414c4d2be8b4e230133d873432780814", + "current_head": "1111a074414c4d2be8b4e230133d873432780814", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-mixed-edge-simplex" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3176", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3177, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "47558b8d6e296b15496edd19dbf3fb0f5f9f6ed5", + "isDraft": false, + "number": 3177, + "title": "Research: exclude P112 2,4,5^9 by D7 support saturation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3177" + }, + "reviewed_head": "47558b8d6e296b15496edd19dbf3fb0f5f9f6ed5", + "current_head": "47558b8d6e296b15496edd19dbf3fb0f5f9f6ed5", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-d7-saturation" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3177", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3179, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "27c4c1d4a9f752fe732e0a82bcadac89f770056a", + "isDraft": false, + "number": 3179, + "title": "Research: exclude the P112 eight-vertex support-union profile", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3179" + }, + "reviewed_head": "27c4c1d4a9f752fe732e0a82bcadac89f770056a", + "current_head": "27c4c1d4a9f752fe732e0a82bcadac89f770056a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-eight-vertex-union" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3179", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3180, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "595a78f7925c8802f764792098806ebfbff1f27a", + "isDraft": false, + "number": 3180, + "title": "Research: exclude P112 4,5^2,6^8 by weighted flat pairs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3180" + }, + "reviewed_head": "595a78f7925c8802f764792098806ebfbff1f27a", + "current_head": "595a78f7925c8802f764792098806ebfbff1f27a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-weighted-flat-pair" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3180", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3181, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "80fc72d14546088e9fce3c06dc12bc67270da0af", + "isDraft": false, + "number": 3181, + "title": "research: QQ16 52-bit interior dynamic-range collapse, backward adjoint ledger, and dyadic grid exactness", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3181" + }, + "reviewed_head": "80fc72d14546088e9fce3c06dc12bc67270da0af", + "current_head": "80fc72d14546088e9fce3c06dc12bc67270da0af", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "PR3189 identifies missing child-error columns in the grid-exactness argument: projected backward guard is 18, not 17. Revise the approximate-child lattice hypothesis and resulting precision claim; ideal-input arithmetic alone does not establish exact subsequent half-ADDs.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3182, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "ad848966cd62e13de5ad8d4b5169c221d74d2fcd", + "isDraft": false, + "number": 3182, + "title": "research: P104 pooled 2,309-edge 1-hop obstruction, PR3124 cycle refutation, and 9-stage consumer bill", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3182" + }, + "reviewed_head": "ad848966cd62e13de5ad8d4b5169c221d74d2fcd", + "current_head": "ad848966cd62e13de5ad8d4b5169c221d74d2fcd", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-pooled-onehop-and-physical-consumer-bill" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3182", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3183, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "2a20f0a508c833825a67188c5233ce222c079a19", + "isDraft": false, + "number": 3183, + "title": "research: R439 sub-10k six-way composition (9,974 ADDs), whole-A star duals, and UT4/dyadic floors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3183" + }, + "reviewed_head": "2a20f0a508c833825a67188c5233ce222c079a19", + "current_head": "2a20f0a508c833825a67188c5233ce222c079a19", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/r439-sub10k-sixway-and-star-dual-witnesses" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3183", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3184, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNjU5ODM5", + "is_bot": false, + "login": "rohanarun", + "name": "" + }, + "headRefOid": "6faefe19f592220c16722a6682c22c8fbccd4bb4", + "isDraft": false, + "number": 3184, + "title": "Conditional κ = 0.001730189061233850760095: idle rank-48 star exchanges on #3148's T740 fill (+4.12e-7)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3184" + }, + "reviewed_head": "6faefe19f592220c16722a6682c22c8fbccd4bb4", + "current_head": "6faefe19f592220c16722a6682c22c8fbccd4bb4", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "PR3187 supplies an exact physical-stream operator counterexample to the first committed idle-star move. Commutation and preserved axis multisets do not establish the needed intertwining identity. Repair the operator proof/candidate and replay the complete overlay-aware construction before claiming this kappa. Revised metadata and optional fill discovery do not repair the operator identity.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-tail-20261017.json" + ] + }, + { + "number": 3185, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "f4fa017730cb3d9978c31b3fe57a751fc15b505a", + "isDraft": false, + "number": 3185, + "title": "Research: prove the sharp fifteen-line P112 two-six-flat cover floor", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3185" + }, + "reviewed_head": "f4fa017730cb3d9978c31b3fe57a751fc15b505a", + "current_head": "f4fa017730cb3d9978c31b3fe57a751fc15b505a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-two-six-flat-cover" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3185", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3186, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "92675b36a8e0ea41b40f0bcda2a3dd9f313abb0e", + "isDraft": false, + "number": 3186, + "title": "Research: exclude P112 3,4,6^8 with a weighted A6 cover", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3186" + }, + "reviewed_head": "92675b36a8e0ea41b40f0bcda2a3dd9f313abb0e", + "current_head": "92675b36a8e0ea41b40f0bcda2a3dd9f313abb0e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-a6-weighted-cover" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3186", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3187, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "85cc6be02f5f912ac203449e06523ad53e6054d2", + "isDraft": false, + "number": 3187, + "title": "Research: certify the current idle-star physical counterexample", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3187" + }, + "reviewed_head": "85cc6be02f5f912ac203449e06523ad53e6054d2", + "current_head": "85cc6be02f5f912ac203449e06523ad53e6054d2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-idle-star-stream-obstruction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3187", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3188, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "93f1fb95a2ab1413b2e9c90a6be4f3a2c4090034", + "isDraft": false, + "number": 3188, + "title": "Research: exclude P112 2,3,4^4,6^5 with a six-vertex budget", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3188" + }, + "reviewed_head": "93f1fb95a2ab1413b2e9c90a6be4f3a2c4090034", + "current_head": "93f1fb95a2ab1413b2e9c90a6be4f3a2c4090034", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-six-vertex-budget" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3188", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3189, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "70537595e46444c8a63455523d9851a5efe55385", + "isDraft": false, + "number": 3189, + "title": "Audit QQ16 child-error grid closure and certify sharp projected guards", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3189" + }, + "reviewed_head": "70537595e46444c8a63455523d9851a5efe55385", + "current_head": "70537595e46444c8a63455523d9851a5efe55385", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-noise-lattice-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3189", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3190, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNjU5ODM5", + "is_bot": false, + "login": "rohanarun", + "name": "" + }, + "headRefOid": "5e4a3235169edddd033889da4e9f47635ff50c3e", + "isDraft": false, + "number": 3190, + "title": "Conditional κ = 0.001733427039589844234749 (bit-bound): idle-remainder donors on #3148's T740 fill (+3.24e-6 over #3184)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3190" + }, + "reviewed_head": "5e4a3235169edddd033889da4e9f47635ff50c3e", + "current_head": "5e4a3235169edddd033889da4e9f47635ff50c3e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Inherits the idle-transfer soundness gap identified for PR3184 by PR3187, and adds hosted-remainder donors without a controller argument. Establish the physical intertwining identity for the actual new moves, hosted correctness, bit-binding outer branch and complete replay; histogram/root arithmetic is insufficient.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ] + }, + { + "number": 3192, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "79864770165fe0d7b72c864be4d5a6e2af5e35b5", + "isDraft": false, + "number": 3192, + "title": "Research: exclude P112 5,6^8 with an affine cover transfer", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3192" + }, + "reviewed_head": "79864770165fe0d7b72c864be4d5a6e2af5e35b5", + "current_head": "79864770165fe0d7b72c864be4d5a6e2af5e35b5", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-a6-five-flat" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3192", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3193, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "a8eec63ecb495b2969d4962b4d4d1a35706b8cb2", + "isDraft": false, + "number": 3193, + "title": "Research: exclude P112 2,3,4,6^8 with a common-cut span bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3193" + }, + "reviewed_head": "a8eec63ecb495b2969d4962b4d4d1a35706b8cb2", + "current_head": "a8eec63ecb495b2969d4962b4d4d1a35706b8cb2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-common-fourteen-cut" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3193", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3194, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "080309ba9e29449ea4f29971e0ce1d9278703350", + "isDraft": false, + "number": 3194, + "title": "Prove native F2 innovation beyond the earlier centre history", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3194" + }, + "reviewed_head": "080309ba9e29449ea4f29971e0ce1d9278703350", + "current_head": "080309ba9e29449ea4f29971e0ce1d9278703350", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/centre-history-innovation" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3194", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3195, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "22f1479db213b1ed0de68cbc61ba15f6352d3276", + "isDraft": false, + "number": 3195, + "title": "Research: exclude P112 5,5,6^6,7 by deleting one piece", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3195" + }, + "reviewed_head": "22f1479db213b1ed0de68cbc61ba15f6352d3276", + "current_head": "22f1479db213b1ed0de68cbc61ba15f6352d3276", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-five-five-slice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3195", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3196, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "ac3c90fb09a15c509c5d693f6bc24ec03574afc6", + "isDraft": false, + "number": 3196, + "title": "Audit paired idle-axis transfers across T740 ports", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3196" + }, + "reviewed_head": "ac3c90fb09a15c509c5d693f6bc24ec03574afc6", + "current_head": "ac3c90fb09a15c509c5d693f6bc24ec03574afc6", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/idle-star-paired-axis-census" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-catchup-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3196", + "merge_commit": "7db27e8fe131323b945633ca5731885c74d387c6" + } + }, + { + "number": 3197, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "3949cc17a4fa4f108a044f532a5d58323c6cb6d2", + "isDraft": false, + "number": 3197, + "title": "Research: exclude P112 4^3,6^6,7 by deleting one piece", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3197" + }, + "reviewed_head": "3949cc17a4fa4f108a044f532a5d58323c6cb6d2", + "current_head": "3949cc17a4fa4f108a044f532a5d58323c6cb6d2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-weight-seven-deletion" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-tail-20261017.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3197", + "merge_commit": "4390d1f8c3a968a44bd15cd3654e7ac0c157ff89" + } + }, + { + "number": 3198, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNjU5ODM5", + "is_bot": false, + "login": "rohanarun", + "name": "" + }, + "headRefOid": "418ea1dc11030a23c1547b4e2b64ef4a46be2881", + "isDraft": false, + "number": 3198, + "title": "Conditional κ = 0.001734770557111513160495: R438 bit supplier with #3190's idle-remainder donors (complex binds again, +0.0775%)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3198" + }, + "reviewed_head": "418ea1dc11030a23c1547b4e2b64ef4a46be2881", + "current_head": "418ea1dc11030a23c1547b4e2b64ef4a46be2881", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "The claimed saving reuses idle-axis moves challenged by exact physical-operator counterexamples in PR3296 (and PR3263 for PR3251). The committed move sets must satisfy the full stream operator identity, beyond rank/commutation/multiset tests. Repair or explicitly withdraw the admissible-kappa claim and supply the overlay-aware native/controller/outer evidence. No improved kappa admitted.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3199, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "d138f8329e8c5aac9f61a071b5e21e1d49f04331", + "isDraft": false, + "number": 3199, + "title": "Source-bound OR-Tools screen for T740 idle-axis reassignment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3199" + }, + "reviewed_head": "d138f8329e8c5aac9f61a071b5e21e1d49f04331", + "current_head": "d138f8329e8c5aac9f61a071b5e21e1d49f04331", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/d138f8329e8c5aac9f61a071b5e21e1d49f04331" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Complete original version retained in Git ancestry; existing main-tree package unchanged. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3200, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNjU5ODM5", + "is_bot": false, + "login": "rohanarun", + "name": "" + }, + "headRefOid": "f09e5b25381393c604082e58fbe56896b13171b5", + "isDraft": false, + "number": 3200, + "title": "Conditional κ = 0.001734807021726127552033: greedy idle-axis phase on #3198 with the R438 bit supplier (+0.0021%)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3200" + }, + "reviewed_head": "f09e5b25381393c604082e58fbe56896b13171b5", + "current_head": "f09e5b25381393c604082e58fbe56896b13171b5", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "The claimed saving reuses idle-axis moves challenged by exact physical-operator counterexamples in PR3296 (and PR3263 for PR3251). The committed move sets must satisfy the full stream operator identity, beyond rank/commutation/multiset tests. Repair or explicitly withdraw the admissible-kappa claim and supply the overlay-aware native/controller/outer evidence. No improved kappa admitted.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3201, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "c9926e2f4adf2c6adfc2a6dba358b2eff581ab87", + "isDraft": false, + "number": 3201, + "title": "research: exclude two P112 profiles with unequal endpoints", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3201" + }, + "reviewed_head": "c9926e2f4adf2c6adfc2a6dba358b2eff581ab87", + "current_head": "c9926e2f4adf2c6adfc2a6dba358b2eff581ab87", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-unequal-endpoint-deletion" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3202, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU4OTI5Nzgw", + "is_bot": false, + "login": "24kHandsome1201", + "name": "" + }, + "headRefOid": "259043321323717b7e816d6be38ad5e1f0b69b4c", + "isDraft": false, + "number": 3202, + "title": "Independently verify PR3044 R2 native slice and residual wrappers", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3202" + }, + "reviewed_head": "259043321323717b7e816d6be38ad5e1f0b69b4c", + "current_head": "259043321323717b7e816d6be38ad5e1f0b69b4c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/pr3044-r2-native-slice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3203, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "f7951d9ca99feb1e54660dbe239941f6187948b1", + "isDraft": false, + "number": 3203, + "title": "Prove A5 shortening and exclude P112 2,5^2,6^6,7", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3203" + }, + "reviewed_head": "f7951d9ca99feb1e54660dbe239941f6187948b1", + "current_head": "f7951d9ca99feb1e54660dbe239941f6187948b1", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a5-shortening" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3204, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "c057c0ce37cbb68cb492d8f24909deefa94f9e1b", + "isDraft": false, + "number": 3204, + "title": "Research: prove four-site idle-rank rigidity under the fixed schedule", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3204" + }, + "reviewed_head": "c057c0ce37cbb68cb492d8f24909deefa94f9e1b", + "current_head": "c057c0ce37cbb68cb492d8f24909deefa94f9e1b", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/idle-four-site-rigidity" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3205, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "49d26a7604686aa77cf88d7280b2e313cb4882f6", + "isDraft": false, + "number": 3205, + "title": "Prove P112 shortening with thirty common coordinates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3205" + }, + "reviewed_head": "49d26a7604686aa77cf88d7280b2e313cb4882f6", + "current_head": "49d26a7604686aa77cf88d7280b2e313cb4882f6", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-support30-shortening" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3206, + "metadata": { + "author": { + "id": "U_kgDOB5L2iw", + "is_bot": false, + "login": "theon199", + "name": "Sricharan Vagvala" + }, + "headRefOid": "e531d4303e31e81b1f4a756d6e00983d9b1f9bf7", + "isDraft": false, + "number": 3206, + "title": "Research: bound two-role extension-field calls with one relation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3206" + }, + "reviewed_head": "e531d4303e31e81b1f4a756d6e00983d9b1f9bf7", + "current_head": "e531d4303e31e81b1f4a756d6e00983d9b1f9bf7", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/bit-extension-one-relation-seed17" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3207, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "d4bf10f9b8c61d1d2b05bad59c86f0b08076a616", + "isDraft": false, + "number": 3207, + "title": "Replace the P112 A5 frame census with a Parseval proof", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3207" + }, + "reviewed_head": "d4bf10f9b8c61d1d2b05bad59c86f0b08076a616", + "current_head": "d4bf10f9b8c61d1d2b05bad59c86f0b08076a616", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-orthogonal-shortening" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3208, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU4OTI5Nzgw", + "is_bot": false, + "login": "24kHandsome1201", + "name": "" + }, + "headRefOid": "87d63a82defff1ffeea173743106fb97903cbbd6", + "isDraft": false, + "number": 3208, + "title": "Verify R2 native cleanup and all 91 private zero returns", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3208" + }, + "reviewed_head": "87d63a82defff1ffeea173743106fb97903cbbd6", + "current_head": "87d63a82defff1ffeea173743106fb97903cbbd6", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/pr3044-native-cleanup" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3209, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "8c62e5f52f1d172bb8c95e795449205015bb5143", + "isDraft": false, + "number": 3209, + "title": "Reuse JSON parses in the complete T16 boundary audit", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3209" + }, + "reviewed_head": "8c62e5f52f1d172bb8c95e795449205015bb5143", + "current_head": "8c62e5f52f1d172bb8c95e795449205015bb5143", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/t16-invoice-read-cache" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3210, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "246c7ae12f3f103b05ed80fad0e2a9edde01c3f8", + "isDraft": false, + "number": 3210, + "title": "Research: audit native acceptance of odd scatter multiplicities (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3210" + }, + "reviewed_head": "246c7ae12f3f103b05ed80fad0e2a9edde01c3f8", + "current_head": "246c7ae12f3f103b05ed80fad0e2a9edde01c3f8", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/scatter-odd-native-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3211, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "66ce40a4bf1c82a0e8b6e94067dc0ab2fbb4c008", + "isDraft": false, + "number": 3211, + "title": "Exclude two P112 profiles by five-endpoint A4 shortening", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3211" + }, + "reviewed_head": "66ce40a4bf1c82a0e8b6e94067dc0ab2fbb4c008", + "current_head": "66ce40a4bf1c82a0e8b6e94067dc0ab2fbb4c008", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a4-shortening" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3212, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4e31290dd10cbc443df8c7b9b1f66b82a4214bb4", + "isDraft": false, + "number": 3212, + "title": "Prove the P112 support-thirty shortening contract is sharp", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3212" + }, + "reviewed_head": "4e31290dd10cbc443df8c7b9b1f66b82a4214bb4", + "current_head": "4e31290dd10cbc443df8c7b9b1f66b82a4214bb4", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-support31-sharpness" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3213, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "941810a486b6f6b4701194fcf5aead6fbaa74d24", + "isDraft": false, + "number": 3213, + "title": "Research: obstruct two simple orders for the coupled T20 packing cap", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3213" + }, + "reviewed_head": "941810a486b6f6b4701194fcf5aead6fbaa74d24", + "current_head": "941810a486b6f6b4701194fcf5aead6fbaa74d24", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/coupled-t20-window-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3214, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "faa6323371db1c5fbb43ab04c6e00715d2328bc6", + "isDraft": false, + "number": 3214, + "title": "Research: audit PR #3182's P104 output support and secondary-cycle binding", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3214" + }, + "reviewed_head": "faa6323371db1c5fbb43ab04c6e00715d2328bc6", + "current_head": "faa6323371db1c5fbb43ab04c6e00715d2328bc6", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p104-support-propagation-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3215, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "00b4f73cd0ea0ea7639288d3bdb59010fa66c299", + "isDraft": false, + "number": 3215, + "title": "Research: audit PR #2542's set/word pruning and refute its minimum-length degree-filter justification", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3215" + }, + "reviewed_head": "00b4f73cd0ea0ea7639288d3bdb59010fa66c299", + "current_head": "00b4f73cd0ea0ea7639288d3bdb59010fa66c299", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/f7-set-word-pruning-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3216, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "af5b2ff1c0afa3100c961fa11b4d6e1fe18714cb", + "isDraft": false, + "number": 3216, + "title": "Research: PR #3189's eighteenth-position QQ16 error witness survives the local native core", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3216" + }, + "reviewed_head": "af5b2ff1c0afa3100c961fa11b4d6e1fe18714cb", + "current_head": "af5b2ff1c0afa3100c961fa11b4d6e1fe18714cb", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/qq16-native-noise-lift" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3217, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b6176a63cd6e9721103646c0cdb0f219f8e21336", + "isDraft": false, + "number": 3217, + "title": "Prove sharp support28 five-endpoint P112 shortening", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3217" + }, + "reviewed_head": "b6176a63cd6e9721103646c0cdb0f219f8e21336", + "current_head": "b6176a63cd6e9721103646c0cdb0f219f8e21336", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a4-orthogonal-threshold" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3218, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "a93c4f0bfcac21bf9c62c79728c8936e35ebbc3b", + "isDraft": false, + "number": 3218, + "title": "Tooling: accelerate exact R2 Clifford comparisons with signed Pauli actions", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3218" + }, + "reviewed_head": "a93c4f0bfcac21bf9c62c79728c8936e35ebbc3b", + "current_head": "a93c4f0bfcac21bf9c62c79728c8936e35ebbc3b", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/clifford-pauli-anchor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3219, + "metadata": { + "author": { + "id": "U_kgDOB5L2iw", + "is_bot": false, + "login": "theon199", + "name": "Sricharan Vagvala" + }, + "headRefOid": "209d20d9da025c90110465f9a1f18186a6160147", + "isDraft": false, + "number": 3219, + "title": "Tooling: accelerate exact seven-owner Fano replay with row tables", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3219" + }, + "reviewed_head": "209d20d9da025c90110465f9a1f18186a6160147", + "current_head": "209d20d9da025c90110465f9a1f18186a6160147", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/fano-census-row-tables" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3220, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "4aa4bd8d53a2bb80fa0c7d6f634c078b33965113", + "isDraft": false, + "number": 3220, + "title": "Research: bound additive idle-axis repair costs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3220" + }, + "reviewed_head": "4aa4bd8d53a2bb80fa0c7d6f634c078b33965113", + "current_head": "4aa4bd8d53a2bb80fa0c7d6f634c078b33965113", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/idle-additive-repair-budget" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3221, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "abfbfefa3e66168f15c5b7415c3aab29d09c59a5", + "isDraft": false, + "number": 3221, + "title": "Prove rank-six A3 shortening and exclude a P112 profile", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3221" + }, + "reviewed_head": "abfbfefa3e66168f15c5b7415c3aab29d09c59a5", + "current_head": "abfbfefa3e66168f15c5b7415c3aab29d09c59a5", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a3-rank-six-shortening" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3222, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "0438cf1edcda3f68dfae345db87d4d690ab95efa", + "isDraft": false, + "number": 3222, + "title": "Research: audit PR #3128's retained aliases across scatter guards and native COPY counts (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3222" + }, + "reviewed_head": "0438cf1edcda3f68dfae345db87d4d690ab95efa", + "current_head": "0438cf1edcda3f68dfae345db87d4d690ab95efa", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/scatter-alias-native-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3223, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "b3e192fa4e11555cad1cf9914f6632ad66531ccd", + "isDraft": false, + "number": 3223, + "title": "Research: audit PR #2809's NODE stock, peel and owned return against PR #2753's logical node", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3223" + }, + "reviewed_head": "b3e192fa4e11555cad1cf9914f6632ad66531ccd", + "current_head": "b3e192fa4e11555cad1cf9914f6632ad66531ccd", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/selected-node-stock-refinement" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3224, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "69567e40e8d92542248eda0d6a400d83adc1d3a3", + "isDraft": false, + "number": 3224, + "title": "Research: audit connector-covering-code's parity-capacity filter and its simple-word boundary", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3224" + }, + "reviewed_head": "69567e40e8d92542248eda0d6a400d83adc1d3a3", + "current_head": "69567e40e8d92542248eda0d6a400d83adc1d3a3", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/connector-capacity-parity-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3225, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "76fad3fe9276796949f769e54eeefdd185f28f4f", + "isDraft": false, + "number": 3225, + "title": "Research: independently certify the helper-13 cut for PR #3124's P104 matching", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3225" + }, + "reviewed_head": "76fad3fe9276796949f769e54eeefdd185f28f4f", + "current_head": "76fad3fe9276796949f769e54eeefdd185f28f4f", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p104-moved-helper-cut" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3226, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "6b17b9b7c76d60726bd87123b9bf9905aa3151dd", + "isDraft": false, + "number": 3226, + "title": "Research: a sufficient exact grid for the finite QQ16 F0 native reference", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3226" + }, + "reviewed_head": "6b17b9b7c76d60726bd87123b9bf9905aa3151dd", + "current_head": "6b17b9b7c76d60726bd87123b9bf9905aa3151dd", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/qq16-native-grid-envelope" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3227, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "dea1160da81edfc3edf5204e70a895475c256454", + "isDraft": false, + "number": 3227, + "title": "research: exclude P112 profile 2^2,6^5,7^3 by A3 binary closure", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3227" + }, + "reviewed_head": "dea1160da81edfc3edf5204e70a895475c256454", + "current_head": "dea1160da81edfc3edf5204e70a895475c256454", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a3-six-flat" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3228, + "metadata": { + "author": { + "id": "U_kgDOB5L2iw", + "is_bot": false, + "login": "theon199", + "name": "Sricharan Vagvala" + }, + "headRefOid": "0895ada2cef723e05a12d492faa673b087a3655e", + "isDraft": false, + "number": 3228, + "title": "Independent verification: separate all five rank-7 frame groups", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3228" + }, + "reviewed_head": "0895ada2cef723e05a12d492faa673b087a3655e", + "current_head": "0895ada2cef723e05a12d492faa673b087a3655e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-group-interactions" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3229, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "8ec29a31efaaa99b4f7823c2d9db2142a4c810c3", + "isDraft": false, + "number": 3229, + "title": "Bound shared phase-repair rank for independent groups", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3229" + }, + "reviewed_head": "8ec29a31efaaa99b4f7823c2d9db2142a4c810c3", + "current_head": "8ec29a31efaaa99b4f7823c2d9db2142a4c810c3", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/shared-phase-repair-rank" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3230, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "98fcc78f5d46b18f0342ea13b9ab5a3cfd87d5f0", + "isDraft": false, + "number": 3230, + "title": "Prove the five-line boundary of P112 Lemma N", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3230" + }, + "reviewed_head": "98fcc78f5d46b18f0342ea13b9ab5a3cfd87d5f0", + "current_head": "98fcc78f5d46b18f0342ea13b9ab5a3cfd87d5f0", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-seven-flat-five-line-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3231, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "4b5597cf06496c4541c23cd6d30d6994cc872e8b", + "isDraft": false, + "number": 3231, + "title": "Separate the four V45 widths in the idle histogram", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3231" + }, + "reviewed_head": "4b5597cf06496c4541c23cd6d30d6994cc872e8b", + "current_head": "4b5597cf06496c4541c23cd6d30d6994cc872e8b", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-v45-width-idle" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3232, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "9d75ed2b5bc9bb8cb19f205724f978b02be732cb", + "isDraft": false, + "number": 3232, + "title": "Prove the sharp Gram cost floor on all 23 physical C5s", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3232" + }, + "reviewed_head": "9d75ed2b5bc9bb8cb19f205724f978b02be732cb", + "current_head": "9d75ed2b5bc9bb8cb19f205724f978b02be732cb", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/c5-gram-rank-cover" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3233, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "803f3593e8f00ed8591d5ff6fc69ce2a036a3293", + "isDraft": false, + "number": 3233, + "title": "Research: exact scratch capacity and a complete linear tape bill for PR #2915's ordered high-field ADD", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3233" + }, + "reviewed_head": "803f3593e8f00ed8591d5ff6fc69ce2a036a3293", + "current_head": "803f3593e8f00ed8591d5ff6fc69ce2a036a3293", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/high-add-scratch-invoice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3234, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "7e1de0fd19040f7de20b06a14313e228f9a01280", + "isDraft": false, + "number": 3234, + "title": "Prove sharp support29 rank-six P112 A3 shortening", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3234" + }, + "reviewed_head": "7e1de0fd19040f7de20b06a14313e228f9a01280", + "current_head": "7e1de0fd19040f7de20b06a14313e228f9a01280", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a3-support29" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3235, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "fafe9cc1af84bb10b6113c88b3fb36c11fc5a1fc", + "isDraft": false, + "number": 3235, + "title": "Research: bound rounded QQ16 producer errors with bounded dirty helpers", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3235" + }, + "reviewed_head": "fafe9cc1af84bb10b6113c88b3fb36c11fc5a1fc", + "current_head": "fafe9cc1af84bb10b6113c88b3fb36c11fc5a1fc", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/qq16-rounded-producer-envelope" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3236, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "63bb8c58175ef6d97c4dd6407f0802d5f6ed4e54", + "isDraft": false, + "number": 3236, + "title": "Research: audit PR #2979's group-A native paths and their binding to the T74 invoice (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3236" + }, + "reviewed_head": "63bb8c58175ef6d97c4dd6407f0802d5f6ed4e54", + "current_head": "63bb8c58175ef6d97c4dd6407f0802d5f6ed4e54", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-group-a-entrance-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3237, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "9881b9d5dfe20017503c8d14baaae8629c5afb10", + "isDraft": false, + "number": 3237, + "title": "Research: certify PR #2979's V45 final-word controls fail the complete packing budget", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3237" + }, + "reviewed_head": "9881b9d5dfe20017503c8d14baaae8629c5afb10", + "current_head": "9881b9d5dfe20017503c8d14baaae8629c5afb10", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-final-fill-controls" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3238, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "3c689aac34ff240f82e27dcc7f0247b96b8676af", + "isDraft": false, + "number": 3238, + "title": "Research: audit all PR #2979 private frees and their expanded native dependencies", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3238" + }, + "reviewed_head": "3c689aac34ff240f82e27dcc7f0247b96b8676af", + "current_head": "3c689aac34ff240f82e27dcc7f0247b96b8676af", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-peer-private-free-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3239, + "metadata": { + "author": { + "id": "U_kgDOB5L2iw", + "is_bot": false, + "login": "theon199", + "name": "Sricharan Vagvala" + }, + "headRefOid": "cab1904334910d1c8a7cffd0f33d18fd02f70a58", + "isDraft": false, + "number": 3239, + "title": "Research audit: preserve route width through binary/radix conversion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3239" + }, + "reviewed_head": "cab1904334910d1c8a7cffd0f33d18fd02f70a58", + "current_head": "cab1904334910d1c8a7cffd0f33d18fd02f70a58", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/qadic-route-cutoff-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3240, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "9f32d16ea188cfba57f6c0d570377be9becb857f", + "isDraft": false, + "number": 3240, + "title": "Tooling: make the complete R2 audit 5.37x faster with mutation-path copies", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3240" + }, + "reviewed_head": "9f32d16ea188cfba57f6c0d570377be9becb857f", + "current_head": "9f32d16ea188cfba57f6c0d570377be9becb857f", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/r2-mutation-path-copy" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3241, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "8a6935257901d1988dfa85bc94d8bc5aa6161f65", + "isDraft": false, + "number": 3241, + "title": "Price local tape access for paired Gaussian SCALE", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3241" + }, + "reviewed_head": "8a6935257901d1988dfa85bc94d8bc5aa6161f65", + "current_head": "8a6935257901d1988dfa85bc94d8bc5aa6161f65", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-paired-scale-routing" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3242, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "f3c7e5229d1ce856fe3d6fa5467b10679c0fda14", + "isDraft": false, + "number": 3242, + "title": "Record that the channel touches every target before every source", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3242" + }, + "reviewed_head": "f3c7e5229d1ce856fe3d6fa5467b10679c0fda14", + "current_head": "f3c7e5229d1ce856fe3d6fa5467b10679c0fda14", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p104-flag-channel-schedule" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3243, + "metadata": { + "author": { + "id": "U_kgDOC-l38Q", + "is_bot": false, + "login": "commdata2338", + "name": "" + }, + "headRefOid": "993e2d4ba993d9818c6d7c5ae1e35980d1ab3ebb", + "isDraft": false, + "number": 3243, + "title": "Research: independently audit PR #3131's first paired P104 collector at tensor multiplicity two", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3243" + }, + "reviewed_head": "993e2d4ba993d9818c6d7c5ae1e35980d1ab3ebb", + "current_head": "993e2d4ba993d9818c6d7c5ae1e35980d1ab3ebb", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p104-tensor-collector-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3244, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "5964d7f22ad9cd9c27a1d2eb0b897f52b9425a13", + "isDraft": false, + "number": 3244, + "title": "Research: audit singleton connector path-domain propagation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3244" + }, + "reviewed_head": "5964d7f22ad9cd9c27a1d2eb0b897f52b9425a13", + "current_head": "5964d7f22ad9cd9c27a1d2eb0b897f52b9425a13", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/connector-path-propagation-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3245, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "171c95e2940341e56377d655a162635fa3caedfa", + "isDraft": false, + "number": 3245, + "title": "Prove dirty-private identity for PR2979's isolated cleanup", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3245" + }, + "reviewed_head": "171c95e2940341e56377d655a162635fa3caedfa", + "current_head": "171c95e2940341e56377d655a162635fa3caedfa", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-cleanup-dirty-identity" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3246, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4b9a993d90f2b49d9217ab46cb6daaba194b53f4", + "isDraft": false, + "number": 3246, + "title": "Research: prove one-factor stock for recursive NODE guards", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3246" + }, + "reviewed_head": "4b9a993d90f2b49d9217ab46cb6daaba194b53f4", + "current_head": "4b9a993d90f2b49d9217ab46cb6daaba194b53f4", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/selected-runtime-guard-stock" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3247, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "ca678025223f6c957efacbcb1254109d3881b4ff", + "isDraft": false, + "number": 3247, + "title": "Exclude P112 TWOSIDE profile 2,3,6^5,7^4 via A3 shortening", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3247" + }, + "reviewed_head": "ca678025223f6c957efacbcb1254109d3881b4ff", + "current_head": "ca678025223f6c957efacbcb1254109d3881b4ff", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-twoside-a3-application" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3248, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "96e3ccd00c62f73d30a23f8d774eea59bfe3b97c", + "isDraft": false, + "number": 3248, + "title": "Prove the sharp five-term asymmetric C5 decoder cost", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3248" + }, + "reviewed_head": "96e3ccd00c62f73d30a23f8d774eea59bfe3b97c", + "current_head": "96e3ccd00c62f73d30a23f8d774eea59bfe3b97c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/c5-rank-tight-asymmetric" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3249, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "22c7bf316d55e59f381cc9ba833afccc7702fd58", + "isDraft": false, + "number": 3249, + "title": "Research: prove P112 rank-five shortening through common support 44", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3249" + }, + "reviewed_head": "22c7bf316d55e59f381cc9ba833afccc7702fd58", + "current_head": "22c7bf316d55e59f381cc9ba833afccc7702fd58", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a2-rank5-shortening" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3250, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "02ff0bb88a2e808bb07c75722f3595861ce2b20d", + "isDraft": false, + "number": 3250, + "title": "Research: finite QQ16 child and rounded half-add contract", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3250" + }, + "reviewed_head": "02ff0bb88a2e808bb07c75722f3595861ce2b20d", + "current_head": "02ff0bb88a2e808bb07c75722f3595861ce2b20d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/qq16-finite-child-halfadd" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3251, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNjU5ODM5", + "is_bot": false, + "login": "rohanarun", + "name": "" + }, + "headRefOid": "d7d6254416f0b3ffe659079cca42fd152df63a36", + "isDraft": false, + "number": 3251, + "title": "Conditional κ = 0.001734815770385098563484: exact per-group idle-donor search on #3200 (+8.75e-9)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3251" + }, + "reviewed_head": "d7d6254416f0b3ffe659079cca42fd152df63a36", + "current_head": "d7d6254416f0b3ffe659079cca42fd152df63a36", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "The claimed saving reuses idle-axis moves challenged by exact physical-operator counterexamples in PR3296 (and PR3263 for PR3251). The committed move sets must satisfy the full stream operator identity, beyond rank/commutation/multiset tests. Repair or explicitly withdraw the admissible-kappa claim and supply the overlay-aware native/controller/outer evidence. No improved kappa admitted.", + "scope": "Changed-head source/integrity triage; no scientific replay. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3252, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4784b71d2e0833537c9ae1e8be05ad2a6b334d92", + "isDraft": false, + "number": 3252, + "title": "Research: prove soundness of repaired P104 memory propagation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3252" + }, + "reviewed_head": "4784b71d2e0833537c9ae1e8be05ad2a6b334d92", + "current_head": "4784b71d2e0833537c9ae1e8be05ad2a6b334d92", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p104-memory-relaxation-soundness" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3253, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "f27442f87cf1fd86a50b8ba15615d8d655d06a85", + "isDraft": false, + "number": 3253, + "title": "Prove the sharp common-five P112 deletion bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3253" + }, + "reviewed_head": "f27442f87cf1fd86a50b8ba15615d8d655d06a85", + "current_head": "f27442f87cf1fd86a50b8ba15615d8d655d06a85", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-common-five-deletion" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3254, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "897bfb42c389d24d2d54a381a216e1f876b42109", + "isDraft": false, + "number": 3254, + "title": "Research: exclude single-child absorption with fixed stream encoders", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3254" + }, + "reviewed_head": "897bfb42c389d24d2d54a381a216e1f876b42109", + "current_head": "897bfb42c389d24d2d54a381a216e1f876b42109", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/idle-single-child-absorption" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3255, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "2977a895c35fa019f53f181edee45177c77ec436", + "isDraft": false, + "number": 3255, + "title": "Research: exclude a P112 profile by three-endpoint A2 shortening", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3255" + }, + "reviewed_head": "2977a895c35fa019f53f181edee45177c77ec436", + "current_head": "2977a895c35fa019f53f181edee45177c77ec436", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a2-singleton-shortening" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3256, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "1ea98246dabb46fc7bedf6127eff63f008414a39", + "isDraft": false, + "number": 3256, + "title": "Prove sharp arbitrary-term asymmetric cost on the named C5 core", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3256" + }, + "reviewed_head": "1ea98246dabb46fc7bedf6127eff63f008414a39", + "current_head": "1ea98246dabb46fc7bedf6127eff63f008414a39", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/c5-asymmetric-cost-floor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3257, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1499da8f88c4d0293fe3ae443d0c7fec80f0e2d7", + "isDraft": false, + "number": 3257, + "title": "Prove P112 rank-five shortening through common support 45", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3257" + }, + "reviewed_head": "1499da8f88c4d0293fe3ae443d0c7fec80f0e2d7", + "current_head": "1499da8f88c4d0293fe3ae443d0c7fec80f0e2d7", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a2-support45" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3258, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4fa77102119e345e02e1e5d3167221e8eb793ff1", + "isDraft": false, + "number": 3258, + "title": "Prove retained-information bounds for a rounded QQ16 child return", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3258" + }, + "reviewed_head": "4fa77102119e345e02e1e5d3167221e8eb793ff1", + "current_head": "4fa77102119e345e02e1e5d3167221e8eb793ff1", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/qq16-rounded-child-inversion" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3259, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b572b0c25569898579041200e95731c5a43c9189", + "isDraft": false, + "number": 3259, + "title": "Independently certify the universal fixed-cover P104 support cut", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3259" + }, + "reviewed_head": "b572b0c25569898579041200e95731c5a43c9189", + "current_head": "b572b0c25569898579041200e95731c5a43c9189", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p104-pooled-cut-independent" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3260, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "cdeee42ba34d4da3db8c2b1fc9cbc134c7172fed", + "isDraft": false, + "number": 3260, + "title": "Exclude a P112 profile by mixed-rank A2 shortening", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3260" + }, + "reviewed_head": "cdeee42ba34d4da3db8c2b1fc9cbc134c7172fed", + "current_head": "cdeee42ba34d4da3db8c2b1fc9cbc134c7172fed", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-mixed-a2-caller" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3261, + "metadata": { + "author": { + "id": "U_kgDOBcp5JQ", + "is_bot": false, + "login": "krzysztofwojt", + "name": "Krzysztof Wójt" + }, + "headRefOid": "aa47cff758c956304327f1fc67dac61e970cfb3d", + "isDraft": false, + "number": 3261, + "title": "Audit complete candidate representation in the seven-source search", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3261" + }, + "reviewed_head": "aa47cff758c956304327f1fc67dac61e970cfb3d", + "current_head": "aa47cff758c956304327f1fc67dac61e970cfb3d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/connector-domain-completeness" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Schedule any complete replay separately. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and explicit ten-minute limits. No dispatch. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3262, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "f7af207c5e8eabc4524448a0f7c6f77a03c059ba", + "isDraft": false, + "number": 3262, + "title": "Prove sharp support29 P112 shortening for three rank-six endpoints", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3262" + }, + "reviewed_head": "f7af207c5e8eabc4524448a0f7c6f77a03c059ba", + "current_head": "f7af207c5e8eabc4524448a0f7c6f77a03c059ba", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-a2-rank6-sharp-shortening" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3263, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "91faeaa09667bf20fd2ba6307a173400e8ad876a", + "isDraft": false, + "number": 3263, + "title": "Reject two T740 axis-search candidates on exact operator replay", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3263" + }, + "reviewed_head": "91faeaa09667bf20fd2ba6307a173400e8ad876a", + "current_head": "91faeaa09667bf20fd2ba6307a173400e8ad876a", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/source-archives", + "research/t740-joint-axis-optimization" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3264, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "e82c9ea7208fd7f4b40d565206f490ca22972746", + "isDraft": false, + "number": 3264, + "title": "Research: connect one-factor stock to the ordinary recursive backend", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3264" + }, + "reviewed_head": "e82c9ea7208fd7f4b40d565206f490ca22972746", + "current_head": "e82c9ea7208fd7f4b40d565206f490ca22972746", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/ordinary-one-factor-stock" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3265, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "ac651ec18e62edf0baf3846cc4bf0a11d335c2b4", + "isDraft": false, + "number": 3265, + "title": "Account for high-route encoded setup and payload ownership", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3265" + }, + "reviewed_head": "ac651ec18e62edf0baf3846cc4bf0a11d335c2b4", + "current_head": "ac651ec18e62edf0baf3846cc4bf0a11d335c2b4", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/high-route-setup-invoice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3266, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "3c4e9dc1a3f1b722bd0db867ecfba17d746816d8", + "isDraft": false, + "number": 3266, + "title": "Prove P112 rank-five shortening through common support 46", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3266" + }, + "reviewed_head": "3c4e9dc1a3f1b722bd0db867ecfba17d746816d8", + "current_head": "3c4e9dc1a3f1b722bd0db867ecfba17d746816d8", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-rank5-support46" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3267, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "008f042859a5183d1323228a68aa1038f8d7718a", + "isDraft": false, + "number": 3267, + "title": "Prove P112 mixed-rank shortening through common support 38", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3267" + }, + "reviewed_head": "008f042859a5183d1323228a68aa1038f8d7718a", + "current_head": "008f042859a5183d1323228a68aa1038f8d7718a", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-mixed-support38" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3268, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "ee5d4f466e6e44a1897896324a36aa4c64cf3912", + "isDraft": false, + "number": 3268, + "title": "Prove arbitrary-term asymmetric cost20 on 18 physical C5 cores", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3268" + }, + "reviewed_head": "ee5d4f466e6e44a1897896324a36aa4c64cf3912", + "current_head": "ee5d4f466e6e44a1897896324a36aa4c64cf3912", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/c5-asymmetric-physical-cores" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3269, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "ebe02d33157dc6c6d3b35df204e4a39242b7429e", + "isDraft": false, + "number": 3269, + "title": "Prove analytic E8 binary-support capacities 12 and 20", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3269" + }, + "reviewed_head": "ebe02d33157dc6c6d3b35df204e4a39242b7429e", + "current_head": "ebe02d33157dc6c6d3b35df204e4a39242b7429e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/e8-quadratic-support-capacity" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3270, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4a83f89c3865d21521b4a72bb71e3a23c3aadbb7", + "isDraft": false, + "number": 3270, + "title": "Certify a one-layer full-cover QQ16 F0-to-B1 exact grid", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3270" + }, + "reviewed_head": "4a83f89c3865d21521b4a72bb71e3a23c3aadbb7", + "current_head": "4a83f89c3865d21521b4a72bb71e3a23c3aadbb7", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/qq16-f0-b1-exact-grid" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3271, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1bbe044ba2c7187dba149e40734179b2a1ebba84", + "isDraft": false, + "number": 3271, + "title": "Prove sharp arbitrary-term cost 20 on one residual physical C5", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3271" + }, + "reviewed_head": "1bbe044ba2c7187dba149e40734179b2a1ebba84", + "current_head": "1bbe044ba2c7187dba149e40734179b2a1ebba84", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/c5-residual-weighted-cover" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3272, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "2d349d6b8c26c308665f85222b447da07271e026", + "isDraft": false, + "number": 3272, + "title": "Prove one-donor T740 operator and residual-rank rigidity", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3272" + }, + "reviewed_head": "2d349d6b8c26c308665f85222b447da07271e026", + "current_head": "2d349d6b8c26c308665f85222b447da07271e026", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/t740-one-donor-operator" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3273, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "2e0408a03e770c85a7e59b9ade547dcbbaea7e73", + "isDraft": false, + "number": 3273, + "title": "Repair scatter export with a versioned XOR-normalized boundary", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3273" + }, + "reviewed_head": "2e0408a03e770c85a7e59b9ade547dcbbaea7e73", + "current_head": "2e0408a03e770c85a7e59b9ade547dcbbaea7e73", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/xor-scatter-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3274, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "78c83cdcc431e7301be33af4bbe3bab2be3021d8", + "isDraft": false, + "number": 3274, + "title": "Prove a sharp two-occurrence terminal-widening budget bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3274" + }, + "reviewed_head": "78c83cdcc431e7301be33af4bbe3bab2be3021d8", + "current_head": "78c83cdcc431e7301be33af4bbe3bab2be3021d8", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-all-terminal-sensitivity" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3275, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "74d54090585e4b2c6d648be30f4ac0e8e4466c67", + "isDraft": false, + "number": 3275, + "title": "Research: exclude character-controlled one-child idle-phase repair", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3275" + }, + "reviewed_head": "74d54090585e4b2c6d648be30f4ac0e8e4466c67", + "current_head": "74d54090585e4b2c6d648be30f4ac0e8e4466c67", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/idle-character-controlled-absorption" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3276, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b7b576c0fc8bf016d67af7f3fa6a4927bc2b1df8", + "isDraft": false, + "number": 3276, + "title": "Audit seven-source search completeness and interruption", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3276" + }, + "reviewed_head": "b7b576c0fc8bf016d67af7f3fa6a4927bc2b1df8", + "current_head": "b7b576c0fc8bf016d67af7f3fa6a4927bc2b1df8", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/connector-search-exhaustion-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Schedule any complete replay separately. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and explicit ten-minute limits. No dispatch. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3277, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "e7ff9dbb57da4ec88742456c6c8f422bb8a0a969", + "isDraft": false, + "number": 3277, + "title": "Research: prove a sharp C5 recursive-moment floor", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3277" + }, + "reviewed_head": "e7ff9dbb57da4ec88742456c6c8f422bb8a0a969", + "current_head": "e7ff9dbb57da4ec88742456c6c8f422bb8a0a969", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/c5-recursive-moment-floor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3278, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "67280b1da48a14435d7fde3ec81314c768a8dd3e", + "isDraft": false, + "number": 3278, + "title": "Prove mixed-rank P112 shortening through common support 39", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3278" + }, + "reviewed_head": "67280b1da48a14435d7fde3ec81314c768a8dd3e", + "current_head": "67280b1da48a14435d7fde3ec81314c768a8dd3e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-mixed-support39" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3279, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "67c1360a7a6e81bcac515c698d56656454340b10", + "isDraft": false, + "number": 3279, + "title": "Prove cost 20 on the four remaining physical C5 cores", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3279" + }, + "reviewed_head": "67c1360a7a6e81bcac515c698d56656454340b10", + "current_head": "67c1360a7a6e81bcac515c698d56656454340b10", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/c5-residual-trace-completion" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3280, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "c55a161982f0a94950a8f2653fe00fd387d2a0d5", + "isDraft": false, + "number": 3280, + "title": "Prove sharp E8 A2 rank-five joint incidence 20", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3280" + }, + "reviewed_head": "c55a161982f0a94950a8f2653fe00fd387d2a0d5", + "current_head": "c55a161982f0a94950a8f2653fe00fd387d2a0d5", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/e8-a2-joint-incidence20" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3281, + "metadata": { + "author": { + "id": "U_kgDOBcp5JQ", + "is_bot": false, + "login": "krzysztofwojt", + "name": "Krzysztof Wójt" + }, + "headRefOid": "a3a7306c15c7da541e4b586fdb642e2855fc2956", + "isDraft": false, + "number": 3281, + "title": "Certify four physical C5 cost floors by exact rational separation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3281" + }, + "reviewed_head": "a3a7306c15c7da541e4b586fdb642e2855fc2956", + "current_head": "a3a7306c15c7da541e4b586fdb642e2855fc2956", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/c5-four-residual-floors" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3282, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9607079de93907d87e6430d6de154f21a66c03e4", + "isDraft": false, + "number": 3282, + "title": "Certify source-bound P112 caller coverage for the (6,4) cell", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3282" + }, + "reviewed_head": "9607079de93907d87e6430d6de154f21a66c03e4", + "current_head": "9607079de93907d87e6430d6de154f21a66c03e4", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-b6-t4-reconciliation" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3283, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "089575ca9fdf03c734feecc2ae8a830fccb21812", + "isDraft": false, + "number": 3283, + "title": "Prove sharp P112 rank-five shortening at common support 47", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3283" + }, + "reviewed_head": "089575ca9fdf03c734feecc2ae8a830fccb21812", + "current_head": "089575ca9fdf03c734feecc2ae8a830fccb21812", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-rank5-sharp47" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3284, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b4d9f52456a66609b629f19fe28c0d1b4a44dc41", + "isDraft": false, + "number": 3284, + "title": "Bound fixed positive global charging of physical C5 floors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3284" + }, + "reviewed_head": "b4d9f52456a66609b629f19fe28c0d1b4a44dc41", + "current_head": "b4d9f52456a66609b629f19fe28c0d1b4a44dc41", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/c5-global-charging-obstruction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3285, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUyOTEyMzI1", + "is_bot": false, + "login": "Matarener", + "name": "" + }, + "headRefOid": "a30d6fabb6ea22f964b7e1e072901916e602154e", + "isDraft": false, + "number": 3285, + "title": "Research: independently re-solve PR #2979's fixed-capacity stage caps and price each stage-one group alone (no new κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3285" + }, + "reviewed_head": "a30d6fabb6ea22f964b7e1e072901916e602154e", + "current_head": "a30d6fabb6ea22f964b7e1e072901916e602154e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-stage-cap-resolve" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3286, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "696489749738515c9a9097d00373a582655a239c", + "isDraft": false, + "number": 3286, + "title": "Certify a mixed-rank P112 counterexample at common cut40", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3286" + }, + "reviewed_head": "696489749738515c9a9097d00373a582655a239c", + "current_head": "696489749738515c9a9097d00373a582655a239c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-mixed-sharp39" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3287, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "a8ed09f187f4f596f25f257dfc1d4ce90c697d02", + "isDraft": false, + "number": 3287, + "title": "Audit seven-source gap traversal and caller exhaustion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3287" + }, + "reviewed_head": "a8ed09f187f4f596f25f257dfc1d4ce90c697d02", + "current_head": "a8ed09f187f4f596f25f257dfc1d4ce90c697d02", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/connector-caller-exhaustion-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Schedule any complete replay separately. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and explicit ten-minute limits. No dispatch. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3288, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "c375ed42aabf1b8cdcaae0cc565540d0eda9fa0e", + "isDraft": false, + "number": 3288, + "title": "Prove analytic A2 rank-six capacity and equality", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3288" + }, + "reviewed_head": "c375ed42aabf1b8cdcaae0cc565540d0eda9fa0e", + "current_head": "c375ed42aabf1b8cdcaae0cc565540d0eda9fa0e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/e8-a2-analytic-rank6" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3289, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "e8570c50f9591c9ca653a527ed9626aaa703c3bc", + "isDraft": false, + "number": 3289, + "title": "Reconcile original P112 cover contracts for three caller rows", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3289" + }, + "reviewed_head": "e8570c50f9591c9ca653a527ed9626aaa703c3bc", + "current_head": "e8570c50f9591c9ca653a527ed9626aaa703c3bc", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-b6-t4-original-covers" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3290, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "6633669da0cc258e655fead0c4274b1bffbd3467", + "isDraft": false, + "number": 3290, + "title": "Bound global nonnegative charging from the 23 physical C5 floors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3290" + }, + "reviewed_head": "6633669da0cc258e655fead0c4274b1bffbd3467", + "current_head": "6633669da0cc258e655fead0c4274b1bffbd3467", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/c5-global-charging-ceiling" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3291, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "5d027c3c8724aec4501e0e2876388bebefa00ef7", + "isDraft": false, + "number": 3291, + "title": "Repair centre block proof with a sharp fifteen-owner graph floor", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3291" + }, + "reviewed_head": "5d027c3c8724aec4501e0e2876388bebefa00ef7", + "current_head": "5d027c3c8724aec4501e0e2876388bebefa00ef7", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/centre-block-moore-bound" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3292, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "33c778cbf8b6e0eb4b4eded3054521ec163a3f9c", + "isDraft": false, + "number": 3292, + "title": "Prove analytic D6 rank-six capacity after four orthogonal punctures", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3292" + }, + "reviewed_head": "33c778cbf8b6e0eb4b4eded3054521ec163a3f9c", + "current_head": "33c778cbf8b6e0eb4b4eded3054521ec163a3f9c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/d6-punctured-capacity18" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3293, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "67b0dc905bccca7bfd79b7e905884c49c53f5391", + "isDraft": false, + "number": 3293, + "title": "Prove an exact QQ16 helper frame-return contract", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3293" + }, + "reviewed_head": "67b0dc905bccca7bfd79b7e905884c49c53f5391", + "current_head": "67b0dc905bccca7bfd79b7e905884c49c53f5391", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/qq16-helper-frame-return" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3294, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "dd630150e5afe47fc1ce1717ca729fd4c344a89f", + "isDraft": false, + "number": 3294, + "title": "Certify an exact QQ16 B1 prefix inverse before child 11795", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3294" + }, + "reviewed_head": "dd630150e5afe47fc1ce1717ca729fd4c344a89f", + "current_head": "dd630150e5afe47fc1ce1717ca729fd4c344a89f", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/qq16-b1-prefix-reachability" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3295, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4cff8128f0f9ea1e61515b95ddbb884366e9362c", + "isDraft": false, + "number": 3295, + "title": "Prove six-piece P112 concentration and exclude a literal caller", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3295" + }, + "reviewed_head": "4cff8128f0f9ea1e61515b95ddbb884366e9362c", + "current_head": "4cff8128f0f9ea1e61515b95ddbb884366e9362c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/p112-six-piece-concentration" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3296, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUyOTEyMzI1", + "is_bot": false, + "login": "Matarener", + "name": "" + }, + "headRefOid": "6f78fe217ed63ef84096d53ed3651b38bab81e15", + "isDraft": false, + "number": 3296, + "title": "Research: PR #3190's remainder moves change the exact physical operator (affects #3198/#3200/#3251; no new κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3296" + }, + "reviewed_head": "6f78fe217ed63ef84096d53ed3651b38bab81e15", + "current_head": "6f78fe217ed63ef84096d53ed3651b38bab81e15", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/pr3190-remainder-stream-obstruction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + }, + { + "number": 3297, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "bab1899ce1c6fd43d073ac7c3a8e7c3e69008c0e", + "isDraft": false, + "number": 3297, + "title": "Prove complete T740 residual-phase identifiability", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3297" + }, + "reviewed_head": "bab1899ce1c6fd43d073ac7c3a8e7c3e69008c0e", + "current_head": "bab1899ce1c6fd43d073ac7c3a8e7c3e69008c0e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/t740-complete-phase-map" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. ", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-refresh-20261017.json" + ] + } + ] +} diff --git a/scripts/historical-ci-inputs/intake-starting-heads/82d67beb311be1b630eb95197492e6462eddccd8.json b/scripts/historical-ci-inputs/intake-starting-heads/82d67beb311be1b630eb95197492e6462eddccd8.json new file mode 100644 index 0000000000..7be7303ed7 --- /dev/null +++ b/scripts/historical-ci-inputs/intake-starting-heads/82d67beb311be1b630eb95197492e6462eddccd8.json @@ -0,0 +1,5736 @@ +{ + "schema_version": 1, + "scope": "Incremental exact-head decisions. Only changed entries are updated; historical decisions remain in the Git history and central ledger sources.", + "pull_requests": [ + { + "number": 275, + "metadata": { + "number": 275, + "title": "Finite assembly theorem and source-bound PR799 application", + "author": { + "id": "MDQ6VXNlcjE2NDk0NDU=", + "is_bot": false, + "login": "lydakis", + "name": "George Lydakis" + }, + "headRefOid": "524375c61b75dc10cef68a71d504e79e7e7f138c", + "isDraft": false + }, + "reviewed_head": "524375c61b75dc10cef68a71d504e79e7e7f138c", + "current_head": "524375c61b75dc10cef68a71d504e79e7e7f138c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/524375c61b75dc10cef68a71d504e79e7e7f138c" + ], + "unresolved_question": "Two primary finite-assembly packages previously passed, including the pinned PR799 application. Eleven additional research/tooling packages still require scientific review and execution. Historical source retention does not admit the submitted test wrappers, CI configuration or certificate replacement.", + "closure": { + "kind": "merged_for_historical_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/275", + "merge_commit": "fadae6f469e0d5c9c03bbe047a4d383dac254448" + }, + "scope": "Complete historical source retention only: all 734 original changed-file entries and full original commit remain accessible in main ancestry. No proposed scientific files, test wrappers, workflows, certificate or attributes are installed in the default tree. Existing main source stays unchanged. Two primary finite-assembly package reviews previously passed and remain credited; eleven other packages retain independent proof/replay obligations.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/275.json", + "research/community-efficient1900-audit/packets/275.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/275.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/275.json", + "docs/research/pr-intake-evidence/pr275-historical-retention.json" + ] + }, + { + "number": 826, + "metadata": { + "number": 826, + "title": "Independent audit: confirm κ of #699 (0.001660666354374641) and #685 (0.001660339298410333)", + "author": { + "id": "MDQ6VXNlcjk4Mzc5MDc=", + "is_bot": false, + "login": "Rohansguliani", + "name": "Rohan Guliani" + }, + "headRefOid": "ea3ceae40d5fa19dc0361d3f15546df0182459c4", + "isDraft": false + }, + "reviewed_head": "ea3ceae40d5fa19dc0361d3f15546df0182459c4", + "current_head": "ea3ceae40d5fa19dc0361d3f15546df0182459c4", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/pr-record699-685-audit" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/826", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change. Generated contributor/ledger metadata resolved against current authoritative dispositions; original self-attested validation text retained only at original author commit.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 1252, + "metadata": { + "number": 1252, + "title": "Idle pair exchanges improve the #1094 κ candidate", + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "1b9db2faf82b8866b0bb0164501c9a627c7dca9b", + "isDraft": false + }, + "reviewed_head": "1b9db2faf82b8866b0bb0164501c9a627c7dca9b", + "current_head": "1b9db2faf82b8866b0bb0164501c9a627c7dca9b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/frontier1094-idle-exchanges" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1252", + "merge_commit": "47fa55b3cd8c7cf8879206f33569bc59d637dad8" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change. The older README candidate note is retained at its original author commit; current README and selected result are unchanged.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016c.json" + ] + }, + { + "number": 1786, + "metadata": { + "number": 1786, + "title": "Conditional κ = 0.001679754788150048 from fine source-prime padding", + "author": { + "id": "MDQ6VXNlcjQ0MDA1Mjc=", + "is_bot": false, + "login": "chafreaky", + "name": "chafreaky" + }, + "headRefOid": "c52345caa318fc6b1b6e2659c57d746317a72823", + "isDraft": false + }, + "reviewed_head": "c52345caa318fc6b1b6e2659c57d746317a72823", + "current_head": "c52345caa318fc6b1b6e2659c57d746317a72823", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity hold: a changed-file MANIFEST.json does not match the vendored PR1673 CAPPED-LAYOUT-CONTROLS.json. The same inconsistency exists upstream; provenance does not repair the package pin. Resolve the frozen manifest/byte contract before integration; mathematical proof/replay review remains open.", + "closure": null, + "scope": "Exact-head source/configuration revision gate. No new scientific execution or approval. Prior scoped evidence is retained.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/1786.json", + "research/community-efficient1900-audit/packets/1786.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/1786.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/1786.json", + "docs/research/pr-intake-evidence/remaining-holds-20261016d.json", + "docs/research/pr-intake-evidence/archives-20261016d.json" + ] + }, + { + "number": 1897, + "metadata": { + "number": 1897, + "title": "Conditional kappa refinement: 500-digit enclosures and complete native-proof reuse", + "author": { + "id": "U_kgDOBdOLfA", + "is_bot": false, + "login": "M6LI", + "name": "Muhammed Ali Mehmood" + }, + "headRefOid": "fdf717a838bb3d4c78396474131bd1ab5f18165d", + "isDraft": false + }, + "reviewed_head": "fdf717a838bb3d4c78396474131bd1ab5f18165d", + "current_head": "fdf717a838bb3d4c78396474131bd1ab5f18165d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity hold: a changed-file MANIFEST.json does not match the vendored PR1673 CAPPED-LAYOUT-CONTROLS.json. The same inconsistency exists upstream; provenance does not repair the package pin. Resolve the frozen manifest/byte contract before integration; mathematical proof/replay review remains open.", + "closure": null, + "scope": "Exact-head source/configuration revision gate. No new scientific execution or approval. Prior scoped evidence is retained.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/1897.json", + "research/community-efficient1900-audit/packets/1897.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/1897.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/1897.json", + "docs/research/pr-intake-evidence/remaining-holds-20261016d.json", + "docs/research/pr-intake-evidence/archives-20261016d.json" + ] + }, + { + "number": 2361, + "metadata": { + "number": 2361, + "title": "ci: select affected verification inputs and preserve historical replays", + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "b15a55ba1cecf985a584ad5926bc67ebb940b8d3", + "isDraft": false + }, + "reviewed_head": "b15a55ba1cecf985a584ad5926bc67ebb940b8d3", + "current_head": "b15a55ba1cecf985a584ad5926bc67ebb940b8d3", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Revise CI adoption against current manual-only historical sweeps: submitted verify.yml enables push/PR runs and a full scheduled matrix every six hours, including formal work. Preserve the current opt-in/no-automatic-Lean policy. Current historical-adapter reconciliation and native Linux strace coverage remain required.", + "closure": null, + "scope": "Exact-head source/configuration revision gate. No new scientific execution or approval. Prior scoped evidence is retained.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "research/community-efficient1800-audit/packets/2361.json", + "research/community-efficient1900-audit/packets/2361.json", + "research/community-efficient2500-audit/INTAKE.json", + "research/community-efficient2500-audit/packets/2361.json", + "research/community-efficient2600-audit/INTAKE.json", + "research/community-efficient2600-audit/packets/2361.json", + "docs/research/pr-intake-evidence/remaining-holds-20261016d.json" + ] + }, + { + "number": 2452, + "metadata": { + "number": 2452, + "title": "Test native Windows replay descendant cleanup", + "author": { + "id": "U_kgDOCTONGQ", + "is_bot": false, + "login": "ywz65", + "name": "" + }, + "headRefOid": "5208ab2780550273b1d8933ff584ce7581fb242d", + "isDraft": false + }, + "reviewed_head": "5208ab2780550273b1d8933ff584ce7581fb242d", + "current_head": "5208ab2780550273b1d8933ff584ce7581fb242d", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/windows-replay-timeout-audit.md", + "tests/test_research_windows_process_tree.py" + ], + "unresolved_question": "", + "closure": { + "kind": "merged_with_scoped_review", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2452", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Native Windows tooling review: exact composed source passed eight current Job Object tests and three frozen historical taskkill observer tests, normal and optimized on Windows/Python 3.12 and 3.14. Non-Windows AST preserved; no mathematical replay.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json", + "docs/research/pr-intake-evidence/windows-native-20261016.log" + ] + }, + { + "number": 2469, + "metadata": { + "number": 2469, + "title": "Fix Windows replay lifetime with gated Job Object ownership", + "author": { + "id": "U_kgDOCTONGQ", + "is_bot": false, + "login": "ywz65", + "name": "" + }, + "headRefOid": "65080e406c9edb0e93daa631f90b3fa4e4461910", + "isDraft": false + }, + "reviewed_head": "65080e406c9edb0e93daa631f90b3fa4e4461910", + "current_head": "65080e406c9edb0e93daa631f90b3fa4e4461910", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/windows-replay-lifetime.md", + "scripts/research_package.py", + "tests/test_research_windows_job.py" + ], + "unresolved_question": "", + "closure": { + "kind": "merged_with_scoped_review", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2469", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Native Windows tooling review: exact composed source passed eight current Job Object tests and three frozen historical taskkill observer tests, normal and optimized on Windows/Python 3.12 and 3.14. Non-Windows AST preserved; no mathematical replay.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json", + "docs/research/pr-intake-evidence/windows-native-20261016.log" + ] + }, + { + "number": 2780, + "metadata": { + "number": 2780, + "title": "Prove paid return of every physical head for the clean six-tape multiplier", + "author": { + "id": "MDQ6VXNlcjQ5MDU0NTMy", + "is_bot": false, + "login": "Dugongue", + "name": "" + }, + "headRefOid": "59f336094958b51b312e54deb85347e1b671172d", + "isDraft": false + }, + "reviewed_head": "59f336094958b51b312e54deb85347e1b671172d", + "current_head": "59f336094958b51b312e54deb85347e1b671172d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "multitape-origin-return/LICENSE", + "multitape-origin-return/MANIFEST.json", + "multitape-origin-return/MODULES.json", + "multitape-origin-return/NOTICE.md", + "multitape-origin-return/PORTING.json", + "multitape-origin-return/README.md", + "multitape-origin-return/REUSE.json", + "multitape-origin-return/SOURCES.json", + "multitape-origin-return/TASK.json", + "multitape-origin-return/VERIFY.json", + "multitape-origin-return/expected", + "multitape-origin-return/lean", + "multitape-origin-return/replay.py", + "multitape-origin-return/verify.py" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2780", + "merge_commit": "47fa55b3cd8c7cf8879206f33569bc59d637dad8" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016c.json" + ] + }, + { + "number": 2832, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "0da81b22178e70dbf59a23dda02371c6201fa4f3", + "isDraft": false, + "number": 2832, + "title": "Decoder floors: universality, projection transfer and batching reductions; C(P112) ≥ 64 reduced to named conjectures, C(P120) ≥ 72 restated on N₀ (no κ claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2832" + }, + "reviewed_head": "0da81b22178e70dbf59a23dda02371c6201fa4f3", + "current_head": "0da81b22178e70dbf59a23dda02371c6201fa4f3", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Theorem TF consequence uses a single fold parameter to cancel all proportional MD terms, but proportionality ratios may differ. The retained P112 decoder has16 MD terms p=(x_i,+/-x_i),q=p/8, exact target diag(G/2,G/2), and total cost128; ratios+1 and-1 require incompatible cancelling parameters. This exposes a gap in the conditional-under-H argument, not a proof or refutation of H. Supply common-ratio/common-annihilator hypotheses or a different proof. Section4.1 also needs justification: m=8k+e does not by itself restrict each call to8+e terms; this example has16 per call with e=0. Re-audit dependent batching consequences and add regression before a full replay. Revised head adds checks and a proof map but says no claim changed; the flagged argument remains. Two manifest-listed logs are also absent.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 2962, + "metadata": { + "number": 2962, + "title": "Ceilings for linear rank-counting decoder certificates (360/17 on P120) and a one-sided lift bound (cost >= 72 for dim S >= 23)", + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "f6e68c9838e21b263223ae61273e381d2c0b92c7", + "isDraft": false + }, + "reviewed_head": "f6e68c9838e21b263223ae61273e381d2c0b92c7", + "current_head": "f6e68c9838e21b263223ae61273e381d2c0b92c7", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/decoder-certificate-ceilings" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2962", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2963, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "ee755e682b3b30d493e764d3be50003b13b69b4a", + "isDraft": false, + "number": 2963, + "title": "F-star family gap: the twelve tied_min v = 11 sub-decoders settled exactly - gap_named = 2 EXISTS below v = 12 (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2963" + }, + "reviewed_head": "ee755e682b3b30d493e764d3be50003b13b69b4a", + "current_head": "ee755e682b3b30d493e764d3be50003b13b69b4a", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "The revised head still ships malformed JSON at research/fstar-gap2-v11-seed42ff0611/predecessor/pr2914/CERTIFICATE.json: Expecting value: line 1 column 1 (char 0). Restore the pinned predecessor certificate or explicitly document and isolate it as inert invalid evidence. This is an integrity hold, not a mathematical rejection.", + "scope": "Changed-head source/integrity triage; no scientific replay.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 2964, + "metadata": { + "number": 2964, + "title": "Decide every odd-order character rank cut before bit-word search", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "466c65e73b3efb5f8144799792fbef0acf4369cf", + "isDraft": false + }, + "reviewed_head": "466c65e73b3efb5f8144799792fbef0acf4369cf", + "current_head": "466c65e73b3efb5f8144799792fbef0acf4369cf", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/bit-odd-character-screen" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2964", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2965, + "metadata": { + "number": 2965, + "title": "Bound completed QQ16 producer errors through the decoder", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "526f2c242202b31b15e09a7502dfb8ff757b2bad", + "isDraft": false + }, + "reviewed_head": "526f2c242202b31b15e09a7502dfb8ff757b2bad", + "current_head": "526f2c242202b31b15e09a7502dfb8ff757b2bad", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-producer-defect-transfer" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2965", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2966, + "metadata": { + "number": 2966, + "title": "Conditional κ = 0.001724034272523452: fourteen declared gate rewrites (five classes) on #2942's words and literal allocation", + "author": { + "id": "U_kgDOEKXqaA", + "is_bot": false, + "login": "jeremykothe2", + "name": "" + }, + "headRefOid": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "isDraft": false + }, + "reviewed_head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "current_head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/e62d3eb9005117d82a9babcfa937ecc53237c490" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_historical_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2966", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original commit retained in main ancestry; differing files NOT installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2968, + "metadata": { + "number": 2968, + "title": "Audit high-scaling physical scratch inventory and tape costs", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "cf4fc903951cd3f034531f7089d0a178f0f67b05", + "isDraft": false + }, + "reviewed_head": "cf4fc903951cd3f034531f7089d0a178f0f67b05", + "current_head": "cf4fc903951cd3f034531f7089d0a178f0f67b05", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/high-scaling-scratch-traffic" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2968", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2969, + "metadata": { + "number": 2969, + "title": "Compose normal-45 extraction and fourteen gate rewrites: candidate κ ≈ 0.0017240352247481", + "author": { + "id": "MDQ6VXNlcjQ5MDU0NTMy", + "is_bot": false, + "login": "Dugongue", + "name": "" + }, + "headRefOid": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "isDraft": false + }, + "reviewed_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "current_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/paired-swap-normal45" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2969", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2970, + "metadata": { + "number": 2970, + "title": "Certify the F-star one-interior-label gap on tied_min", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "bef9060f6b923577ca1d5a78266fd84df00ca93a", + "isDraft": false + }, + "reviewed_head": "bef9060f6b923577ca1d5a78266fd84df00ca93a", + "current_head": "bef9060f6b923577ca1d5a78266fd84df00ca93a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/fstar-one-interior-label" + ], + "unresolved_question": "Independent mechanism/proof review and source-bound scientific replay remain open. Archival acceptance is not a selected-bound update.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2970", + "merge_commit": "484a8adea580345a7c37d8ac772cedfd47bcde92" + }, + "scope": "Source-only archive; independent scientific validation remains open. Exact original source identity, changed-file inventory, Python/JSON syntax and available flat manifest pins checked. No submitted scientific code executed. Original research blobs installed in default tree.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/windows-and-new-archives-20261016.json" + ] + }, + { + "number": 2971, + "metadata": { + "number": 2971, + "title": "Complete native and hosted replay of the R438 bit improvement", + "author": { + "id": "MDQ6VXNlcjgwMjk5Njgz", + "is_bot": false, + "login": "CubeJerry", + "name": "" + }, + "headRefOid": "cc009708e5d7ca1e76a3263eb4e9efce57ac7d10", + "isDraft": false + }, + "reviewed_head": "cc009708e5d7ca1e76a3263eb4e9efce57ac7d10", + "current_head": "cc009708e5d7ca1e76a3263eb4e9efce57ac7d10", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/r438-native-rehost" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2971", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2972, + "metadata": { + "number": 2972, + "title": "Audit: stock-margin chain closes for the remaining cutoff pairs (no new kappa)", + "author": { + "id": "MDQ6VXNlcjE1MzM0MQ==", + "is_bot": false, + "login": "kumagi", + "name": "Hiroki KUMAZAKI" + }, + "headRefOid": "d6b883f97d2fd176171553b695005a132156d961", + "isDraft": false + }, + "reviewed_head": "d6b883f97d2fd176171553b695005a132156d961", + "current_head": "d6b883f97d2fd176171553b695005a132156d961", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/stock-margin-chain" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2972", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2973, + "metadata": { + "number": 2973, + "title": "Correct word-census parity budgets; 22 <= f(7) <= 24 in the PR943 model", + "author": { + "id": "MDQ6VXNlcjk0NjMxMDU=", + "is_bot": false, + "login": "NicholasStone", + "name": "Nicholas Stone" + }, + "headRefOid": "d48f3945dbb1ef5d06835744c4082b3bd04181c0", + "isDraft": false + }, + "reviewed_head": "d48f3945dbb1ef5d06835744c4082b3bd04181c0", + "current_head": "d48f3945dbb1ef5d06835744c4082b3bd04181c0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-weight-parity-census-correction" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2973", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2974, + "metadata": { + "number": 2974, + "title": "Independently verify PR2942 owner-to-recursive-cost bridge", + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "9cffaeb321429eb0b3f192aef05ce4ff3dae4b9f", + "isDraft": false + }, + "reviewed_head": "9cffaeb321429eb0b3f192aef05ce4ff3dae4b9f", + "current_head": "9cffaeb321429eb0b3f192aef05ce4ff3dae4b9f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/normal45-owner-cost-bridge" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2974", + "merge_commit": "445dad73a56a978b0314d0975839e7bb3cf1e2f3" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016b.json" + ] + }, + { + "number": 2975, + "metadata": { + "number": 2975, + "title": "Accelerate exact four-flat requirement enumeration by 33x on a pinned corpus", + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "1d7b491c9efad451d49dbfd36a3be7443999bf17", + "isDraft": false + }, + "reviewed_head": "1d7b491c9efad451d49dbfd36a3be7443999bf17", + "current_head": "1d7b491c9efad451d49dbfd36a3be7443999bf17", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/two-flat-cover-branching" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2975", + "merge_commit": "47fa55b3cd8c7cf8879206f33569bc59d637dad8" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016c.json" + ] + }, + { + "number": 2977, + "metadata": { + "number": 2977, + "title": "Audit selected scatter parity across word and record checks", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "cd23d242dfe0e7a71cafba0ad5590dc4f2fbf4f2", + "isDraft": false + }, + "reviewed_head": "cd23d242dfe0e7a71cafba0ad5590dc4f2fbf4f2", + "current_head": "cd23d242dfe0e7a71cafba0ad5590dc4f2fbf4f2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/scatter-export-parity-audit" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete source-bound replay remain open. Author-reported PASS receipts and claimed bounds are not maintainer validation.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2977", + "merge_commit": "ff9019ba07a87ce40765c6e75dc4fb82df6a7789" + }, + "scope": "Source/integrity archival acceptance only; no submitted scientific code executed or selected-bound change.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-20261016d.json" + ] + }, + { + "number": 2978, + "metadata": { + "number": 2978, + "title": "F-star family gap: Lemma BPP's without-loss question answered NO - box-completeness fails at tau >= 1, minimal counterexample v = 3 (no kappa)", + "headRefOid": "12eb7b832de9239a314a7cddf6c6033d618cd8f2", + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "isDraft": false + }, + "reviewed_head": "12eb7b832de9239a314a7cddf6c6033d618cd8f2", + "current_head": "12eb7b832de9239a314a7cddf6c6033d618cd8f2", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Repair malformed vendored predecessor/pr2963/predecessor/pr2914/CERTIFICATE.json; source-only JSON intake fails before scientific review. Retain authentic predecessor bytes and update declared source pins consistently. Mathematical claims remain unreviewed.", + "closure": null, + "scope": "Source syntax/integrity intake: malformed vendored JSON. No scientific execution or endorsement.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/pr2978-source-hold.json" + ] + }, + { + "number": 2979, + "metadata": { + "number": 2979, + "title": "Conditional κ ≈ 0.0017290339826465: joint rank-7 end frames, five paired extractions and #2957's rewrites on #2942's words (+5.00e-6 over #2969)", + "author": { + "id": "MDQ6VXNlcjMwNTExNDU2", + "is_bot": false, + "login": "mdumitrean", + "name": "aigent-marius" + }, + "headRefOid": "be191346391661f4d35fc0d1508d0a6029572576", + "isDraft": false + }, + "reviewed_head": "be191346391661f4d35fc0d1508d0a6029572576", + "current_head": "be191346391661f4d35fc0d1508d0a6029572576", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-endframes" + ], + "unresolved_question": "Independent scientific mechanism/proof review and complete native/outer replay remain open. The proposed kappa is an author claim, not the selected result.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2979", + "merge_commit": "30f016dd79ee6a23c40d7dab44a9466c148c42dd" + }, + "scope": "Exact-source archival intake only. No submitted scientific code executed and no selected-bound update.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archive-pr2979.json" + ] + }, + { + "number": 2980, + "metadata": { + "number": 2980, + "title": "Record the odd-prime depth-zero unit root as a weight, not a padded-row reversal", + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "d0aa33af7c20b2ce28ea64d615ff63a164384e4e", + "isDraft": false + }, + "reviewed_head": "d0aa33af7c20b2ce28ea64d615ff63a164384e4e", + "current_head": "d0aa33af7c20b2ce28ea64d615ff63a164384e4e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-odd-prime-unit-root" + ], + "unresolved_question": "Independent scientific review and registered source-bound replay remain open. No new supplier, selected result or theorem validation is implied by archival publication.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2980", + "merge_commit": "86b5e56d4aa0ced955ac7f059eac0c3a5633ca59" + }, + "scope": "Source-only archival intake. No submitted scientific code executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-pr2980-2981.json" + ] + }, + { + "number": 2981, + "metadata": { + "number": 2981, + "title": "Research: certify joint P104 unit-step endpoint flags (no new kappa)", + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "isDraft": false + }, + "reviewed_head": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "current_head": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-joint-unit-flags" + ], + "unresolved_question": "Independent scientific review and registered source-bound replay remain open. No new supplier, selected result or theorem validation is implied by archival publication.", + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2981", + "merge_commit": "86b5e56d4aa0ced955ac7f059eac0c3a5633ca59" + }, + "scope": "Source-only archival intake. No submitted scientific code executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/archives-pr2980-2981.json" + ] + }, + { + "number": 2982, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b9ac0d07eb9cdc31c4dca8dcc218943998edd3e8", + "isDraft": false, + "number": 2982, + "title": "Certify sharp linear wrapper costs for complete high routes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2982" + }, + "reviewed_head": "b9ac0d07eb9cdc31c4dca8dcc218943998edd3e8", + "current_head": "b9ac0d07eb9cdc31c4dca8dcc218943998edd3e8", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/high-route-prefix-cost" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2982", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2984, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "34d7c3feaf87b878d9524c215b678403b8afdc08", + "isDraft": false, + "number": 2984, + "title": "Tooling: 2.25x faster corrected f(7) census with identical traversal", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2984" + }, + "reviewed_head": "34d7c3feaf87b878d9524c215b678403b8afdc08", + "current_head": "34d7c3feaf87b878d9524c215b678403b8afdc08", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-parity-mask-replay" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2984", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2985, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "b07b0e3226bcbe32a90c1b43ab225c339086f7b5", + "isDraft": false, + "number": 2985, + "title": "Research: one-sided residue closures — Circuit Lemma, relative root counting and plane lemma close 480 of the 603 d>=4 residues (116 open; no kappa claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2985" + }, + "reviewed_head": "b07b0e3226bcbe32a90c1b43ab225c339086f7b5", + "current_head": "b07b0e3226bcbe32a90c1b43ab225c339086f7b5", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/one-sided-residue-closures/evidence/logs/nj4.out; missing flat manifest file research/one-sided-residue-closures/provenance/generator/land7.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 2986, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "f610bda7818df522c26b28f5766a06c5ef5c270c", + "isDraft": false, + "number": 2986, + "title": "Fix replay selection through symlinked input paths", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2986" + }, + "reviewed_head": "f610bda7818df522c26b28f5766a06c5ef5c270c", + "current_head": "f610bda7818df522c26b28f5766a06c5ef5c270c", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/replay-input-symlink-alias" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2986", + "merge_commit": "5d2f626f73aa981d67f438e424e7df79f5496586" + } + }, + { + "number": 2987, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "02c3047a1e78e6e35e7573c12434ba26f6f9bd96", + "isDraft": false, + "number": 2987, + "title": "Certify rank-seven chronological packing bound and cost-neutral repair", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2987" + }, + "reviewed_head": "02c3047a1e78e6e35e7573c12434ba26f6f9bd96", + "current_head": "02c3047a1e78e6e35e7573c12434ba26f6f9bd96", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-chronological-face" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2987", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2989, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "133cd8a7c5ce16a3d66e3372c5fdd9e88067d75b", + "isDraft": false, + "number": 2989, + "title": "Independently audit selected compiler ordering and owner guards", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2989" + }, + "reviewed_head": "133cd8a7c5ce16a3d66e3372c5fdd9e88067d75b", + "current_head": "133cd8a7c5ce16a3d66e3372c5fdd9e88067d75b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-compiler-correspondence" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2989", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2990, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9158ee6d097e8058b177c54a1f68a6c30249c8f8", + "isDraft": false, + "number": 2990, + "title": "fix(tests): prevent stale bytecode from hiding failures", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2990" + }, + "reviewed_head": "9158ee6d097e8058b177c54a1f68a6c30249c8f8", + "current_head": "9158ee6d097e8058b177c54a1f68a6c30249c8f8", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/isolated-test-bytecode" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2990", + "merge_commit": "cedad3e65c45c4ca1e00b02a2ae8055e8d2bb57a" + } + }, + { + "number": 2991, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "7d9452f7b99901c78f49fcb1244d5c3a87dbca02", + "isDraft": false, + "number": 2991, + "title": "docs: map P104 precision contracts and remaining implementation obligations", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2991" + }, + "reviewed_head": "7d9452f7b99901c78f49fcb1244d5c3a87dbca02", + "current_head": "7d9452f7b99901c78f49fcb1244d5c3a87dbca02", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/bottleneck-brief.md", + "docs/research/p104-precision-contract-map.md" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2991", + "merge_commit": "4dab22885e1d153e8258ddf96fa5566af27b3ec4" + } + }, + { + "number": 2992, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "b31bf0360ad702b1be71dea7a33edc11711084af", + "isDraft": false, + "number": 2992, + "title": "Enforce simple scatter supports at opt-in checker and exporter boundaries", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2992" + }, + "reviewed_head": "b31bf0360ad702b1be71dea7a33edc11711084af", + "current_head": "b31bf0360ad702b1be71dea7a33edc11711084af", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/simple-scatter-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2992", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2993, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "34a7003866390618b8e8006dc483e7a37a37903f", + "isDraft": false, + "number": 2993, + "title": "Independently audit #2979's joint rank-seven frame paths", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2993" + }, + "reviewed_head": "34a7003866390618b8e8006dc483e7a37a37903f", + "current_head": "34a7003866390618b8e8006dc483e7a37a37903f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-frame-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2993", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2994, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "900ab6c9e1f9cc5dcc1ca93ed7db966e7cf883a5", + "isDraft": false, + "number": 2994, + "title": "Audit case-insensitive replay inputs against Git spelling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2994" + }, + "reviewed_head": "900ab6c9e1f9cc5dcc1ca93ed7db966e7cf883a5", + "current_head": "900ab6c9e1f9cc5dcc1ca93ed7db966e7cf883a5", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/replay-input-case-alias" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2994", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2995, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "8ba0358b62edbeb16a0842473500c468d8c0759b", + "isDraft": false, + "number": 2995, + "title": "Certify an F0 scalar fault witness with exact dirty restoration", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2995" + }, + "reviewed_head": "8ba0358b62edbeb16a0842473500c468d8c0759b", + "current_head": "8ba0358b62edbeb16a0842473500c468d8c0759b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-producer-dirty-fault" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2995", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2996, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4d772802fe86e5185d5468db86b36472e6c81b96", + "isDraft": false, + "number": 2996, + "title": "Certify P104 dependency obstruction for every fixed-pair flag completion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2996" + }, + "reviewed_head": "4d772802fe86e5185d5468db86b36472e6c81b96", + "current_head": "4d772802fe86e5185d5468db86b36472e6c81b96", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-endpoint-completion-flow" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2996", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2997, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "16e790e10cc0bc737b9cd269020d3d967d36430f", + "isDraft": false, + "number": 2997, + "title": "Audit missing information paths in the fixed P104 joint flags", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2997" + }, + "reviewed_head": "16e790e10cc0bc737b9cd269020d3d967d36430f", + "current_head": "16e790e10cc0bc737b9cd269020d3d967d36430f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-flag-information-flow" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2997", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2998, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "3aa400ed59d19b9d6c08e22d1b75edb36a1d3e27", + "isDraft": false, + "number": 2998, + "title": "Research: prove a sharp S4 coordinate-cut gap for mixed targets", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2998" + }, + "reviewed_head": "3aa400ed59d19b9d6c08e22d1b75edb36a1d3e27", + "current_head": "3aa400ed59d19b9d6c08e22d1b75edb36a1d3e27", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/s4-two-premium-cut-envelope" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2998", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 2999, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "ac6025235b6f1233291000d35a067198628569e9", + "isDraft": false, + "number": 2999, + "title": "Prove adaptive P104 rounding collisions and retained-history bounds", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2999" + }, + "reviewed_head": "ac6025235b6f1233291000d35a067198628569e9", + "current_head": "ac6025235b6f1233291000d35a067198628569e9", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-adaptive-rounding-collision" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2999", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3000, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "4c0cf223e3e4a06099704b34202a5015f1ab1e62", + "isDraft": false, + "number": 3000, + "title": "Tooling: 9.31x faster exact four-flat maximal-mask filtering", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3000" + }, + "reviewed_head": "4c0cf223e3e4a06099704b34202a5015f1ab1e62", + "current_head": "4c0cf223e3e4a06099704b34202a5015f1ab1e62", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/four-flat-maximal-masks" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3000", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3002, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "0bc34c304441740273e30e06cb28710bdd3d788d", + "isDraft": false, + "number": 3002, + "title": "Fix numeric task references in overlap search", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3002" + }, + "reviewed_head": "0bc34c304441740273e30e06cb28710bdd3d788d", + "current_head": "0bc34c304441740273e30e06cb28710bdd3d788d", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "autoresearch.md", + "docs/research/overlap-task-reference-matching.md", + "scripts/find_overlap.py", + "tests/test_research_overlap_terms.py" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3002", + "merge_commit": "3051cf1605606c32589c2823e0e54f017119d3f5" + } + }, + { + "number": 3003, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "38a0eddf69de8d64840353b5e1ed53bb37b6bc68", + "isDraft": false, + "number": 3003, + "title": "Add exact controls for one-sided residue dominance provenance", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3003" + }, + "reviewed_head": "38a0eddf69de8d64840353b5e1ed53bb37b6bc68", + "current_head": "38a0eddf69de8d64840353b5e1ed53bb37b6bc68", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/one-sided-landscape-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3003", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3004, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE1MzM0MQ==", + "is_bot": false, + "login": "kumagi", + "name": "Hiroki KUMAZAKI" + }, + "headRefOid": "ce08d19f6e43bbc6f552858d93154efe3aa98916", + "isDraft": false, + "number": 3004, + "title": "Audit: exact scatter parity contract at the checker/exporter boundary (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3004" + }, + "reviewed_head": "ce08d19f6e43bbc6f552858d93154efe3aa98916", + "current_head": "ce08d19f6e43bbc6f552858d93154efe3aa98916", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/scatter-parity-contract-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3004", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3005, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "68e67922294d96a42f479f80fdc352eb04a9b550", + "isDraft": false, + "number": 3005, + "title": "Independently corroborate the corrected seven-label word exclusion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3005" + }, + "reviewed_head": "68e67922294d96a42f479f80fdc352eb04a9b550", + "current_head": "68e67922294d96a42f479f80fdc352eb04a9b550", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-union-support-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3005", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3006, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1432a43a331ec857f45093a1d6e16acdbe9849e2", + "isDraft": false, + "number": 3006, + "title": "test(research): audit V45 native residual and private endpoint", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3006" + }, + "reviewed_head": "1432a43a331ec857f45093a1d6e16acdbe9849e2", + "current_head": "1432a43a331ec857f45093a1d6e16acdbe9849e2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-native-endpoint" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3006", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3007, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "3cb500b743f36e13d21b6a46f126846bf36bad32", + "isDraft": false, + "number": 3007, + "title": "fix(research): require exact Git spelling for replay inputs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3007" + }, + "reviewed_head": "3cb500b743f36e13d21b6a46f126846bf36bad32", + "current_head": "3cb500b743f36e13d21b6a46f126846bf36bad32", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/replay-input-head-spelling" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3007", + "merge_commit": "e983379b309c2389608ad7903ae7258a79a36fdd" + } + }, + { + "number": 3008, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "948a997eba1aaf13d04e2b52edf70404860d19dc", + "isDraft": false, + "number": 3008, + "title": "test(research): bind V45 helper and private-buffer events", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3008" + }, + "reviewed_head": "948a997eba1aaf13d04e2b52edf70404860d19dc", + "current_head": "948a997eba1aaf13d04e2b52edf70404860d19dc", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-event-binding" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3008", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3009, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE1MzM0MQ==", + "is_bot": false, + "login": "kumagi", + "name": "Hiroki KUMAZAKI" + }, + "headRefOid": "95568ae83a73ace578e3972a01aef55c889e58a2", + "isDraft": false, + "number": 3009, + "title": "Tooling: 1.27x faster t16 invoice-boundary replay via compresslevel=1 (identical receipt)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3009" + }, + "reviewed_head": "95568ae83a73ace578e3972a01aef55c889e58a2", + "current_head": "95568ae83a73ace578e3972a01aef55c889e58a2", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/t16-invoice-boundary-audit" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3009", + "merge_commit": "6837fa6f28d065dc43b1f7c1fef7c1e8347633ca" + } + }, + { + "number": 3010, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "87ca15cf005ab232ca0104ec5137014ac754f487", + "isDraft": false, + "number": 3010, + "title": "Certify a sharp frozen-fill boundary for rank-seven inverse swaps", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3010" + }, + "reviewed_head": "87ca15cf005ab232ca0104ec5137014ac754f487", + "current_head": "87ca15cf005ab232ca0104ec5137014ac754f487", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-face-boundary-fill" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3010", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3011, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "c5b58be95592a408d0cc42b0b829a3b543fd4b3b", + "isDraft": false, + "number": 3011, + "title": "Show the unit-weight GL2 machine reverses every column at one gap", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3011" + }, + "reviewed_head": "c5b58be95592a408d0cc42b0b829a3b543fd4b3b", + "current_head": "c5b58be95592a408d0cc42b0b829a3b543fd4b3b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-unit-weight-reversal" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3011", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3012, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "63c6525120c20543c4a7acae1a1e1ea36e099b81", + "isDraft": false, + "number": 3012, + "title": "F-star family gap: the box floor FAILS minimally at v = 3 - surviving tau >= 1 form exact (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3012" + }, + "reviewed_head": "63c6525120c20543c4a7acae1a1e1ea36e099b81", + "current_head": "63c6525120c20543c4a7acae1a1e1ea36e099b81", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: research/fstar-boxfloor-minimal-seed758ae8fe/predecessor/pr2978/data/box-search-kj-receipt.json: Expecting value: line 1 column 1 (char 0); research/fstar-boxfloor-minimal-seed758ae8fe/predecessor/pr2978/predecessor/pr2963/predecessor/pr2914/CERTIFICATE.json: Expecting value: line 1 column 1 (char 0). Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3013, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "504dc9a15f7a874a47564cdf3ae6857bbbc8d000", + "isDraft": false, + "number": 3013, + "title": "Certify the P104 matching-pool limit and a 45-missing-pair witness", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3013" + }, + "reviewed_head": "504dc9a15f7a874a47564cdf3ae6857bbbc8d000", + "current_head": "504dc9a15f7a874a47564cdf3ae6857bbbc8d000", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-rematched-dependency-screen" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3013", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3014, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "16e8db5656b4fea487a2212395f39707bf134f7a", + "isDraft": false, + "number": 3014, + "title": "test(research): certify V45's frozen-owner invoice obstruction", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3014" + }, + "reviewed_head": "16e8db5656b4fea487a2212395f39707bf134f7a", + "current_head": "16e8db5656b4fea487a2212395f39707bf134f7a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-frozen-owner-invoice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3014", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3015, + "metadata": { + "author": { + "id": "U_kgDOEKXqaA", + "is_bot": false, + "login": "jeremykothe2", + "name": "" + }, + "headRefOid": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "isDraft": false, + "number": 3015, + "title": "Conditional κ = 0.001729150973534224: one declared restore edit (R1) on PR2979's words and literal allocation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3015" + }, + "reviewed_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "current_head": "e244296debb45fe6f4da84d29e4d64fbab55fda0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-endframes-restore-edit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3015", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3016, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4471aa49f9f0dd9332b0f1819bead8e331e824db", + "isDraft": false, + "number": 3016, + "title": "fix(replay): make owner verification repeatable", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3016" + }, + "reviewed_head": "4471aa49f9f0dd9332b0f1819bead8e331e824db", + "current_head": "4471aa49f9f0dd9332b0f1819bead8e331e824db", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "research/half-stage-evacuation", + "research/owner-replay-workspaces", + "research/source-partner-residual-exchanges" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3016", + "merge_commit": "2b43ca4a3a9c704a037718d4023214a7db48ba0a" + } + }, + { + "number": 3017, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "0f493f4c264fbc70ee14364b68af260d858c143c", + "isDraft": false, + "number": 3017, + "title": "Audit: bind the QQ16 dirty-helper fault to native execution", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3017" + }, + "reviewed_head": "0f493f4c264fbc70ee14364b68af260d858c143c", + "current_head": "0f493f4c264fbc70ee14364b68af260d858c143c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-native-dirty-fault" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3017", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3018, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "isDraft": false, + "number": 3018, + "title": "feat(research): lower the rank-seven packing moment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3018" + }, + "reviewed_head": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "current_head": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-integrality-exchange" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3018", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3019, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "44d12bdeb8ade4066645bd968bebd4756b06200a", + "isDraft": false, + "number": 3019, + "title": "Certify a single P104 matching with complete relaxed support", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3019" + }, + "reviewed_head": "44d12bdeb8ade4066645bd968bebd4756b06200a", + "current_head": "44d12bdeb8ade4066645bd968bebd4756b06200a", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-coherent-support-witness" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3019", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3020, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "e49abeef32a376f9e8500999ef15594af2587779", + "isDraft": false, + "number": 3020, + "title": "Construct a four-bin relay beyond frozen direct swaps", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3020" + }, + "reviewed_head": "e49abeef32a376f9e8500999ef15594af2587779", + "current_head": "e49abeef32a376f9e8500999ef15594af2587779", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-multibin-face-relay" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3020", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3021, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "217edac2ebfa6250536bd6df153de14901a69395", + "isDraft": false, + "number": 3021, + "title": "feat(research): compose restore and packing gains", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3021" + }, + "reviewed_head": "217edac2ebfa6250536bd6df153de14901a69395", + "current_head": "217edac2ebfa6250536bd6df153de14901a69395", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-packing-composition" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3021", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3022, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "isDraft": false, + "number": 3022, + "title": "feat(research): improve doubled rank-seven packing", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3022" + }, + "reviewed_head": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "current_head": "553dc9d8fc8c1489aa2b0378331a0de4b5e9b44e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-doubled-residual-exchange" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3022", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3023, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "02ebc2ff8243baa9febbb6954f9169e4c216a65e", + "isDraft": false, + "number": 3023, + "title": "KB3h: (12,6) A-vanish (5,1) PROVEN impossible; (4,2)/(3,3) reduced to exact walkable forms (outcome=partial; no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3023" + }, + "reviewed_head": "02ebc2ff8243baa9febbb6954f9169e4c216a65e", + "current_head": "02ebc2ff8243baa9febbb6954f9169e4c216a65e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-18point-avtail-seed010d26fa" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3023", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3024, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "isDraft": false, + "number": 3024, + "title": "Attain the joint rank-seven packing cap exactly at T740", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3024" + }, + "reviewed_head": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "current_head": "315df10c07cf8b8ee9af9b2122750635bb2582ae", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-cap740" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3024", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3025, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "a544ef068a46f4de3bc47d1d02149cbdc3ba547f", + "isDraft": false, + "number": 3025, + "title": "Construction: reversible integer-lifting cleanup for the P104 collector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3025" + }, + "reviewed_head": "a544ef068a46f4de3bc47d1d02149cbdc3ba547f", + "current_head": "a544ef068a46f4de3bc47d1d02149cbdc3ba547f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-reversible-lifting" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3025", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3026, + "metadata": { + "author": { + "id": "MDQ6VXNlcjQ0MTczMTcz", + "is_bot": false, + "login": "flyingviper", + "name": "" + }, + "headRefOid": "d323df51afdb616d73ff577179bfb76d8832450d", + "isDraft": false, + "number": 3026, + "title": "P112: sharp cost-45 floor for all low-tariff frames on five triads", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3026" + }, + "reviewed_head": "d323df51afdb616d73ff577179bfb76d8832450d", + "current_head": "d323df51afdb616d73ff577179bfb76d8832450d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-five-group-projector-lift" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3026", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3027, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "e686b4a622846c01ac80d038d1441434e9c0b13c", + "isDraft": false, + "number": 3027, + "title": "Record that the selected-grammar root rejects the unit tape", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3027" + }, + "reviewed_head": "e686b4a622846c01ac80d038d1441434e9c0b13c", + "current_head": "e686b4a622846c01ac80d038d1441434e9c0b13c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/selected-unit-root-tape-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3027", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3028, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9d10633660a3dff5469f4e7a0a009a6c9994c0d7", + "isDraft": false, + "number": 3028, + "title": "feat(research): release the T148 restore composition", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3028" + }, + "reviewed_head": "9d10633660a3dff5469f4e7a0a009a6c9994c0d7", + "current_head": "9d10633660a3dff5469f4e7a0a009a6c9994c0d7", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-t148-restore-release" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3028", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3029, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "6a2de790fadcf87db02eaa99b19b92eed5aa0d3f", + "isDraft": false, + "number": 3029, + "title": "Two-sided deficiency budget: Theorem BX for b_Q <= 4 (conditional frame, exact residue, no κ claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3029" + }, + "reviewed_head": "6a2de790fadcf87db02eaa99b19b92eed5aa0d3f", + "current_head": "6a2de790fadcf87db02eaa99b19b92eed5aa0d3f", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/two-sided-deficiency-budget/evidence/orig_chk8_B78.log; missing flat manifest file research/two-sided-deficiency-budget/evidence/orig_chk8_B80_first40.log. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3030, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "78e77d820393c6b8648b47af219e991edfcc54e6", + "isDraft": false, + "number": 3030, + "title": "feat(research): release the T740 R1 cap composition", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3030" + }, + "reviewed_head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "current_head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-t740-release" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3030", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3031, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "e75906fc4e8b9f756a9877b2e467f4e564851c7d", + "isDraft": false, + "number": 3031, + "title": "KB5L: tau >= 1 box floor PROVEN at v = 5 - shareable class narrowed - no kappa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3031" + }, + "reviewed_head": "e75906fc4e8b9f756a9877b2e467f4e564851c7d", + "current_head": "e75906fc4e8b9f756a9877b2e467f4e564851c7d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: research/fstar-boxfloor-v5-seedab80f07c/predecessor/pr3012/predecessor/pr2978/data/box-search-kj-receipt.json: Expecting value: line 1 column 1 (char 0); research/fstar-boxfloor-v5-seedab80f07c/predecessor/pr3012/predecessor/pr2978/predecessor/pr2963/predecessor/pr2914/CERTIFICATE.json: Expecting value: line 1 column 1 (char 0). Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3032, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "5b1a7939393ef2778ec058ee8367cdad52c86fb3", + "isDraft": false, + "number": 3032, + "title": "Reject PR3019 fixed P104 matching with a monotone relay cut", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3032" + }, + "reviewed_head": "5b1a7939393ef2778ec058ee8367cdad52c86fb3", + "current_head": "5b1a7939393ef2778ec058ee8367cdad52c86fb3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-fixed-matching-flag-consistency" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3032", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3033, + "metadata": { + "author": { + "id": "U_kgDOCRtulg", + "is_bot": false, + "login": "tekuuu", + "name": "Tekalign" + }, + "headRefOid": "b12bbaeb5ca2e83f15433fc2dd0ba3b766595281", + "isDraft": false, + "number": 3033, + "title": "Research: exact four-bit reduction and faster P104 lifting reference", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3033" + }, + "reviewed_head": "b12bbaeb5ca2e83f15433fc2dd0ba3b766595281", + "current_head": "b12bbaeb5ca2e83f15433fc2dd0ba3b766595281", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-lifting-residue-reduction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3033", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3034, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "a05791d428f5d06802fb4c96b33732e6347c64eb", + "isDraft": false, + "number": 3034, + "title": "KB3i: the 18-point cover remainder for F2^7 - parity shortcut DEMOTED, m=5 obstruction localized (outcome=partial, no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3034" + }, + "reviewed_head": "a05791d428f5d06802fb4c96b33732e6347c64eb", + "current_head": "a05791d428f5d06802fb4c96b33732e6347c64eb", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/f7-18point-remainder-kb3i-a1" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3034", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3035, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "0cc430349a3f3dc200666bc22e997076e0a557ed", + "isDraft": false, + "number": 3035, + "title": "Certify a 343-bit coupled residue domain for P104 lifting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3035" + }, + "reviewed_head": "0cc430349a3f3dc200666bc22e997076e0a557ed", + "current_head": "0cc430349a3f3dc200666bc22e997076e0a557ed", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-coupled-lifting-residues" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3035", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3036, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "3717c1e684553c57bc73300410df65438a9ef095", + "isDraft": false, + "number": 3036, + "title": "Audit concrete rounding in the QQ16 F0 scalar projection", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3036" + }, + "reviewed_head": "3717c1e684553c57bc73300410df65438a9ef095", + "current_head": "3717c1e684553c57bc73300410df65438a9ef095", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-f0-rounded-scalar" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3036", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3037, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "02a1c41e8e016d3d0be64c62c8b4734f9c494236", + "isDraft": false, + "number": 3037, + "title": "Prove the P104 lifting translation lattice is maximal", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3037" + }, + "reviewed_head": "02a1c41e8e016d3d0be64c62c8b4734f9c494236", + "current_head": "02a1c41e8e016d3d0be64c62c8b4734f9c494236", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-maximal-translation-lattice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3037", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3038, + "metadata": { + "author": { + "id": "MDQ6VXNlcjI3NTY4NjE3", + "is_bot": false, + "login": "ToikY", + "name": "" + }, + "headRefOid": "c7d0d7be056ba77fda1c168641b2bcffb10cf43d", + "isDraft": false, + "number": 3038, + "title": "test(research): certify the V45 closed native endpoint cone", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3038" + }, + "reviewed_head": "c7d0d7be056ba77fda1c168641b2bcffb10cf43d", + "current_head": "c7d0d7be056ba77fda1c168641b2bcffb10cf43d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-native-cone-seed78" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3038", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3039, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "f0d6a48245e44fc29cfe077d21ca2521c2a8d941", + "isDraft": false, + "number": 3039, + "title": "Block-climb complete profile: exact obstruction for charged block-climb realization - no kappa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3039" + }, + "reviewed_head": "f0d6a48245e44fc29cfe077d21ca2521c2a8d941", + "current_head": "f0d6a48245e44fc29cfe077d21ca2521c2a8d941", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "The per-group inequality does not justify excluding every mixed complete profile. PR3066 supplies a free/charged cost-alphabet counterexample; scope the obstruction to individual charged groups and re-audit the call-level inference. No physical decoder or improved supplier follows from that counterexample.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3040, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "53fc5af5b778b8bbe6472d69a4f112d76febc108", + "isDraft": false, + "number": 3040, + "title": "Rank-8 rigidity of the E8 pattern with arbitrary extra zeros after deleting any at most 8 lines (hypothesis (1) of Lemma RIGD; no kappa claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3040" + }, + "reviewed_head": "53fc5af5b778b8bbe6472d69a4f112d76febc108", + "current_head": "53fc5af5b778b8bbe6472d69a4f112d76febc108", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/e8-rank8-rigidity-small-deletions/evidence/cubev8.out; missing flat manifest file research/e8-rank8-rigidity-small-deletions/evidence/R1-RIG3/fr_40.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3041, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b89c9eef729eb1e5889e2095d59a6fbf4738447d", + "isDraft": false, + "number": 3041, + "title": "Independently prove conditional selected residual/CALL refinement", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3041" + }, + "reviewed_head": "b89c9eef729eb1e5889e2095d59a6fbf4738447d", + "current_head": "b89c9eef729eb1e5889e2095d59a6fbf4738447d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/residual-call-refinement" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3041", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3042, + "metadata": { + "author": { + "id": "MDQ6VXNlcjExNDE0MjUx", + "is_bot": false, + "login": "dcharb78", + "name": "" + }, + "headRefOid": "84cc406ad91ec53fff329a11a445d7effe564a77", + "isDraft": false, + "number": 3042, + "title": "Conditional κ = 0.001729736166387916: six restore carrier/pivot skips (R1_E42, R2_E7) on PR2979's words and literal allocation", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3042" + }, + "reviewed_head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "current_head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-carrier-skips" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3042", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3043, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "b5cabfb02a3d8bc3121825144373b03a5648479d", + "isDraft": false, + "number": 3043, + "title": "Construct and price a reversible P104 residue extractor", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3043" + }, + "reviewed_head": "b5cabfb02a3d8bc3121825144373b03a5648479d", + "current_head": "b5cabfb02a3d8bc3121825144373b03a5648479d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-modular-residue-reducer" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3043", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3044, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1f922b25abff2d7fd87fa5b29619160862a06b59", + "isDraft": false, + "number": 3044, + "title": "feat(research): share the rank-seven restore covector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3044" + }, + "reviewed_head": "1f922b25abff2d7fd87fa5b29619160862a06b59", + "current_head": "1f922b25abff2d7fd87fa5b29619160862a06b59", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-shared-restore-fanin" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3044", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3045, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "16feea078f5542964ae85ca1b1f35bb94314ae78", + "isDraft": false, + "number": 3045, + "title": "Non-dense fitting B: every E8 term with x·y ≠ 0 has rank ≥ 9; square root-code floors E8 ≥ 72, P112 ≥ 64, P104 ≥ 56, D4 ≥ 12 for any fitting B (no κ claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3045" + }, + "reviewed_head": "16feea078f5542964ae85ca1b1f35bb94314ae78", + "current_head": "16feea078f5542964ae85ca1b1f35bb94314ae78", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/nondense-pairing-square-floors/evidence/a1_brute.log; missing flat manifest file research/nondense-pairing-square-floors/evidence/a1_e8.log. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3046, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "5549524f7894120b7e993522eb3a59956df5c5c3", + "isDraft": false, + "number": 3046, + "title": "Reuse the forward P104 residue basis for the exact inverse", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3046" + }, + "reviewed_head": "5549524f7894120b7e993522eb3a59956df5c5c3", + "current_head": "5549524f7894120b7e993522eb3a59956df5c5c3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-inverse-residue-permutation" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3046", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3047, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "8beaff37e90aa63141ec148ba85da4d6fc80c935", + "isDraft": false, + "number": 3047, + "title": "fix(tooling): name offending keys, caps and shapes in research package checks", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3047" + }, + "reviewed_head": "8beaff37e90aa63141ec148ba85da4d6fc80c935", + "current_head": "8beaff37e90aa63141ec148ba85da4d6fc80c935", + "disposition": "incorporated", + "github_state": "MERGED", + "integration_location": [ + "docs/research/research-package-guide.md", + "scripts/research_package.py", + "tests/test_research_package_diagnostics.py" + ], + "unresolved_question": "Scoped tooling/documentation integration complete; scientific and hosted/platform-specific replays are outside this review.", + "scope": "Reviewed tooling/documentation change; focused behavioral regressions and integration checks passed. No new mathematical validation.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_reviewed_tooling", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3047", + "merge_commit": "bc191093c71895ec9c70f238c58056e428b21847" + } + }, + { + "number": 3048, + "metadata": { + "author": { + "id": "MDQ6VXNlcjQ0MTczMTcz", + "is_bot": false, + "login": "flyingviper", + "name": "" + }, + "headRefOid": "71a0ec5012a04965826c62ad27532b5a4e014480", + "isDraft": false, + "number": 3048, + "title": "P112: exclude cost 296 in the aligned six-mode factor family", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3048" + }, + "reviewed_head": "71a0ec5012a04965826c62ad27532b5a4e014480", + "current_head": "71a0ec5012a04965826c62ad27532b5a4e014480", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p112-six-mode-exclusion" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3048", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3049, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "3d61d02651e4ba9d92229d9943d073e9c427ab95", + "isDraft": false, + "number": 3049, + "title": "Research: one-sided residue closures, part 2 — Lemma Q4, count lemma + E6 dim-cover and rerunnable span passes close 78 more of the 116 open residues (38 open; no kappa claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3049" + }, + "reviewed_head": "3d61d02651e4ba9d92229d9943d073e9c427ab95", + "current_head": "3d61d02651e4ba9d92229d9943d073e9c427ab95", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/one-sided-residue-closures-2/checks/all.out; missing flat manifest file research/one-sided-residue-closures-2/evidence/sc_rerun751/7-5-1-s0_M1r0J2j1.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3050, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "7c9d6b8b01606fa51032c0166f5ed522c8fa5735", + "isDraft": false, + "number": 3050, + "title": "test(research): independently audit the six restore skips", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3050" + }, + "reviewed_head": "7c9d6b8b01606fa51032c0166f5ed522c8fa5735", + "current_head": "7c9d6b8b01606fa51032c0166f5ed522c8fa5735", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-substitution-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3050", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3051, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMDk2NjQ=", + "is_bot": false, + "login": "jeremydiviney", + "name": "" + }, + "headRefOid": "10a45bd361554709840becb5bc26016ca49944c3", + "isDraft": false, + "number": 3051, + "title": "Verify six-skip/T740 release: conditional kappa 0.001729737950064279", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3051" + }, + "reviewed_head": "10a45bd361554709840becb5bc26016ca49944c3", + "current_head": "10a45bd361554709840becb5bc26016ca49944c3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-six-skip-cap-release" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3051", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3052, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "ae6dcf7e04de89198f8cd5321766d62bf6ee187b", + "isDraft": false, + "number": 3052, + "title": "Register the HPE post-wrapper uniqueness lemma (drawn card formal-interface-lemma)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3052" + }, + "reviewed_head": "ae6dcf7e04de89198f8cd5321766d62bf6ee187b", + "current_head": "ae6dcf7e04de89198f8cd5321766d62bf6ee187b", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/hpe-post-wrapper-lemma" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3052", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3053, + "metadata": { + "author": { + "id": "MDQ6VXNlcjE4NjIyMjg4", + "is_bot": false, + "login": "thakrarsagar", + "name": "" + }, + "headRefOid": "a977fd1989c092d6946766fe0e66625935799058", + "isDraft": false, + "number": 3053, + "title": "Independent verification (no κ): #3015's R1 restore edit on #2979's words is exact and correctly priced; R1 unique in its rewrite class; #3018 journal and #3021 composition reproduced; no defect found", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3053" + }, + "reviewed_head": "a977fd1989c092d6946766fe0e66625935799058", + "current_head": "a977fd1989c092d6946766fe0e66625935799058", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/t74-3015-restore-edit-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3053", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3054, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4773c3ea67b471415870e38411fae313ec44a675", + "isDraft": false, + "number": 3054, + "title": "feat(research): release the T740 six-skip composition", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3054" + }, + "reviewed_head": "4773c3ea67b471415870e38411fae313ec44a675", + "current_head": "4773c3ea67b471415870e38411fae313ec44a675", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-t740-carrier-skips" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3054", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3055, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "9dc841c9a101435fdd15e0f7623bf16b6d0363e9", + "isDraft": false, + "number": 3055, + "title": "Implement encoded physical Compact operations through B1", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3055" + }, + "reviewed_head": "9dc841c9a101435fdd15e0f7623bf16b6d0363e9", + "current_head": "9dc841c9a101435fdd15e0f7623bf16b6d0363e9", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/physical-complex-compact" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3055", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3056, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "9e4acb6049a6c1897ad8d515892f67204ab1d8c0", + "isDraft": false, + "number": 3056, + "title": "Contract PR3042's four-ADD restore block to three", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3056" + }, + "reviewed_head": "9e4acb6049a6c1897ad8d515892f67204ab1d8c0", + "current_head": "9e4acb6049a6c1897ad8d515892f67204ab1d8c0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-contraction" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3056", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3057, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "8892832224cffb73553cc921e4e3b1ae75d7b886", + "isDraft": false, + "number": 3057, + "title": "Prove the complete restore-frame optimum of the six-skip words", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3057" + }, + "reviewed_head": "8892832224cffb73553cc921e4e3b1ae75d7b886", + "current_head": "8892832224cffb73553cc921e4e3b1ae75d7b886", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-restore-frame-optimum" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3057", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3058, + "metadata": { + "author": { + "id": "MDQ6VXNlcjg2NDE2NTcy", + "is_bot": false, + "login": "conorholds", + "name": "conorholds" + }, + "headRefOid": "e67ca5f26351e09c5bb314821633e511212f88ec", + "isDraft": false, + "number": 3058, + "title": "Research: exact seven-source singleton minimum f(7) = 24", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3058" + }, + "reviewed_head": "e67ca5f26351e09c5bb314821633e511212f88ec", + "current_head": "e67ca5f26351e09c5bb314821633e511212f88ec", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/connector-covering-code" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3058", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3059, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "0b8b44c6cc367725a8737f8b3cd997f42d3bd0d9", + "isDraft": false, + "number": 3059, + "title": "Test pointwise P104 defect codes and the code-only update limit", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3059" + }, + "reviewed_head": "0b8b44c6cc367725a8737f8b3cd997f42d3bd0d9", + "current_head": "0b8b44c6cc367725a8737f8b3cd997f42d3bd0d9", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-pointwise-defect-consumer" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3059", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3060, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "df16ae619b858c5344a797c4424e0bafc2e69f62", + "isDraft": false, + "number": 3060, + "title": "Prove an optimal native tariff for the rank-seven restore block", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3060" + }, + "reviewed_head": "df16ae619b858c5344a797c4424e0bafc2e69f62", + "current_head": "df16ae619b858c5344a797c4424e0bafc2e69f62", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-native-tariff-optimum" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3060", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3063, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "3f384b8b7daccb2c8e12013fd81a738202ce0f8d", + "isDraft": false, + "number": 3063, + "title": "Prove exact dirty-output anchor child/ADD tariff frontier", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3063" + }, + "reviewed_head": "3f384b8b7daccb2c8e12013fd81a738202ce0f8d", + "current_head": "3f384b8b7daccb2c8e12013fd81a738202ce0f8d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/dirty-anchor-tradeoff" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3063", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3064, + "metadata": { + "author": { + "id": "U_kgDOFEm3gg", + "is_bot": false, + "login": "dataisfire", + "name": "dataisfire" + }, + "headRefOid": "239447f19b9365194bca2583014c947db5de8ea4", + "isDraft": false, + "number": 3064, + "title": "Propose conditional κ ≈ 0.001729737530919310 via T148 carrier skips (full replay pending)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3064" + }, + "reviewed_head": "239447f19b9365194bca2583014c947db5de8ea4", + "current_head": "239447f19b9365194bca2583014c947db5de8ea4", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-t148-restore-release", + "research/t148-carrier-skips" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa. Author reports resource-stopped full release; schedule a separately budgeted replay. Configuration review is not a successful hosted check.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Workflow configuration separately reviewed: manual-only, read-only, immutable actions, serial research replay group and 150-minute limit. No dispatch.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3065, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1cd7d3af6f41dc53e02c26f0b2cf6ffb11106fc8", + "isDraft": false, + "number": 3065, + "title": "Prove the complete joint A/B/restore frame optimum", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3065" + }, + "reviewed_head": "1cd7d3af6f41dc53e02c26f0b2cf6ffb11106fc8", + "current_head": "1cd7d3af6f41dc53e02c26f0b2cf6ffb11106fc8", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-joint-frame-optimum" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3065", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3066, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "8aa53674536727123436d3f76adb8f5dac6ddea1", + "isDraft": false, + "number": 3066, + "title": "Correct the mixed-profile inference in the block-climb screen", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3066" + }, + "reviewed_head": "8aa53674536727123436d3f76adb8f5dac6ddea1", + "current_head": "8aa53674536727123436d3f76adb8f5dac6ddea1", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/mixed-block-climb-overhead" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3066", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3067, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "e1e28b4070ae52efa5a9d0aa826bc588be7206f2", + "isDraft": false, + "number": 3067, + "title": "Bind the QQ16 F0 rounding witness to physical native execution", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3067" + }, + "reviewed_head": "e1e28b4070ae52efa5a9d0aa826bc588be7206f2", + "current_head": "e1e28b4070ae52efa5a9d0aa826bc588be7206f2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/qq16-f0-physical-rounding" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3067", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3068, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "7d2c519a1fdcc6bf66f6f08757eed7c48762d3f2", + "isDraft": false, + "number": 3068, + "title": "Certify a common invariant period lattice for P104 lifting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3068" + }, + "reviewed_head": "7d2c519a1fdcc6bf66f6f08757eed7c48762d3f2", + "current_head": "7d2c519a1fdcc6bf66f6f08757eed7c48762d3f2", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-invariant-lifting-lattice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3068", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3069, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "cd02d94c5eb3c0e1452cc94aeb2231c4d704a684", + "isDraft": false, + "number": 3069, + "title": "Price signed dependent-source delivery over characteristic zero", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3069" + }, + "reviewed_head": "cd02d94c5eb3c0e1452cc94aeb2231c4d704a684", + "current_head": "cd02d94c5eb3c0e1452cc94aeb2231c4d704a684", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/signed-dependent-delivery" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3069", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3070, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "3e9445ed10067912838bd83222ea4066dcfbc62d", + "isDraft": false, + "number": 3070, + "title": "Test P104 defect codes under restricted coordinate updates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3070" + }, + "reviewed_head": "3e9445ed10067912838bd83222ea4066dcfbc62d", + "current_head": "3e9445ed10067912838bd83222ea4066dcfbc62d", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-restricted-update-codes" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3070", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3071, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "6730b594ad6b0164d484ff1570d774d510fad130", + "isDraft": false, + "number": 3071, + "title": "Prove sharp selected-centre repair dimension for owner blocks up to six", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3071" + }, + "reviewed_head": "6730b594ad6b0164d484ff1570d774d510fad130", + "current_head": "6730b594ad6b0164d484ff1570d774d510fad130", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/centre-block-repair-information" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3071", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3072, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "cd1bbd05251f9d8e15cbb0192f1bfe83dc138f5e", + "isDraft": false, + "number": 3072, + "title": "Research: conditional blockwise P104 lifting at linear precision", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3072" + }, + "reviewed_head": "cd1bbd05251f9d8e15cbb0192f1bfe83dc138f5e", + "current_head": "cd1bbd05251f9d8e15cbb0192f1bfe83dc138f5e", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-blockwise-lifting" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3072", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3073, + "metadata": { + "author": { + "id": "MDQ6VXNlcjU2NTI3MTY=", + "is_bot": false, + "login": "RossRichardson", + "name": "Ross Richardson" + }, + "headRefOid": "9e808b67bc395dc91b55493a6fdce0863240bf1c", + "isDraft": false, + "number": 3073, + "title": "Factor P104 lifting defects through 201 exact real output channels", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3073" + }, + "reviewed_head": "9e808b67bc395dc91b55493a6fdce0863240bf1c", + "current_head": "9e808b67bc395dc91b55493a6fdce0863240bf1c", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/p104-defect-output-channels" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3073", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3074, + "metadata": { + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "3cc41f260c31052c933d0e75ea02f2b7677e780c", + "isDraft": false, + "number": 3074, + "title": "One-sided padding lemma: P112 to P120 at cost exactly +8 (L120 suffices for Delta >= n_nf)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3074" + }, + "reviewed_head": "3cc41f260c31052c933d0e75ea02f2b7677e780c", + "current_head": "3cc41f260c31052c933d0e75ea02f2b7677e780c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [], + "unresolved_question": "Source-integrity clarification required: missing flat manifest file research/one-sided-padding-lemma/expected/pad_audit.out. Restore missing/valid artifacts or explicitly separate generated outputs and inert predecessor evidence from the retained-source manifest. No mathematical rejection is inferred.", + "scope": "Source/intake triage only; unresolved obligation keeps the PR open.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ] + }, + { + "number": 3075, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "378b8e47fc01412cbc0bc49f0d7a3d40eb1d9442", + "isDraft": false, + "number": 3075, + "title": "Fully charged favourable relaxation for a k-call shared centre window", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3075" + }, + "reviewed_head": "378b8e47fc01412cbc0bc49f0d7a3d40eb1d9442", + "current_head": "378b8e47fc01412cbc0bc49f0d7a3d40eb1d9442", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/centre-shared-kcall-charged-seed615415" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3075", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3076, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "2037b8e4a8c03c2015f88904449f60d1fdf58ef3", + "isDraft": false, + "number": 3076, + "title": "Lower the complete rank-seven native bound by 340", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3076" + }, + "reviewed_head": "2037b8e4a8c03c2015f88904449f60d1fdf58ef3", + "current_head": "2037b8e4a8c03c2015f88904449f60d1fdf58ef3", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-commuting-contractions" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3076", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3077, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "9e52b244e07b1d981dd945bba7ac6c16fa7fdd43", + "isDraft": false, + "number": 3077, + "title": "Research: dirty-output anchor; no selected kappa improvement", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3077" + }, + "reviewed_head": "9e52b244e07b1d981dd945bba7ac6c16fa7fdd43", + "current_head": "9e52b244e07b1d981dd945bba7ac6c16fa7fdd43", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/complex-dirty-output-temporary-sum-anchor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3077", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3078, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "3da2ea9729f70b074713a5d0f69f0bdab32f2b47", + "isDraft": false, + "number": 3078, + "title": "Materialize rank-seven scalar lowerings with explicit width guards", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3078" + }, + "reviewed_head": "3da2ea9729f70b074713a5d0f69f0bdab32f2b47", + "current_head": "3da2ea9729f70b074713a5d0f69f0bdab32f2b47", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-primitive-lowering" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3078", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3079, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "8aee45e6a918c99cdca98431c3e791d2b3fd4206", + "isDraft": false, + "number": 3079, + "title": "Research: independently replay #2979 staged rank profile and T74 aggregate", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3079" + }, + "reviewed_head": "8aee45e6a918c99cdca98431c3e791d2b3fd4206", + "current_head": "8aee45e6a918c99cdca98431c3e791d2b3fd4206", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-v45-profile-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3079", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3080, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "fd5ff58c6c438c438481bc4bff8c86e2d4fbe865", + "isDraft": false, + "number": 3080, + "title": "Implement aligned bit circuits for the rank-seven ADD layer", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3080" + }, + "reviewed_head": "fd5ff58c6c438c438481bc4bff8c86e2d4fbe865", + "current_head": "fd5ff58c6c438c438481bc4bff8c86e2d4fbe865", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-aligned-bit-adders" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3080", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3081, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "d764f9c11c86c40d35fd67811e60284feb1b8f10", + "isDraft": false, + "number": 3081, + "title": "Implement a guarded bit caller for rank-seven dyadic ADDs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3081" + }, + "reviewed_head": "d764f9c11c86c40d35fd67811e60284feb1b8f10", + "current_head": "d764f9c11c86c40d35fd67811e60284feb1b8f10", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-fixed-width-half-add" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3081", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3082, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "c9c6b59ce5f526a0082d06b24470b7ac946e62da", + "isDraft": false, + "number": 3082, + "title": "Research: exact screen for kappa > 0.1 on selected suppliers", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3082" + }, + "reviewed_head": "c9c6b59ce5f526a0082d06b24470b7ac946e62da", + "current_head": "c9c6b59ce5f526a0082d06b24470b7ac946e62da", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/kappa01-target-screen" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3082", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3083, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "a2ff82111b42aa4abe38e2f8f0386c804111d17f", + "isDraft": false, + "number": 3083, + "title": "Certify rank-seven scalar grids and 77-bit endpoint formats", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3083" + }, + "reviewed_head": "a2ff82111b42aa4abe38e2f8f0386c804111d17f", + "current_head": "a2ff82111b42aa4abe38e2f8f0386c804111d17f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-coefficient-grid" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3083", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3084, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4b763c20da54e4e29e3edfdd1c3e251f5ede37e0", + "isDraft": false, + "number": 3084, + "title": "Prove exact alignment envelopes for rank-seven scalar streams", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3084" + }, + "reviewed_head": "4b763c20da54e4e29e3edfdd1c3e251f5ede37e0", + "current_head": "4b763c20da54e4e29e3edfdd1c3e251f5ede37e0", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/rank7-scalar-lattice" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3084", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3085, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "6d5db23b5ba34b20493fe9eea98d08682495a821", + "isDraft": false, + "number": 3085, + "title": "PR1 source and credit retention receipt (research consolidation, no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3085" + }, + "reviewed_head": "6d5db23b5ba34b20493fe9eea98d08682495a821", + "current_head": "6d5db23b5ba34b20493fe9eea98d08682495a821", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "integration_location": [ + "research/pr1-retention-receipt" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Source-only preservation does not validate a supplier, theorem, new kappa or selected-frontier change.", + "scope": "Source-only archival intake: full Git inventory, modes, Python/JSON syntax and available local manifest pins checked. No submitted scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": true + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-pass-20261016.json" + ], + "closure": { + "kind": "merged_for_archive_only", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3085", + "merge_commit": "5d93a572628653ad7a2d35c81a4e97c974fad3e2" + } + }, + { + "number": 3086, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "1e47220c44a90976f1b53289f643794bad1aadfe", + "isDraft": false, + "number": 3086, + "title": "Prove the sharp native format at the rank-seven A13 half-ADD", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3086" + }, + "reviewed_head": "1e47220c44a90976f1b53289f643794bad1aadfe", + "current_head": "1e47220c44a90976f1b53289f643794bad1aadfe", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-native-half-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3087, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "e7e49fb8176772c71ad7006920a407109a89e440", + "isDraft": false, + "number": 3087, + "title": "Implement encoded physical Gaussian monomial phases", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3087" + }, + "reviewed_head": "e7e49fb8176772c71ad7006920a407109a89e440", + "current_head": "e7e49fb8176772c71ad7006920a407109a89e440", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/physical-gaussian-monomial" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3088, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "19fefab093b802a58d0c432debfa72fa4b381b2d", + "isDraft": false, + "number": 3088, + "title": "Bind a physical four-ADD boundary and save 6,144 CNOTs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3088" + }, + "reviewed_head": "19fefab093b802a58d0c432debfa72fa4b381b2d", + "current_head": "19fefab093b802a58d0c432debfa72fa4b381b2d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-physical-a13" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3089, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "4a5ce834638534a5bfab1b5169c4a7210b2c0656", + "isDraft": false, + "number": 3089, + "title": "Certify an 84-bit conditional rank-seven A-stage format", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3089" + }, + "reviewed_head": "4a5ce834638534a5bfab1b5169c4a7210b2c0656", + "current_head": "4a5ce834638534a5bfab1b5169c4a7210b2c0656", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-native-a-format" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3090, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "47a2bcec53667f490df6d40550e14a8ae465cba4", + "isDraft": false, + "number": 3090, + "title": "Certify coefficient construction within the 84-bit A-stage bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3090" + }, + "reviewed_head": "47a2bcec53667f490df6d40550e14a8ae465cba4", + "current_head": "47a2bcec53667f490df6d40550e14a8ae465cba4", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-coefficient-capacity" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3091, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "d546815f4b116a79bd0ecec6661d2b2b3de29377", + "isDraft": false, + "number": 3091, + "title": "Implement fused physical Gaussian coefficient arithmetic", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3091" + }, + "reviewed_head": "d546815f4b116a79bd0ecec6661d2b2b3de29377", + "current_head": "d546815f4b116a79bd0ecec6661d2b2b3de29377", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/physical-gaussian-leaf" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3092, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "764123a9e18c9a838aee917af7657aa639804680", + "isDraft": false, + "number": 3092, + "title": "Independently audit the rank-seven coefficient-capacity claim", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3092" + }, + "reviewed_head": "764123a9e18c9a838aee917af7657aa639804680", + "current_head": "764123a9e18c9a838aee917af7657aa639804680", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-scalar-microstates" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3093, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf", + "isDraft": false, + "number": 3093, + "title": "Research: audit #2979 profile against kappa=0.1", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3093" + }, + "reviewed_head": "d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf", + "current_head": "d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/d7b545b12da3fc9751c2ea36f5efbf26e12dfcaf" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed. Complete original version retained in Git ancestry; existing main-tree package unchanged.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3094, + "metadata": { + "author": { + "id": "MDQ6VXNlcjc0MjEzNDY=", + "is_bot": false, + "login": "petalas", + "name": "Nick Petalas" + }, + "headRefOid": "b7a761ce2d6198509adb4b09ebf22b5b17ea2f55", + "isDraft": false, + "number": 3094, + "title": "Implement a guarded Boolean caller for the rank-seven scalar layer", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3094" + }, + "reviewed_head": "b7a761ce2d6198509adb4b09ebf22b5b17ea2f55", + "current_head": "b7a761ce2d6198509adb4b09ebf22b5b17ea2f55", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank7-boolean-scalar-caller" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3095, + "metadata": { + "author": { + "id": "MDQ6VXNlcjgwMjk5Njgz", + "is_bot": false, + "login": "CubeJerry", + "name": "" + }, + "headRefOid": "41826461eaceb25b77c026148b50b884e3c9780e", + "isDraft": false, + "number": 3095, + "title": "Audit one-sided padding: exact field scope and normalization costs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3095" + }, + "reviewed_head": "41826461eaceb25b77c026148b50b884e3c9780e", + "current_head": "41826461eaceb25b77c026148b50b884e3c9780e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/one-sided-padding-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3096, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "b5bb91b123697d9a818ae35d2e165478756c960a", + "isDraft": false, + "number": 3096, + "title": "Record the bit-0 census false prune on 01021323", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3096" + }, + "reviewed_head": "b5bb91b123697d9a818ae35d2e165478756c960a", + "current_head": "b5bb91b123697d9a818ae35d2e165478756c960a", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/f7-bit0-false-prune" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3097, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "ef7a52f4b0acf7cc8c51f9d81274d106abeffa24", + "isDraft": false, + "number": 3097, + "title": "Research: rule out seven-owner centre information compression", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3097" + }, + "reviewed_head": "ef7a52f4b0acf7cc8c51f9d81274d106abeffa24", + "current_head": "ef7a52f4b0acf7cc8c51f9d81274d106abeffa24", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/centre-seven-owner-information-floor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3098, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "ae54061980ef6a956d1276c7775aa833c1f669ca", + "isDraft": false, + "number": 3098, + "title": "Execute scalar recipes on encoded sequential tapes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3098" + }, + "reviewed_head": "ae54061980ef6a956d1276c7775aa833c1f669ca", + "current_head": "ae54061980ef6a956d1276c7775aa833c1f669ca", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/physical-scalar-stream" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3099, + "metadata": { + "author": { + "id": "MDQ6VXNlcjkxNzkyOQ==", + "is_bot": false, + "login": "jwr404", + "name": "James Reed" + }, + "headRefOid": "80b7b0b452de3c9fa4306f49d12e904a40cfbe2e", + "isDraft": false, + "number": 3099, + "title": "Record the selected scatter duplicate boundary", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3099" + }, + "reviewed_head": "80b7b0b452de3c9fa4306f49d12e904a40cfbe2e", + "current_head": "80b7b0b452de3c9fa4306f49d12e904a40cfbe2e", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/scatter-duplicate-boundary" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3100, + "metadata": { + "author": { + "id": "U_kgDOE8HONA", + "is_bot": false, + "login": "josecarlosgonzalezroque-design", + "name": "" + }, + "headRefOid": "72380f027199199ed4b4dbfc252ec39163acc56c", + "isDraft": false, + "number": 3100, + "title": "Audit fractional label coercion at the bit checker/exporter boundary", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3100" + }, + "reviewed_head": "72380f027199199ed4b4dbfc252ec39163acc56c", + "current_head": "72380f027199199ed4b4dbfc252ec39163acc56c", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/label-coordinate-boundary-audit" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3101, + "metadata": { + "author": { + "id": "U_kgDOB5L2iw", + "is_bot": false, + "login": "theon199", + "name": "Sricharan Vagvala" + }, + "headRefOid": "9a6d3b4e62cd41e25557511fa9b7ef270698c605", + "isDraft": false, + "number": 3101, + "title": "Research/qq16 native rounded audit", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3101" + }, + "reviewed_head": "9a6d3b4e62cd41e25557511fa9b7ef270698c605", + "current_head": "9a6d3b4e62cd41e25557511fa9b7ef270698c605", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/qq16-native-rounded-components" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3102, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "39bb449ef136cb3899ca16a6933abba52decf021", + "isDraft": false, + "number": 3102, + "title": "Allow research task selection from sparse checkouts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3102" + }, + "reviewed_head": "39bb449ef136cb3899ca16a6933abba52decf021", + "current_head": "39bb449ef136cb3899ca16a6933abba52decf021", + "disposition": "incorporated", + "github_state": "OPEN", + "integration_location": [ + "docs/research/agent-procedure.md", + "scripts/choose_research_task.py", + "tests/test_research_assignment.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3103, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "de12c885fb742735af90b496d30760b639fd6e5a", + "isDraft": false, + "number": 3103, + "title": "Independently verify all patterns in the T740 six-skip packing cap", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3103" + }, + "reviewed_head": "de12c885fb742735af90b496d30760b639fd6e5a", + "current_head": "de12c885fb742735af90b496d30760b639fd6e5a", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/t740-independent-packing-cap" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3104, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "107dd53ba63afb49688b830fc855829a1336a860", + "isDraft": false, + "number": 3104, + "title": "Fix stale commit attribution in PR path overlap reports", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3104" + }, + "reviewed_head": "107dd53ba63afb49688b830fc855829a1336a860", + "current_head": "107dd53ba63afb49688b830fc855829a1336a860", + "disposition": "incorporated", + "github_state": "OPEN", + "integration_location": [ + "docs/research/agent-procedure.md", + "scripts/find_overlap.py", + "tests/test_research_onboarding.py", + "tests/test_research_pr_file_pages.py" + ], + "unresolved_question": "No remaining scoped tooling obligation. Platform-specific skips and all scientific validation remain separate.", + "scope": "Shared tooling/source-binding review and focused affected regressions passed. No mathematical result changed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": true, + "required_execution_complete": true, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3105, + "metadata": { + "author": { + "id": "U_kgDOC__Fxw", + "is_bot": false, + "login": "Arham-Tahir64", + "name": "" + }, + "headRefOid": "7f6b0c765ffeaa6c75e692f73dbbad414e3d2453", + "isDraft": false, + "number": 3105, + "title": "Close the three-line F-star census remainder with a correct joint quotient", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3105" + }, + "reviewed_head": "7f6b0c765ffeaa6c75e692f73dbbad414e3d2453", + "current_head": "7f6b0c765ffeaa6c75e692f73dbbad414e3d2453", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/fstar-joint-label-census" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3106, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "1a9da866330d31d7b6edc5f514802a3ab2176f88", + "isDraft": false, + "number": 3106, + "title": "Bind and execute the first selected whole-family prefix", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3106" + }, + "reviewed_head": "1a9da866330d31d7b6edc5f514802a3ab2176f88", + "current_head": "1a9da866330d31d7b6edc5f514802a3ab2176f88", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/selected-first-prefix" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3107, + "metadata": { + "author": { + "id": "MDQ6VXNlcjM4NzQ0OTQ=", + "is_bot": false, + "login": "Gonzalo-Mier", + "name": "Gonzalo Mier" + }, + "headRefOid": "e697fb9ef8d57a3ddf843ac5a38ae70b3633ca6b", + "isDraft": false, + "number": 3107, + "title": "Kappa 0.1 budget screens; corrected paired-plane route", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3107" + }, + "reviewed_head": "e697fb9ef8d57a3ddf843ac5a38ae70b3633ca6b", + "current_head": "e697fb9ef8d57a3ddf843ac5a38ae70b3633ca6b", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/kappa010-complex-lever-floor", + "research/kappa010-rank-cap-floor" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3108, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "996a37e21d676a71d7f6df7e00513ce25d7f0f6d", + "isDraft": false, + "number": 3108, + "title": "KB3j: the (4,2) and (3,3) A-vanish walks - budget-honest partial with receipts; even-half self-sum profiles classified (outcome=partial; no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3108" + }, + "reviewed_head": "996a37e21d676a71d7f6df7e00513ce25d7f0f6d", + "current_head": "996a37e21d676a71d7f6df7e00513ce25d7f0f6d", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/f7-18point-av42-kb3j-b1" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3109, + "metadata": { + "author": { + "id": "U_kgDOBwp4BA", + "is_bot": false, + "login": "jmbarrancoml", + "name": "Jose Manuel" + }, + "headRefOid": "15eac811648182bdac7254a91fd9b841b1414ebc", + "isDraft": false, + "number": 3109, + "title": "Derive a batched reversible lifting bound with paid history", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3109" + }, + "reviewed_head": "15eac811648182bdac7254a91fd9b841b1414ebc", + "current_head": "15eac811648182bdac7254a91fd9b841b1414ebc", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/batched-spaced-lifting" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + }, + { + "number": 3110, + "metadata": { + "author": { + "id": "MDQ6VXNlcjUwMzY2Njc2", + "is_bot": false, + "login": "navinor", + "name": "Aaron Wang" + }, + "headRefOid": "f01a1bb3910cf27fd9ebacecaf90f503ca75e535", + "isDraft": false, + "number": 3110, + "title": "Rank-shape fully charged block-climb gate screen: exact zero-charge thresholds - no new kappa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3110" + }, + "reviewed_head": "f01a1bb3910cf27fd9ebacecaf90f503ca75e535", + "current_head": "f01a1bb3910cf27fd9ebacecaf90f503ca75e535", + "disposition": "partially_reviewed", + "github_state": "OPEN", + "integration_location": [ + "research/rank-shape-coframe-bill-seed850bc3" + ], + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa.", + "scope": "Source-only archival intake: exact Git inventory/modes, Python/JSON syntax and available local manifest pins checked. No scientific verifier executed.", + "review_completion": { + "changed_file_coverage": true, + "scoped_mechanism_review": false, + "required_execution_complete": false, + "published": false + }, + "verification_evidence": [ + "docs/research/pr-intake-evidence/queue-next-20261017.json" + ] + } + ] +} diff --git a/scripts/historical-ci-inputs/intake-starting-heads/README.md b/scripts/historical-ci-inputs/intake-starting-heads/README.md new file mode 100644 index 0000000000..12c293f4af --- /dev/null +++ b/scripts/historical-ci-inputs/intake-starting-heads/README.md @@ -0,0 +1,43 @@ +# Authenticated initial intake metadata + +These are byte-exact copies of docs/research/pr-intake-decisions.json from the +commits named by each filename. The checker pins both their Git blob SHA-1 and +SHA256 in INTAKE_HISTORY. They are new retained copies of existing history; +no original intake record, ledger value, source pin, or review receipt is edited. + +The ordered checkpoints preserve initial metadata before later intake updates +replaced it. In particular, PR3107 first appears with e697fb9e at 82d67beb; +PR3184 with ffab383a at 09fbc0f0; PR3251 with d7d62544 at 24db9bff. +Those are still the ledger's starting heads. The latest intake instead records +reviewed/current heads 7d40236b, 6faefe19, 3ffd42b3. They remain subject to the +unchanged current family, closure and review-completion checks. + +Sources (all at path docs/research/pr-intake-decisions.json): + +- https://github.com/CrocSwap/integer-mult-bounds/blob/82d67beb311be1b630eb95197492e6462eddccd8/docs/research/pr-intake-decisions.json + Git blob 7be7303ed7f9c83e01a3cceb99698ed672da4e41; SHA256 09d29d6cddea9ba382ee663262605c4ba4a4adc5cc9d572cd54bb37a1505cd65 +- https://github.com/CrocSwap/integer-mult-bounds/blob/09fbc0f002fc5b04814272c89edbd557b2a8285d/docs/research/pr-intake-decisions.json + Git blob 6c5a777a8221dc6e7866dcde0fff6b0aae58be33; SHA256 b149b6057fb72f9617bd48a5bb5b5d5dd548a955b89416d38449e1ecac3464a4 +- https://github.com/CrocSwap/integer-mult-bounds/blob/24db9bfffd4a7c812545ea6ae58853cb9ef094b2/docs/research/pr-intake-decisions.json + Git blob 021141eaa94d1768d997f0f246fa73b4a528db84; SHA256 3271e96c44d42fcae0f485abda725ff36c2f31b99ac740672787c108107410d4 + +All rows are processed in checkpoint order; the first observed metadata wins. +Immutable starting-snapshot and earlier family metadata take precedence. No +historical checkpoint can introduce a PR absent from the current intake source. +The current source supplies new arrivals and all current-state review decisions. +This is offline repository provenance validation, not a live GitHub-state check. + +When changing intake metadata for a later head, first retain the original exact +source checkpoint and register its independently authenticated commit/blob/hash +in chronological order. Never repair a failing initial-head guard by copying +expected values from the ledger, accepting any previous_head value, or changing +an existing pin. Add a new source checkpoint and strict rejection tests instead. +This policy keeps provenance loss visible rather than accepting arbitrary drift. + +The generator uses this same authenticated projection and records these source +hashes in future output. Its other accumulated intake-evidence differences still +require separate review: this repair does not make a full ledger regeneration +safe. The published ledger is not regenerated by this change. + +Substantial OpenAI assistance. Apache-2.0. + diff --git a/scripts/reconcile_pr_queue.py b/scripts/reconcile_pr_queue.py index f1cefee3b3..8d4799d305 100644 --- a/scripts/reconcile_pr_queue.py +++ b/scripts/reconcile_pr_queue.py @@ -18,6 +18,16 @@ def read(path): return json.loads((ROOT / path).read_text()) +def original_intake_metadata(rows): + """Use the checker's authenticated history, including in Git-free exports.""" + import importlib.util + spec = importlib.util.spec_from_file_location( + 'intake_history_checker', ROOT / 'scripts/verify_pr_reconciliation.py') + checker = importlib.util.module_from_spec(spec) + spec.loader.exec_module(checker) + return checker.authenticated_intake_starting_metadata(ROOT, rows), checker.INTAKE_HISTORY + + def apply_pr148_retention(item, receipt, coverage): """Index PR1572's source-only evidence without granting PR148 review. @@ -261,14 +271,20 @@ def add(number, head, evidence, scope, kind='review'): family_path = family_paths[-1] if family_paths else None for family_path in family_paths: family = load(family_path) + initial_metadata = {} + if family_path == 'docs/research/pr-intake-decisions.json': + initial_metadata, history = original_intake_metadata(family['pull_requests']) + for commit, _blob, digest in history: + sources['scripts/historical-ci-inputs/intake-starting-heads/' + commit + '.json'] = digest indexed = {p['number']: p for p in result} for decision in family['pull_requests']: n = decision['number'] if n not in indexed: pr = decision['metadata'] + initial = initial_metadata.get(n, pr) item = dict(number=n, url=f'https://github.com/CrocSwap/integer-mult-bounds/pull/{n}', - title=pr['title'], contributor=pr['author'], draft=pr['isDraft'], - starting_head=pr['headRefOid'], current_head=pr['headRefOid'], + title=pr['title'], contributor=initial['author'], draft=pr['isDraft'], + starting_head=initial['headRefOid'], current_head=pr['headRefOid'], previously_reviewed_heads=[], historical_assessment_heads=[], evidence=[], historical_mentions=[], integration_location=[], github_state='OPEN', closure=None) result.append(item) diff --git a/scripts/replay_historical_receipt.py b/scripts/replay_historical_receipt.py new file mode 100644 index 0000000000..b98c09457b --- /dev/null +++ b/scripts/replay_historical_receipt.py @@ -0,0 +1,344 @@ +#!/usr/bin/env python3 +"""Explicit historical-only replay of two frozen source/credit receipts. + +The generic live-input validator is unchanged. This adapter authenticates and +isolates original bytes; success never claims that today's inputs match them. +Prepared with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +import copy +from contextlib import contextmanager +import hashlib +import json +import os +from pathlib import Path +import re +import stat +import subprocess +import sys +import tempfile + +import research_package as replay + +ROOT = Path(__file__).resolve().parents[1] +FROZEN_COMMIT = "20ecf2891d80b5acf18d980b2164fb44ea7faa90" +# Changes to this explicit policy require review. No automatic historical +# fallback exists for other packages or for the default live validator. +POLICY = { + "research/pr636-family-witness-manifest-receipt": { + "package_commit": FROZEN_COMMIT, + "package_tree": "23693de73801a0987c80fb0eed1c8e45a5206890", + "base_commit": "1f7a934975e5eacaf83511c9ac870263bf095e05", + "manifest_sha256": { + "SOURCES.json": "9f18c9391184a197b338a1b3c7b43ddc571b2c49e5aac0f283e9e8e76d7d14f5", + "VERIFY.json": "18a182e83005ee6b9745037f524098dbd8b28b389a6213ef98b1010f3e8adb38", + }, + "inputs": ("docs/research/pr-ledger.json", "research/larger-gain/MANIFEST.json"), + "git_inputs": ("research/larger-gain/NOTICE", "research/larger-gain/README.md"), + }, + "research/pr1-retention-receipt": { + "package_commit": FROZEN_COMMIT, + "package_tree": "334d46aae47e139ca26229f8bf6e7d6556e585c8", + "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "manifest_sha256": { + "SOURCES.json": "8460f7af7e1b89f2389fcb1870eec63fc220d65ff6b0db41d0e5e735ca3c524d", + "VERIFY.json": "e070bc8ffc93911bdfc669671063f23dae1f0c290d5c72c82e1992a07beb4252", + }, + "inputs": ("CITATION.cff", "CONTRIBUTORS.md", "Makefile", "NOTICE", "README.md", + "docs/reproducibility.md", "docs/research/pr-ledger.json", + "research/overnight-pr-review-20261009/dispositions.json", + "research/overnight-pr-review-20261009/source-inventory.json"), + "git_inputs": (), + }, +} + + +ADAPTER = "scripts/replay_historical_receipt.py" +REGRESSION = "tests/test_research_historical_receipts.py" +WRAPPER_NOTICE = """ +## Explicit historical-only registered replay + +The registered command now authenticates and replays the original package at +`20ecf2891d80b5acf18d980b2164fb44ea7faa90` against its original pinned base. +It does not validate today's ledger, contributor list, or other live input +bytes. The original SOURCES.json, VERIFY.json, verifier and evidence are read +unchanged from that commit into an isolated temporary tree. Current source +rows keep their exact original commit/blob/SHA256 pins as historical provenance. + +Only these three wrapper files (README.md, SOURCES.json and VERIFY.json) may +differ from the frozen package, and the adapter checks their exact approved +transformation. All current verifier and evidence bytes must still equal the +original tree. The original positive and negative controls run without edits; +materialized and live package/input files must remain unchanged afterward. +`PASS_HISTORICAL_RECEIPT_ONLY` is a historical source/credit result, not a +current-state validation, new scientific acceptance, or closure decision. + +Run the historical adapter with Python 3.12: + +```sh +python3 -B scripts/replay_historical_receipt.py --package {package} +``` + +The generic runner's default live-input contract is unchanged. To inspect the +original live contract, replay the original frozen package metadata against live +inputs: it correctly rejects later byte drift. The registered wrapper declares +the adapter and its focused tests as inputs, so changes select these two +consumers without a global shared-workflow invalidation. See +[the replay guide](../../docs/research/research-package-guide.md#historical-sourcecredit-receipt-adapters). +""" + + +def wrapper_files(files, package): + """Exact, reviewable transformation; never accept arbitrary metadata drift.""" + sources = json.loads(files[package + "/SOURCES.json"][1]) + for row in sources["files"]: + row["usage"] = "provenance" + original = json.loads(files[package + "/VERIFY.json"][1]) + manifest = copy.deepcopy(original) + manifest["inputs"] = [*original["inputs"], ADAPTER, REGRESSION] + manifest["commands"] = [ + {"argv": ["{python}", "-B", ADAPTER, "--package", "{package}"], + "timeout_seconds": 480, + "checks": "Historical-only replay: authenticate the exact frozen package and original source pins, " + "run unchanged original commands and failure controls in an isolated Git snapshot, " + "and require historical/live bytes unchanged; does not validate today's input bytes."}, + {"argv": ["{python}", "-B", "-m", "unittest", "discover", "-s", "tests", + "-p", "test_research_historical_receipts.py", "-v"], + "timeout_seconds": 120, + "checks": "Focused historical-adapter regression controls for wrong history/pins, path aliases, " + "missing inputs, wrapper/code/evidence drift, isolation and unchanged-file gates; " + "the generic live-input validator remains strict."}, + ] + result = {package + "/" + name: ("100644", (json.dumps(value, indent=2) + "\n").encode()) + for name, value in (("SOURCES.json", sources), ("VERIFY.json", manifest))} + readme = files[package + "/README.md"][1] + result[package + "/README.md"] = ("100644", readme + WRAPPER_NOTICE.format(package=package).encode()) + return result + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def safe_path(name): + path = replay.canonical_relative_path(name) + need(".git" not in [part.lower().rstrip(" .") for part in path.parts] + and not name.startswith(":") and not any(ord(char) < 32 for char in name), "unsafe historical path: " + name) + return path + + +def git_environment(): + env = {key: value for key, value in os.environ.items() if not key.startswith("GIT_")} + env.update(GIT_NO_REPLACE_OBJECTS="1", GIT_CONFIG_NOSYSTEM="1", + GIT_CONFIG_GLOBAL=os.devnull, GIT_OPTIONAL_LOCKS="0", GIT_NO_LAZY_FETCH="1") + return env + + +def git(root, *args, **kwargs): + return subprocess.run(["git", "--no-replace-objects", "--literal-pathspecs", *args], + cwd=root, env=git_environment(), check=True, timeout=60, + stderr=subprocess.PIPE, **kwargs) + + +def output(root, *args): + return git(root, *args, stdout=subprocess.PIPE).stdout + + +def object_bytes(root, oid, kind): + need(isinstance(oid, str) and re.fullmatch(r"[0-9a-f]{40}", oid), "invalid historical object ID") + need(output(root, "cat-file", "-t", oid).strip() == kind.encode(), "wrong Git object type: " + oid) + raw = output(root, "cat-file", kind, oid) + actual = hashlib.sha1(kind.encode() + b" " + str(len(raw)).encode() + b"\0" + raw).hexdigest() + need(actual == oid, "Git object bytes do not match their ID: " + oid) + return raw + + +def tree_rows(root, commit, path=None, recursive=False): + argv = ["ls-tree", "-z"] + (["-r", "-t"] if recursive else []) + [commit] + if path is not None: + safe_path(path) + argv += ["--", path] + rows = {} + for record in output(root, *argv).split(b"\0"): + if not record: + continue + header, raw_path = record.split(b"\t", 1) + mode, kind, oid = header.decode("ascii").split() + name = raw_path.decode("utf-8") + safe_path(name) + need(name not in rows, "duplicate Git tree path: " + name) + rows[name] = (mode, kind, oid) + return rows + + +def pinned_file(root, commit, name): + rows = tree_rows(root, commit, name) + need(set(rows) == {name}, "missing exact historical input: " + name) + mode, kind, oid = rows[name] + need(mode in ("100644", "100755") and kind == "blob", "non-regular historical input: " + name) + return mode, oid, object_bytes(root, oid, "blob") + + +def package_snapshot(root, package): + safe_path(package) + directory = replay.symlink_free_relative_path(root, package) + need(directory.is_dir(), "missing live package: " + package) + names = [] + for parent, dirs, files in os.walk(directory, followlinks=False): + for name in dirs + files: + path = Path(parent) / name + need(not path.is_symlink(), "symlink in live package: " + str(path)) + names += [(Path(parent) / name).relative_to(root).as_posix() for name in files] + return file_snapshot(root, names) + + +def file_snapshot(root, names): + result = {} + for name in names: + safe_path(name) + path = replay.relative_file(root, name) + mode = path.stat().st_mode + need(stat.S_ISREG(mode), "non-regular live file: " + name) + result[name] = (stat.S_IMODE(mode), hashlib.sha256(path.read_bytes()).hexdigest()) + return result + + +def authenticate(root, package, policy): + package_commit, base = policy["package_commit"], policy["base_commit"] + # Grafts are rejected, not trusted as evidence; replacement objects and + # inherited Git config/environment are disabled in every Git operation. + grafts = Path(output(root, "rev-parse", "--git-path", "info/grafts").decode().strip()) + if not grafts.is_absolute(): + grafts = root / grafts + need(not grafts.exists() or not grafts.read_bytes().strip(), "legacy Git grafts are not supported") + objects = set() + for commit in {package_commit, base}: + raw = object_bytes(root, commit, "commit") + root_tree = raw.split(b"\n", 1)[0].decode().removeprefix("tree ") + object_bytes(root, root_tree, "tree") + objects.update((commit, root_tree)) + objects.update(row[2] for row in tree_rows(root, commit, recursive=True).values() if row[1] == "tree") + package_entry = tree_rows(root, package_commit, package).get(package) + need(package_entry == ("040000", "tree", policy["package_tree"]), "frozen package tree mismatch") + files = {} + for name, (mode, kind, oid) in tree_rows(root, package_commit, package, recursive=True).items(): + if kind == "tree": + continue + need(name.startswith(package + "/") and mode in ("100644", "100755") and kind == "blob", + "non-regular frozen package entry: " + name) + files[name] = (mode, object_bytes(root, oid, "blob")) + objects.add(oid) + for name, expected in policy["manifest_sha256"].items(): + need(hashlib.sha256(files[package + "/" + name][1]).hexdigest() == expected, + "frozen original manifest digest mismatch: " + name) + approved = {**files, **wrapper_files(files, package)} + live = package_snapshot(root, package) + need(set(live) == set(files), "live package inventory differs from the frozen original") + for name, (mode, raw) in approved.items(): + need(live[name][1] == hashlib.sha256(raw).hexdigest() + and bool(live[name][0] & 0o111) == (mode == "100755"), "live package drift: " + name) + sources = json.loads(files[package + "/SOURCES.json"][1]) + manifest = json.loads(files[package + "/VERIFY.json"][1]) + need(sources["base_commit"] == base, "historical base differs from approved policy") + need(manifest["inputs"] == list(policy["inputs"]), "historical input list differs from approved policy") + source_names = set() + for row in sources["files"]: + name = row["path"] + safe_path(name) + need(name not in source_names and name not in files, "duplicate or overlapping historical source: " + name) + source_names.add(name) + need(replay.source_pin(row, base) == base + ":" + name, "only approved base-commit source pins are supported") + mode, oid, raw = pinned_file(root, base, name) + need(oid == row["git_blob"], "historical input Git blob mismatch: " + name) + need(hashlib.sha256(raw).hexdigest() == row["sha256"], "historical input SHA256 mismatch: " + name) + files[name] = (mode, raw) + objects.add(oid) + need({row["path"] for row in sources["files"] if row["usage"] == "input"} == set(policy["inputs"]), + "historical live-input pins differ from approved policy") + for name in policy["git_inputs"]: + _, oid, _ = pinned_file(root, base, name) + objects.add(oid) + # These live bytes may differ from history. Keep them intact, never replace + # them with old contributors, ledger rows, or other historical input data. + live_inputs = file_snapshot(root, [*policy["inputs"], ADAPTER, REGRESSION]) + return files, objects, live, live_inputs + + +def materialize(root, temporary, files, objects, package_commit): + git(temporary, "init", "--quiet", "--template=") + # Self-contained object copy: no worktree, alternates, shared object store, + # links, hooks, refs, or config from the live repository are exposed. + with tempfile.TemporaryFile() as pack: + git(root, "pack-objects", "--stdout", input=("\n".join(sorted(objects)) + "\n").encode(), stdout=pack) + pack.seek(0) + git(temporary, "index-pack", "--stdin", stdin=pack, stdout=subprocess.PIPE) + git(temporary, "update-ref", "--no-deref", "HEAD", package_commit) + for name, (mode, raw) in files.items(): + safe_path(name) + path = temporary / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(raw) + path.chmod(0o755 if mode == "100755" else 0o644) + + +@contextmanager +def replay_environment(): + previous = os.environ.copy() + clean = {key: value for key, value in git_environment().items() if not key.startswith("PYTHON")} + clean["PYTHONDONTWRITEBYTECODE"] = "1" + os.environ.clear() + os.environ.update(clean) + try: + yield + finally: + os.environ.clear() + os.environ.update(previous) + + +def run(root, package, check_only=False): + need(package in POLICY, "package is not approved for historical-only replay: " + package) + policy = POLICY[package] + files, objects, live_package, live_inputs = authenticate(root, package, policy) + print("HISTORICAL_INPUTS_ONLY package=" + package + " base=" + policy["base_commit"] + + " package_commit=" + policy["package_commit"] + + " (no validation of today's input bytes)", flush=True) + try: + with tempfile.TemporaryDirectory(prefix="historical-receipt-") as directory: + isolated = Path(directory) + materialize(root, isolated, files, objects, policy["package_commit"]) + before = file_snapshot(isolated, files) + before_package = package_snapshot(isolated, package) + try: + with replay_environment(): + if check_only: + replay.validate(isolated, package) + else: + replay.run_package(isolated, package) + finally: + need(file_snapshot(isolated, files) == before + and package_snapshot(isolated, package) == before_package, + "historical replay changed its materialized source/evidence files") + finally: + need(package_snapshot(root, package) == live_package + and file_snapshot(root, live_inputs) == live_inputs, + "live package or inputs changed during historical replay") + label = "PASS_HISTORICAL_METADATA_ONLY" if check_only else "PASS_HISTORICAL_RECEIPT_ONLY" + print(label + " " + package + " base=" + policy["base_commit"] + + " package_commit=" + policy["package_commit"] + + " live_inputs_validated=false") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--package", required=True) + parser.add_argument("--check-only", action="store_true") + args = parser.parse_args() + try: + run(ROOT, args.package, args.check_only) + except (OSError, ValueError, KeyError, TypeError, subprocess.SubprocessError) as exc: + parser.exit(1, str(exc) + "\n") + + +if __name__ == "__main__": + main() diff --git a/scripts/verify_pr_reconciliation.py b/scripts/verify_pr_reconciliation.py index cd0abfd7a3..829af45943 100644 --- a/scripts/verify_pr_reconciliation.py +++ b/scripts/verify_pr_reconciliation.py @@ -11,16 +11,79 @@ import zipfile import subprocess import sys +import re ROOT = Path(__file__).resolve().parents[1] AUDIT = ROOT / 'research/pr-reconciliation-20261012' +# Original bytes of docs/research/pr-intake-decisions.json at these commits. +# Intake metadata is mutable; these ordered checkpoints retain first appearances +# before later exact-head reviews replaced it. Never infer history from a ledger. +# Source commit, Git blob, SHA256; the complete source files are preserved below. +INTAKE_HISTORY = ( + ('82d67beb311be1b630eb95197492e6462eddccd8', + '7be7303ed7f9c83e01a3cceb99698ed672da4e41', + '09d29d6cddea9ba382ee663262605c4ba4a4adc5cc9d572cd54bb37a1505cd65'), + ('09fbc0f002fc5b04814272c89edbd557b2a8285d', + '6c5a777a8221dc6e7866dcde0fff6b0aae58be33', + 'b149b6057fb72f9617bd48a5bb5b5d5dd548a955b89416d38449e1ecac3464a4'), + ('24db9bfffd4a7c812545ea6ae58853cb9ef094b2', + '021141eaa94d1768d997f0f246fa73b4a528db84', + '3271e96c44d42fcae0f485abda725ff36c2f31b99ac740672787c108107410d4'), +) + def require(condition, message): if not condition: raise ValueError(message) +def project_intake_starting_metadata(history, current_rows): + """Keep each first authenticated appearance, with no ledger-value fallback. + + History changes only initial metadata, never current review/closure evidence. + Require historical membership to remain visible in the current intake source. + Substantial OpenAI assistance; Apache-2.0. + """ + current_numbers = [row['number'] for row in current_rows] + require(all(type(number) is int and number > 0 for number in current_numbers) + and len(current_numbers) == len(set(current_numbers)), 'Invalid current intake PR set') + current_numbers = set(current_numbers) + first = {} + for rows in history: + numbers = [row['number'] for row in rows] + require(all(type(number) is int and number > 0 for number in numbers) + and len(numbers) == len(set(numbers)), 'Duplicate or invalid historical intake PR') + require(set(numbers) <= current_numbers, 'Historical intake PR missing from current source') + for row in rows: + metadata = row['metadata'] + require(type(metadata.get('number')) is int and metadata['number'] == row['number'], + 'Historical intake metadata number mismatch') + require(isinstance(metadata.get('headRefOid'), str) + and re.fullmatch('[0-9a-f]{40}', metadata['headRefOid']) + and isinstance(metadata.get('author'), dict), 'Invalid historical intake metadata') + first.setdefault(row['number'], deepcopy(metadata)) + return first + + +def authenticated_intake_starting_metadata(root, current_rows): + """Authenticate full original source blobs without requiring Git or network.""" + directory = root / 'scripts/historical-ci-inputs/intake-starting-heads' + require(all(not path.is_symlink() for path in + (root, root / 'scripts', directory.parent, directory)), + 'Linked historical intake source directory') + history = [] + for commit, blob, digest in INTAKE_HISTORY: + path = directory / (commit + '.json') + require(path.is_file() and not path.is_symlink(), 'Missing or linked historical intake source') + raw = path.read_bytes() + require(hashlib.sha256(raw).hexdigest() == digest, 'Changed historical intake source: ' + commit) + identity = hashlib.sha1(b'blob ' + str(len(raw)).encode('ascii') + b'\0' + raw).hexdigest() + require(identity == blob, 'Historical intake Git blob mismatch: ' + commit) + history.append(json.loads(raw)['pull_requests']) + return project_intake_starting_metadata(history, current_rows) + + def check_batch1047_file(item): """Preserve the pinned Makefile prefix after batch1099 appends reviewed targets. @@ -297,6 +360,11 @@ def main(): if not family_path.exists(): continue family = json.loads(family_path.read_text()) + if family_path == ROOT / 'docs/research/pr-intake-decisions.json': + initial = authenticated_intake_starting_metadata(ROOT, family['pull_requests']) + for number, metadata in initial.items(): + # Immutable starting snapshot and earlier family rounds win. + expected.setdefault(number, metadata) family_rounds.append(family['pull_requests']) numbers = [p['number'] for p in family['pull_requests']] require(len(numbers) == len(set(numbers)), 'Duplicate family PR') diff --git a/tests/test_pr_reconciliation.py b/tests/test_pr_reconciliation.py index 0266367d1c..44d763c5ef 100644 --- a/tests/test_pr_reconciliation.py +++ b/tests/test_pr_reconciliation.py @@ -14,6 +14,125 @@ spec.loader.exec_module(checker) +class IntakeStartingHistory(unittest.TestCase): + def row(self, number, head): + return dict(number=number, metadata=dict(number=number, headRefOid=head * 40, + author={'login': 'original'})) + + def test_ordered_first_appearance_and_source_immutability(self): + history = [[self.row(7, 'a')], [self.row(7, 'b'), self.row(8, 'c')]] + current = [self.row(7, 'd'), self.row(8, 'e'), self.row(9, 'f')] + before = deepcopy((history, current)) + got = checker.project_intake_starting_metadata(history, current) + self.assertEqual({n: row['headRefOid'] for n, row in got.items()}, + {7: 'a' * 40, 8: 'c' * 40}) + got[7]['author']['login'] = 'mutation' + self.assertEqual((history, current), before) + + def test_missing_extra_duplicate_and_malformed_history_reject(self): + current = [self.row(7, 'b')] + mutations = [[self.row(8, 'a')], [self.row(7, 'a'), self.row(7, 'b')], + [self.row(True, 'a')], [dict(number=7, metadata=self.row(8, 'a')['metadata'])], + [self.row(7, 'z')]] + for rows in mutations: + with self.subTest(rows=rows), self.assertRaises(ValueError): + checker.project_intake_starting_metadata([rows], current) + with self.assertRaises(ValueError): + checker.project_intake_starting_metadata([[self.row(7, 'a')]], []) + with self.assertRaises(ValueError): + checker.project_intake_starting_metadata([], current + current) + + def test_complete_current_starting_metadata_matches_original_sources(self): + snapshot = json.loads((checker.AUDIT / 'starting-snapshot.json').read_text()) + expected = {row['number']: row for row in snapshot['pull_requests']} + for path in checker.decision_paths(): + if not path.exists(): + continue + rows = json.loads(path.read_text())['pull_requests'] + if path.name == 'pr-intake-decisions.json': + initial = checker.authenticated_intake_starting_metadata(ROOT, rows) + for number, metadata in initial.items(): + expected.setdefault(number, metadata) + for row in rows: + expected.setdefault(row['number'], row['metadata']) + ledger = json.loads((ROOT / 'docs/research/pr-ledger.json').read_text()) + self.assertEqual(len(expected), len(ledger['pull_requests'])) + for item in ledger['pull_requests']: + with self.subTest(number=item['number']): + self.assertEqual(item['starting_head'], expected[item['number']]['headRefOid']) + self.assertEqual(item['contributor'], expected[item['number']]['author']) + + def test_changed_swapped_or_forged_pinned_source_rejects(self): + rows = json.loads((ROOT / 'docs/research/pr-intake-decisions.json').read_text())['pull_requests'] + directory = ROOT / 'scripts/historical-ci-inputs/intake-starting-heads' + path = directory / (checker.INTAKE_HISTORY[0][0] + '.json') + original = path.read_bytes() + other = (directory / (checker.INTAKE_HISTORY[1][0] + '.json')).read_bytes() + read_bytes = Path.read_bytes + for changed in (original + b' ', other): + def read(p): + return changed if p == path else read_bytes(p) + with patch.object(Path, 'read_bytes', read), self.assertRaisesRegex(ValueError, 'Changed historical'): + checker.authenticated_intake_starting_metadata(ROOT, rows) + commit, blob, digest = checker.INTAKE_HISTORY[0] + forged = ((commit, '0' * 40, digest), *checker.INTAKE_HISTORY[1:]) + with patch.object(checker, 'INTAKE_HISTORY', forged), self.assertRaisesRegex(ValueError, 'Git blob mismatch'): + checker.authenticated_intake_starting_metadata(ROOT, rows) + + def test_missing_and_linked_source_rejects(self): + with tempfile.TemporaryDirectory() as td: + root = Path(td) + with self.assertRaisesRegex(ValueError, 'Missing or linked'): + checker.authenticated_intake_starting_metadata(root, []) + directory = root / 'scripts/historical-ci-inputs/intake-starting-heads' + directory.mkdir(parents=True) + original = ROOT / 'scripts/historical-ci-inputs/intake-starting-heads' / (checker.INTAKE_HISTORY[0][0] + '.json') + (directory / original.name).symlink_to(original) + with self.assertRaisesRegex(ValueError, 'Missing or linked'): + checker.authenticated_intake_starting_metadata(root, []) + + def test_entrypoint_rejects_forged_starting_and_current_heads(self): + ledger = json.loads((ROOT / 'docs/research/pr-ledger.json').read_text()) + original_read = Path.read_text + for number in (3107, 3184, 3251): + for field in ('starting_head', 'reviewed_head', 'current_head'): + changed = deepcopy(ledger) + item = next(row for row in changed['pull_requests'] if row['number'] == number) + item[field] = '0' * 40 + def read(path, *args, **kwargs): + return json.dumps(changed) if path == ROOT / 'docs/research/pr-ledger.json' else original_read(path, *args, **kwargs) + expected = 'starting head' if field == 'starting_head' else field + with self.subTest(number=number, field=field), patch.object(Path, 'read_text', read), self.assertRaisesRegex(ValueError, f'#{number}:.*{expected}'): + checker.main() + + def test_generator_keeps_original_heads_without_writing_evidence(self): + spec = importlib.util.spec_from_file_location('history_aware_generator', + ROOT / 'scripts/reconcile_pr_queue.py') + generator = importlib.util.module_from_spec(spec) + spec.loader.exec_module(generator) + outputs = {} + permitted = {ROOT / 'docs/research/pr-ledger.json', ROOT / 'docs/research/pr-ledger.md'} + def capture(path, content, *args, **kwargs): + self.assertIn(path, permitted) + outputs[path] = content + return len(content) + original = (ROOT / 'docs/research/pr-ledger.json').read_bytes() + with patch.object(Path, 'write_text', capture), patch('builtins.print'): + generator.build() + self.assertEqual((ROOT / 'docs/research/pr-ledger.json').read_bytes(), original) + self.assertEqual(set(outputs), permitted) + rebuilt = json.loads(outputs[ROOT / 'docs/research/pr-ledger.json']) + actual = {row['number']: row for row in json.loads(original)['pull_requests']} + self.assertEqual(len(rebuilt['pull_requests']), len(actual)) + for row in rebuilt['pull_requests']: + for field in ('starting_head', 'contributor', 'current_head', 'reviewed_head'): + with self.subTest(number=row['number'], field=field): + self.assertEqual(row.get(field), actual[row['number']].get(field)) + for commit, _blob, digest in checker.INTAKE_HISTORY: + name = 'scripts/historical-ci-inputs/intake-starting-heads/' + commit + '.json' + self.assertEqual(rebuilt['source_sha256'][name], digest) + + class FamilyClosureProjection(unittest.TestCase): def decision(self, number=7): return dict(number=number, reviewed_head='a' * 40, current_head='a' * 40, diff --git a/tests/test_research_historical_receipts.py b/tests/test_research_historical_receipts.py new file mode 100644 index 0000000000..8c70fbfaf1 --- /dev/null +++ b/tests/test_research_historical_receipts.py @@ -0,0 +1,355 @@ +"""Synthetic Git controls for explicit historical-only receipt adaptation. + +No network, original evidence rewriting, or mathematical suite is required. +""" +import contextlib +import copy +import hashlib +import io +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest +from unittest import mock + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts")) +import replay_historical_receipt as historical +import research_package as replay + +PACKAGE = "research/pr1-retention-receipt" +INPUT = "docs/input.txt" +CATALOG = "docs/research/agent-task-catalog.json" + + +class HistoricalReceiptTests(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory(prefix="test-historical-") + self.addCleanup(self.tmp.cleanup) + self.root = Path(self.tmp.name) + self.git("init", "--quiet", "--template=") + self.git("config", "user.name", "Historical fixture") + self.git("config", "user.email", "fixture@example.invalid") + self.put(INPUT, b"original input\n") + card = {"id": "receipt", "question": "historical source check"} + self.put(CATALOG, json.dumps({"tracks": [{"tasks": [card]}]})) + self.put(historical.ADAPTER, b"# fixture adapter input\n") + self.put(historical.REGRESSION, b"# fixture regression input\n") + self.base = self.commit() + self.sources = {"schema_version": 1, "base_commit": self.base, "files": [ + self.source_row(INPUT, "input"), self.source_row(CATALOG, "provenance")]} + self.manifest = {"schema_version": 1, "status": "ready", "python": "3.12", + "requirements": [], "inputs": [INPUT], "commands": [{ + "argv": ["{python}", "-B", "{package}/verify.py"], + "timeout_seconds": 10, "checks": "Original input and assertion control"}]} + task = {"schema_version": 1, "base_commit": self.base, "task_id": "receipt", + "original_card": card, "scope_status": "refined", "scope_change_reason": "fixture", + "actual_scope": "historical receipt fixture", "outcome": "completed", + "bottleneck_link": "fixture", "stop_rule": "one check", "evidence": "verifier", + "author": "fixture", "ai_assistance": "fixture", "open_questions": [], + "no_open_questions_reason": "bounded fixture"} + self.put(PACKAGE + "/TASK.json", json.dumps(task)) + self.original_readme = "## Open next questions\nBounded fixture\n" + self.put(PACKAGE + "/README.md", self.original_readme) + self.put(PACKAGE + "/verify.py", "from pathlib import Path\n" + "assert __debug__, 'assertions were disabled'\n" + "assert Path('docs/input.txt').read_bytes() == b'original input\\n'\n" + "print('PASS_ORIGINAL_CONTROL')\n") + self.freeze() + self.put(INPUT, b"current input with later credit\n") + self.commit() + self.patch = mock.patch.dict(historical.POLICY, {PACKAGE: self.policy}, clear=True) + self.patch.start() + self.addCleanup(self.patch.stop) + + def git(self, *args): + return subprocess.run(["git", *args], cwd=self.root, check=True, + stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout + + def put(self, name, value): + path = self.root / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(value.encode() if isinstance(value, str) else value) + + def commit(self): + self.git("add", "--all") + self.git("commit", "--quiet", "-m", "fixture") + return self.git("rev-parse", "HEAD").decode().strip() + + def source_row(self, name, usage): + return {"path": name, "usage": usage, + "git_blob": self.git("rev-parse", self.base + ":" + name).decode().strip(), + "sha256": hashlib.sha256((self.root / name).read_bytes()).hexdigest()} + + def freeze(self): + self.put(PACKAGE + "/README.md", self.original_readme) + self.put(PACKAGE + "/SOURCES.json", json.dumps(self.sources)) + self.put(PACKAGE + "/VERIFY.json", json.dumps(self.manifest)) + commit = self.commit() + self.policy = {"package_commit": commit, + "package_tree": self.git("rev-parse", commit + ":" + PACKAGE).decode().strip(), + "base_commit": self.base, "inputs": (INPUT,), "git_inputs": (), + "manifest_sha256": {name: hashlib.sha256((self.root / PACKAGE / name).read_bytes()).hexdigest() + for name in ("SOURCES.json", "VERIFY.json")}} + original = {PACKAGE + "/" + name: ("100644", (self.root / PACKAGE / name).read_bytes()) + for name in ("SOURCES.json", "VERIFY.json", "README.md")} + for name, (_, raw) in historical.wrapper_files(original, PACKAGE).items(): + self.put(name, raw) + if hasattr(self, "patch"): + historical.POLICY[PACKAGE] = self.policy + + def run_receipt(self, check_only=False): + with contextlib.redirect_stdout(io.StringIO()) as text: + historical.run(self.root, PACKAGE, check_only=check_only) + return text.getvalue() + + def test_positive_historical_replay_keeps_live_bytes_and_git_unchanged(self): + before = historical.package_snapshot(self.root, PACKAGE) + live = (self.root / INPUT).read_bytes() + git_before = {p.relative_to(self.root).as_posix(): p.read_bytes() + for p in (self.root / ".git").rglob("*") if p.is_file()} + result = self.run_receipt() + self.assertIn("PASS_HISTORICAL_RECEIPT_ONLY", result) + self.assertIn("live_inputs_validated=false", result) + self.assertEqual((self.root / INPUT).read_bytes(), live) + self.assertEqual(historical.package_snapshot(self.root, PACKAGE), before) + git_after = {p.relative_to(self.root).as_posix(): p.read_bytes() + for p in (self.root / ".git").rglob("*") if p.is_file()} + self.assertEqual(git_before, git_after) + + def test_default_live_validation_still_fails(self): + for _ in range(2): + wrapped = {name: (self.root / PACKAGE / name).read_bytes() + for name in ("SOURCES.json", "VERIFY.json")} + try: + for name in wrapped: + self.put(PACKAGE + "/" + name, self.git("show", self.policy["package_commit"] + ":" + PACKAGE + "/" + name)) + with self.assertRaisesRegex(ValueError, "working source drift"): + replay.validate(self.root, PACKAGE) + finally: + for name, raw in wrapped.items(): + self.put(PACKAGE + "/" + name, raw) + self.run_receipt(check_only=True) + + def test_arbitrary_wrapper_metadata_drift_rejected(self): + for name in ("SOURCES.json", "VERIFY.json", "README.md"): + with self.subTest(name=name): + path = self.root / PACKAGE / name + original = path.read_bytes() + try: + path.write_bytes(original + b" ") + with self.assertRaisesRegex(ValueError, "live package drift"): + self.run_receipt() + finally: + path.write_bytes(original) + + def test_original_manifest_digest_mismatch_rejected(self): + historical.POLICY[PACKAGE]["manifest_sha256"]["VERIFY.json"] = "0" * 64 + with self.assertRaisesRegex(ValueError, "original manifest digest mismatch"): + self.run_receipt() + + def test_metadata_only_is_not_labelled_receipt_success(self): + result = self.run_receipt(check_only=True) + self.assertIn("PASS_HISTORICAL_METADATA_ONLY", result) + self.assertNotIn("PASS_HISTORICAL_RECEIPT_ONLY", result) + + def test_unknown_package_fails_closed(self): + with self.assertRaisesRegex(ValueError, "not approved"): + historical.run(self.root, "research/other") + + def test_wrong_frozen_commit_rejected(self): + historical.POLICY[PACKAGE]["package_commit"] = "0" * 40 + with self.assertRaises(subprocess.CalledProcessError): + self.run_receipt() + + def test_wrong_frozen_package_tree_rejected(self): + historical.POLICY[PACKAGE]["package_tree"] = "0" * 40 + with self.assertRaisesRegex(ValueError, "package tree mismatch"): + self.run_receipt() + + def test_wrong_history_base_rejected(self): + historical.POLICY[PACKAGE]["base_commit"] = historical.POLICY[PACKAGE]["package_commit"] + with self.assertRaisesRegex(ValueError, "base differs"): + self.run_receipt() + + def test_wrong_blob_pin_rejected(self): + self.sources["files"][0]["git_blob"] = "0" * 40 + self.freeze() + with self.assertRaisesRegex(ValueError, "Git blob mismatch"): + self.run_receipt() + + def test_wrong_sha256_pin_rejected(self): + self.sources["files"][0]["sha256"] = "0" * 64 + self.freeze() + with self.assertRaisesRegex(ValueError, "SHA256 mismatch"): + self.run_receipt() + + def test_foreign_head_pin_rejected(self): + self.sources["files"][0]["pin"] = "head:" + self.base + ":" + INPUT + self.freeze() + # The supported general resolver yields the same base expression. A + # genuinely different commit is what must not replace the approved base. + self.sources["files"][0]["pin"] = "head:" + "f" * 40 + ":" + INPUT + self.freeze() + with self.assertRaisesRegex(ValueError, "base-commit source pins"): + self.run_receipt() + + def test_undeclared_input_rejected(self): + self.manifest["inputs"] = [] + self.freeze() + with self.assertRaisesRegex(ValueError, "input list differs"): + self.run_receipt() + + def test_missing_historical_input_rejected(self): + self.sources["files"][0]["path"] = "docs/missing.txt" + self.freeze() + with self.assertRaisesRegex(ValueError, "missing exact historical input"): + self.run_receipt() + + def test_duplicate_pin_rejected(self): + self.sources["files"].append(copy.deepcopy(self.sources["files"][0])) + self.freeze() + with self.assertRaisesRegex(ValueError, "duplicate or overlapping"): + self.run_receipt() + + def test_malicious_paths_rejected(self): + for name in ("../escape", "/escape", "docs/../input.txt", "docs//input.txt", + "./docs/input.txt", "docs\\input.txt", ".git/config", "docs/.GiT/config", + "docs/input\n.txt", "docs/input\x00.txt", ":(glob)*"): + with self.subTest(name=name): + with self.assertRaises(ValueError): + historical.safe_path(name) + + def test_traversal_in_authenticated_sources_rejected(self): + self.sources["files"][0]["path"] = "../escape" + self.freeze() + with self.assertRaisesRegex(ValueError, "canonical"): + self.run_receipt() + + def test_live_package_drift_rejected(self): + self.put(PACKAGE + "/verify.py", "print('fake success')\n") + with self.assertRaisesRegex(ValueError, "live package drift"): + self.run_receipt() + + def test_extra_live_package_file_rejected(self): + self.put(PACKAGE + "/extra.py", "print('untracked')\n") + with self.assertRaisesRegex(ValueError, "inventory differs"): + self.run_receipt() + + def test_live_package_symlink_rejected(self): + (self.root / PACKAGE / "link").symlink_to(self.root / INPUT) + with self.assertRaisesRegex(ValueError, "symlink"): + self.run_receipt() + + def test_frozen_package_symlink_rejected(self): + (self.root / PACKAGE / "link").symlink_to(self.root / INPUT) + self.freeze() + with self.assertRaisesRegex(ValueError, "non-regular frozen package"): + self.run_receipt() + + def test_live_input_symlink_rejected(self): + (self.root / INPUT).unlink() + (self.root / INPUT).symlink_to(self.root / CATALOG) + with self.assertRaisesRegex(ValueError, "symlink"): + self.run_receipt() + + def test_missing_live_input_rejected(self): + (self.root / INPUT).unlink() + with self.assertRaisesRegex(ValueError, "missing or external"): + self.run_receipt() + + def test_materialized_source_mutation_fails_final_gate(self): + def corrupt(root, package): + (root / INPUT).write_text("bad mutation") + with mock.patch.object(replay, "run_package", side_effect=corrupt): + with self.assertRaisesRegex(ValueError, "changed its materialized"): + self.run_receipt() + + def test_materialized_extra_package_file_fails_final_gate(self): + def corrupt(root, package): + (root / package / "extra").write_text("bad mutation") + with mock.patch.object(replay, "run_package", side_effect=corrupt): + with self.assertRaisesRegex(ValueError, "changed its materialized"): + self.run_receipt() + + def test_live_mutation_during_replay_fails_final_gate(self): + def corrupt(root, package): + (self.root / INPUT).write_text("bad live mutation") + with mock.patch.object(replay, "run_package", side_effect=corrupt): + with self.assertRaisesRegex(ValueError, "live package or inputs changed"): + self.run_receipt() + + def test_failure_propagates_and_temporary_directory_is_removed(self): + paths = [] + def fail(root, package): + paths.append(root) + raise ValueError("original verifier rejected") + with mock.patch.object(replay, "run_package", side_effect=fail): + with self.assertRaisesRegex(ValueError, "original verifier rejected"): + self.run_receipt() + self.assertTrue(paths) + self.assertTrue(all(not path.exists() for path in paths)) + + def test_original_assertions_run_despite_inherited_optimization(self): + with mock.patch.dict(os.environ, {"PYTHONOPTIMIZE": "2"}): + self.run_receipt() + self.assertEqual(os.environ["PYTHONOPTIMIZE"], "2") + + def test_replacement_cannot_substitute_wrong_history(self): + self.put(INPUT, b"replacement bytes\n") + replacement = self.commit() + self.git("replace", self.base, replacement) + self.run_receipt() + + def test_inherited_git_directory_cannot_redirect_authentication(self): + with mock.patch.dict(os.environ, {"GIT_DIR": str(self.root / "absent"), + "GIT_CONFIG_COUNT": "1", "GIT_CONFIG_KEY_0": "core.bare", + "GIT_CONFIG_VALUE_0": "true"}): + self.run_receipt() + + def test_historical_symlink_input_rejected(self): + (self.root / "docs/link.txt").symlink_to("input.txt") + commit = self.commit() + with self.assertRaisesRegex(ValueError, "non-regular historical input"): + historical.pinned_file(self.root, commit, "docs/link.txt") + + def test_original_timeout_is_enforced(self): + self.manifest["commands"][0]["timeout_seconds"] = 1 + self.put(PACKAGE + "/verify.py", "import time; time.sleep(10)\n") + self.freeze() + with self.assertRaisesRegex(ValueError, "verification timed out"): + self.run_receipt() + + def test_original_nonzero_exit_is_not_success(self): + self.put(PACKAGE + "/verify.py", "raise SystemExit(7)\n") + self.freeze() + with self.assertRaisesRegex(ValueError, "verification command exited 7"): + self.run_receipt() + + def test_adapter_input_mutation_fails_final_gate(self): + def corrupt(root, package): + (self.root / historical.ADAPTER).write_text("bad mutation") + with mock.patch.object(replay, "run_package", side_effect=corrupt): + with self.assertRaisesRegex(ValueError, "live package or inputs changed"): + self.run_receipt() + + def test_legacy_grafts_rejected(self): + self.put(".git/info/grafts", self.base + "\n") + with self.assertRaisesRegex(ValueError, "legacy Git grafts"): + self.run_receipt() + + def test_isolated_git_has_no_alternates_or_live_config(self): + def inspect(root, package): + self.assertFalse((root / ".git/objects/info/alternates").exists()) + self.assertNotIn(str(self.root), (root / ".git/config").read_text()) + self.assertEqual(historical.output(root, "show", self.base + ":" + INPUT), b"original input\n") + self.assertIn(INPUT.encode(), historical.output(root, "ls-tree", "-r", self.base)) + with mock.patch.object(replay, "run_package", side_effect=inspect): + self.run_receipt() + + +if __name__ == "__main__": + unittest.main() From 3088a09c77fe5353218df861e34b0fe67dbf1b6b Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 18:18:17 +1100 Subject: [PATCH 8/8] Validate batch1099 review history separately from latest ledger state PR1048's authenticated batch1099 partial review is followed by explicit source-only triage in later pinned family records. Validate the historical completion invariants without incorrectly requiring today's ledger to equal the superseded flags/evidence list. Independently require exact latest-family equality and current completion invariants; keep all source hashes, coverage checks, evidence and ledger data unchanged. Add five regressions covering all forty batch rows, historical/current invariants, missing/forged state, bool-int distinction, source immutability and byte-level authentication of the superseded source. Validation: all 55 reconciliation tests pass normally and under -O. Unchanged reconciliation100 and historical-five default integrity checks pass on exact source bytes. Three later integrity checks require 225 MiB of frozen fixtures and remain for full hosted CI; no local full-ledger pass is claimed. Implemented and reviewed with substantial OpenAI assistance. --- scripts/verify_pr_reconciliation.py | 19 +++++- tests/test_pr_reconciliation.py | 90 +++++++++++++++++++++++++++++ 2 files changed, 108 insertions(+), 1 deletion(-) diff --git a/scripts/verify_pr_reconciliation.py b/scripts/verify_pr_reconciliation.py index 829af45943..1e3afdc9da 100644 --- a/scripts/verify_pr_reconciliation.py +++ b/scripts/verify_pr_reconciliation.py @@ -227,6 +227,23 @@ def check_review_completion(item, decision): require(item['integration_location'], 'Incorporated without integration location') +def check_historical_review_completion(item, decision, latest_decision): + """Validate a pinned past review separately from its current projection. + + Later source-only triage can explicitly replace completion flags while + retaining the earlier evidence. It must still match the latest decision + exactly; an old review must not silently certify today's ledger state. + """ + require(item['number'] == decision['number'] == latest_decision['number'], + 'Historical review belongs to a different PR') + require(all(field in latest_decision for field in ('review_completion', 'verification_evidence')), + 'Latest family decision lacks detailed review or evidence state') + check_family_decision(item, latest_decision) + check_review_completion(item, latest_decision) + if latest_decision != decision: + check_review_completion(decision, decision) + + def check_companion_review(item, companion, decision=None): """Keep scoped evidence; only a later authoritative whole-head review clears its hold.""" require(item['current_head'] == companion['head'] and @@ -738,7 +755,7 @@ def main(): 'Batch1099 coverage head differs') require(len(row['files']) == row['changed_files'] == len({f['source_path'] for f in row['files']}), 'Batch1099 changed-file inventory incomplete') - check_review_completion(actual[number], decision) + check_historical_review_completion(actual[number], decision, family_decisions[number]) for item in row['files']: require(item['action'] in {'retained', 'adapted', 'excluded', 'pending'}, 'Unknown file action') if item['action'] == 'pending': diff --git a/tests/test_pr_reconciliation.py b/tests/test_pr_reconciliation.py index 44d763c5ef..f44e26b915 100644 --- a/tests/test_pr_reconciliation.py +++ b/tests/test_pr_reconciliation.py @@ -326,6 +326,96 @@ def read_text(path, *args, **kwargs): checker.main() +class HistoricalReviewCompletion(unittest.TestCase): + def setUp(self): + self.ledger = json.loads((ROOT / 'docs/research/pr-ledger.json').read_text()) + self.actual = {row['number']: row for row in self.ledger['pull_requests']} + self.path = ROOT / 'research/community-batch1099-audit/DISPOSITIONS.json' + self.historical = json.loads(self.path.read_text())['pull_requests'] + self.latest = {} + for path in checker.decision_paths(): + if path.exists(): + for row in json.loads(path.read_text())['pull_requests']: + self.latest[row['number']] = row + self.decision = next(row for row in self.historical if row['number'] == 1048) + + def test_all_batch1099_historical_and_current_projections(self): + before = deepcopy((self.actual, self.historical, self.latest)) + changed = [] + for decision in self.historical: + number = decision['number'] + item, latest = self.actual[number], self.latest[number] + with self.subTest(number=number): + checker.check_historical_review_completion(item, decision, latest) + if any(item[field] != decision[field] for field in + ('review_completion', 'verification_evidence')): + changed.append(number) + self.assertEqual(changed, [1048]) + self.assertEqual((self.actual, self.historical, self.latest), before) + self.assertTrue(self.decision['review_completion']['changed_file_coverage']) + self.assertFalse(self.latest[1048]['review_completion']['changed_file_coverage']) + self.assertTrue(set(self.decision['verification_evidence']).issubset( + self.actual[1048]['verification_evidence'])) + with self.assertRaisesRegex(ValueError, 'Ledger lost'): + checker.check_review_completion(self.actual[1048], self.decision) + + def test_latest_ledger_mutations_and_missing_fields_reject(self): + fields = ('reviewed_head', 'current_head', 'disposition', 'closure', + 'review_completion', 'verification_evidence') + for field in fields: + for remove in (False, True): + item = deepcopy(self.actual[1048]) + if remove: + item.pop(field) + else: + item[field] = 'forged' + with self.subTest(field=field, remove=remove), self.assertRaises(ValueError): + checker.check_historical_review_completion(item, self.decision, self.latest[1048]) + item = deepcopy(self.actual[1048]) + item['review_completion']['published'] = 0 + with self.assertRaisesRegex(ValueError, 'review_completion'): + checker.check_historical_review_completion(item, self.decision, self.latest[1048]) + + def test_historical_incorporation_and_schema_invariants_reject(self): + mutations = [dict(disposition='incorporated'), dict(verification_evidence=[])] + flags = deepcopy(self.decision['review_completion']) + flags['published'] = 0 + mutations.append(dict(review_completion=flags)) + for mutation in mutations: + decision = dict(deepcopy(self.decision), **mutation) + with self.subTest(mutation=mutation), self.assertRaises(ValueError): + checker.check_historical_review_completion(self.actual[1048], decision, self.latest[1048]) + for field in ('review_completion', 'verification_evidence'): + latest = deepcopy(self.latest[1048]) + latest.pop(field) + with self.subTest(field=field), self.assertRaisesRegex(ValueError, 'Latest family decision lacks'): + checker.check_historical_review_completion(self.actual[1048], self.decision, latest) + latest = dict(self.latest[1048], number=1049) + with self.assertRaisesRegex(ValueError, 'different PR'): + checker.check_historical_review_completion(self.actual[1048], self.decision, latest) + latest = dict(deepcopy(self.latest[1048]), disposition='incorporated') + item = dict(deepcopy(self.actual[1048]), disposition='incorporated') + with self.assertRaisesRegex(ValueError, 'before review'): + checker.check_historical_review_completion(item, self.decision, latest) + + def test_current_review_still_requires_exact_completion_binding(self): + checker.check_historical_review_completion(self.actual[1048], self.latest[1048], self.latest[1048]) + item = deepcopy(self.actual[1048]) + item['verification_evidence'] = self.decision['verification_evidence'] + with self.assertRaisesRegex(ValueError, 'verification_evidence'): + checker.check_historical_review_completion(item, self.latest[1048], self.latest[1048]) + + def test_entrypoint_authenticates_superseded_source_bytes(self): + original = self.path.read_bytes() + original_read = Path.read_bytes + # The historical row is no longer the latest ledger projection. Its + # source hash must nevertheless reject even a whitespace-only change. + def read(path): + return original + b' ' if path == self.path else original_read(path) + with patch.object(Path, 'read_bytes', read), self.assertRaisesRegex(ValueError, 'Stale source:.*batch1099'): + checker.main() + + class SpectrumRefresh(unittest.TestCase): def setUp(self): coverage = json.loads((ROOT / 'research/community-frontier890-audit/CONTENT-COVERAGE.json').read_bytes())