From 091386d3632eb084eb264b293d6b7eb520fe2e3b Mon Sep 17 00:00:00 2001 From: Clear Insight Date: Sun, 18 Oct 2026 13:49:51 +1100 Subject: [PATCH 1/2] Retain exact Newton and covariance predecessor sources --- .../inputs/PR3382_PROOF.md | 445 ++++++++++++++++++ .../inputs/PR3416_PROOF.md | 117 +++++ .../inputs/PR3426_PROOF.md | 145 ++++++ .../inputs/pr3382_model.py | 428 +++++++++++++++++ 4 files changed, 1135 insertions(+) create mode 100644 research/p104-stagewise-entrance/inputs/PR3382_PROOF.md create mode 100644 research/p104-stagewise-entrance/inputs/PR3416_PROOF.md create mode 100644 research/p104-stagewise-entrance/inputs/PR3426_PROOF.md create mode 100644 research/p104-stagewise-entrance/inputs/pr3382_model.py diff --git a/research/p104-stagewise-entrance/inputs/PR3382_PROOF.md b/research/p104-stagewise-entrance/inputs/PR3382_PROOF.md new file mode 100644 index 0000000000..10b3202c78 --- /dev/null +++ b/research/p104-stagewise-entrance/inputs/PR3382_PROOF.md @@ -0,0 +1,445 @@ +# A phase-complete Gaussian entrance for one literal P104 collector + +This result changes the admissible numerical states of one fixed collector. +It does not change its scalar/frame word, claim a new precision threshold, +or provide the missing complete P104 correction and supplier invoice. +The construction is motivated by Clifford-invariant and Barnes–Wall lattice +methods. The proof below uses the repository's exact Gaussian normalization; +it does not invoke a lattice classification theorem or claim a new lattice +family. + +The source is ywz65's PR #2586, head +`7953c9a8f788a8de5cf2ced63d9a61b67c22c6f1`, retained at +`research/p104-rounded-collector/inputs/WORD.json` and `NATIVE.json.gz`. +Tekalign's PR #3025 binds its first collector and supplies the literal signed +floor pair. Ross Richardson's PR #3068, head +`7d2c519a1fdcc6bf66f6f08757eed7c48762d3f2`, supplies the neighboring +period-domain contract and explicitly leaves a larger state exactness domain +open. Their constructions, inverses, source binding and earlier bounds retain +their credit. Exact consumed bytes and the isolated replay are recorded by +the accompanying source manifest and receipt. + +## 1. Coordinates and the explicit code + +Put `pi = 1+i`, so `pi^2 = 2i` and `1/pi = (1-i)/2`. An array of +`2^r` Gaussian integers is a function on the binary cube. It has unique +multilinear Newton coefficients: + +\[ + f(x)=\sum_{S\subseteq\{0,\ldots,r-1\}}a_S x^S, + \qquad x^S=\prod_{j\in S}x_j. +\] + +Uniqueness follows by Boolean differences, or by the triangular evaluation +matrix indexed by subsets. Define the Gaussian module + +\[ + \mathcal B_r=\{f:a_S\in\pi^{|S|}\mathbb Z[i]\text{ for every }S\}. +\] + +Its encoder is explicit: + +\[ + E_r=E_1^{\otimes r},\qquad + E_1=\begin{pmatrix}1&0\\1&\pi\end{pmatrix}. +\] + +Thus a coefficient pair `(c0,c1)` becomes `(c0,c0+pi*c1)`. Bit `j` is +the address bit `1< x xor y = x+y-2xy`, and gives + +\[ + (a,b,c,d)\longmapsto + (a,\ b+c+\pi d,\ c,\ (i-1)c-d). +\] + +The phase `CZ=(-1)^{xy}=1-2xy` gives + +\[ + (a,b,c,d)\longmapsto + (a,\ b,\ c,\ ia+(i-1)(b+c)-d). +\] + +These formulas use `x^2=x`, `y^2=y` and `2=-i*pi^2`. The other bits contribute +the same common coefficient factors, so the formulas apply at every rank. +Bit swaps simply permute coefficient indices. The listed self-inverse gates +remain self-inverse under conjugation; `C` and `S` have the integral inverses +shown above. Global Gaussian units preserve the module. Thus every full source +wrapper, and its inverse, preserves `B_r`. + +No unrestricted phase or permutation is admitted by this argument. For example, +the cubic phase `(-1)^(x0*x1*x2)` applied to the constant one produces Newton +coefficient `-2` at degree three. It is not divisible by `pi^3`, so the result +leaves `B_3`. The quadratic source schema matters. + +The old structured phase witness is a positive control here. The constant one +and `i^{x_j}=1+(i-1)x_j` both belong to `B_r`, because `i-1=i*pi`. +The latter leaves the older `Gamma` period lattice, as credited in PR #3068. +That earlier counterexample did not claim that it creates a lifting error. + +## 5. One complete source-bound collector + +Use zero-based events **2025–2039** of the retained PR #2586 word. They are: + +1. Allocate zero private `C` at the common source frame. +2. Add `D31,D30,D29,D28,D27` to `C`, in that order. +3. Apply the literal rank-seven transport `U` at event 2031. +4. Add `C` to the arbitrarily dirty query `Q7` at its common frame. +5. Apply the separately archived return `V` at event 2033. +6. Subtract the five original sources in reverse order; erase exact zero `C`. + +The source arrays have 512 complex entries and nine address bits. Both native +recipes have the form `M_left C_0 ... C_6 M_right`. The complete surrounding +wrapper acts on all nine bits, so the contract is `B_9`, not an unproved +rank-seven block restriction. Source authentication binds the two event +occurrences, their frames, the common-chart ADDs and their actual recipes. +The predecessor's exact native interpretation is retained; the finite operator +check of `VU=I` is separate from the lattice exactness argument. + +Assume the five source arrays and the initial query belong to `2^-f B_9`. +They are otherwise arbitrary, independently dirty and potentially correlated. +The five sources remain available and unchanged across this whole interval. +The private `C` is owned and starts zero. No alias of those distinct roles or +nonzero private initialization is granted. + +Let `s` be the sum of the five sources. Module closure gives `s in 2^-f B_9`. +By Sections 3–4 both actual transports execute their exact ideal maps on this +domain. The query becomes `Q7+U*s`. Since `VU=I`, the private register returns +to `s`; subtracting the unchanged sources makes it exactly zero. Thus the +literal endpoint is + +\[ + (D31,\ldots,D27,Q7,C=0) + \longmapsto(D31,\ldots,D27,Q7+U\sum_jD_j,C=0). +\] + +The query remains in the same declared lattice and grid. There is no rounded +query defect, per-input grid selection, residue history or numerical downcast +in this restricted-state execution. This permits the separately archived `V`; +the unrestricted approximate lifting contract instead needs its paired inverse. +They must not be interchanged when counting operations. + +This is a boundary assumption at the actual collector cut. The earlier producer +has not been proved to supply this state for arbitrary unrestricted inputs. +The later whole word also has additional operations. A repeated collector is +valid only when its sources, frames, permissions and declared lattice are +available at its own cut. + +## 6. Quarter ADD and the exact meaning of an encoder + +Whole-array ADD by any Gaussian-integer coefficient preserves `B_r`. For an +integral array `z`, a quarter source `z/4` belongs to `B_r` exactly when +`z` belongs to `4B_r`. Integral components alone do not imply that condition. +At rank one `(4,0)` belongs to `B_1`, but `(4,0)/4=(1,0)` does not. Extend +the pair constantly in the other eight bits for the actual nine-bit counterexample. +Conversely `z=4E_r c` always has the admissible quarter `E_r c`. +The named collector contains only unit ADDs, so this counterexample marks the +external interface; no quarter instruction is treated as free within its bill. + +Encoding arbitrary raw coefficients `c` as `E_r c` changes the logical action +of a physical native map `U` to + +\[ + T=E_r^{-1}UE_r. +\] + +The gate formulas prove that `T` is an explicitly described Gaussian-integral +automorphism for the stated alphabet. They do **not** say `UE_r=E_rU`. +Already `C E_1 != E_1 C`; a control checks this distinction. Substituting this +representation into a caller expecting a different map requires its own +intertwining adapters and their complete costs. + +For clarity, one fully specified optional cold preparation realizes this +different `T` contract. Keep five arbitrary raw Gaussian coefficient source +arrays borrowed and unchanged, and give the query mutable ownership. Allocate +five zero source banks, copy the borrowed sources into them by five full-array +ADDs, and encode the five banks and query. Run the original collector on these +six encoded fields. Decode the query and all five banks. Each source bank is +then exactly its original raw source; subtract that borrowed source, check zero +and dispose of the bank. The query endpoint is `q+T*sum(sources)`. + +This construction uses six encodes, six decodes, five copy ADDs, five cleanup +ADDs and five additional owned array lifetimes. It demonstrates a complete +logical codec schedule with literal restoration. It does not admit that `T` +as a requested recursive caller, give a free borrowed-input conversion, or +establish an advantage over an existing `U` implementation. + +## 7. Gate, codec and storage ledger + +All counts in this section concern a direct scalar reference with explicit +array access. They are not tape time, native child tariffs or a lower bound. +Gaussian units, signed arithmetic and addressing are separate operations. + +An encode or decode sweep has `r*2^(r-1)` tensor pairs. Encoding a pair uses +one multiplication by `pi` and one Gaussian ADD. Decoding uses one Gaussian +subtraction and one exact division by `pi`. Multiplication by `pi` is +`(a-b,a+b)`; exact division is `((a+b)/2,(b-a)/2)`. Thus each encode pair costs +four real additions/subtractions, while each decode pair adds two exact real +halvings. Each loads four real components and writes two. An in-place sweep +uses the owned numerical array and four real work words; loop/control storage +and physical routing are additional. Borrowed input cannot be overwritten to +obtain this in-place price. + +At `r=9`, each direction has **2,304 pairs**. The optional cold schedule therefore +adds 13,824 `pi` multiplications, 13,824 exact `pi` divisions, 110,592 real +additions/subtractions, 27,648 exact real halvings and its ten full-array copy/ +cleanup ADDs. Those ten ADDs add 10,240 real additions/subtractions, 20,480 +real-component reads and 10,240 writes. The codecs add 110,592 component reads +and 55,296 writes. Five extra owned banks add 2,560 complex words and 5,120 +component initializations and zero checks each. These quantities are additional +to the direct collector below; they are not paid by an abstract rank count. + +For the literal collector, both seven-stage transforms use `7*512=3,584` +pair applications altogether. Each credited signed-floor pair costs eight +real additions/subtractions, four real floor halvings and one Gaussian quarter +turn. The eleven field ADDs cost `22*512` more real additions/subtractions. +The four actual wrapper cycle counts, in chronological order, are + +\[ + U_{right}:64,\quad U_{left}:128,\quad V_{right}:160,\quad V_{left}:64. +\] + +The credited one-zero-Gaussian-scratch cycle algorithm uses `N+c` swaps for a +wrapper with `c` cycles and `N` unit phase applications. Here it gives **416 +cycles and 2,464 swaps**, plus 2,048 phase applications. The old paired-inverse +schedule's 384 cycles and 2,432 swaps do not price these separately archived +return wrappers. The phase acts on the cycle scratch before each swap, so its +arithmetic is counted without an extra full-array phase pass. + +| Direct collector operation | Count | +|---|---:| +| Signed-floor pair applications | 3,584 | +| Real additions/subtractions, including all eleven field ADDs | 39,936 | +| Real floor halvings | 14,336 | +| Pair Gaussian quarter turns | 3,584 | +| Actual wrapper Gaussian swaps | 2,464 | +| Actual wrapper unit phase applications | 2,048 | +| Butterfly real-component reads / writes | 14,336 / 14,336 | +| Field-ADD real-component reads / writes | 22,528 / 11,264 | +| Wrapper-swap component reads / writes, including scratch | 9,856 / 9,856 | +| Private initialization / zero-check component inspections | 1,024 / 1,024 | + +The 10,240 source-component reads are a subtotal of the field-ADD reads, not an +extra charge. The direct contract has five borrowed source arrays, one mutable +query, one owned zero private array and one zero Gaussian wrapper scratch, +with constant pair work. The optional cold schedule supplies the five source +arrays by additional owned copies. Source plans, range/type validation, +permissions, address/control work, physical movement, allocator behavior, +recursive children, precision metadata and final endpoint consumption require +their actual caller's tariff. They do not acquire a zero price from these +scalar counts. + +## 8. Finite headroom + +Let `H` bound the absolute value of every real and imaginary component at a +codec's own entrance. During an encode the exact largest real component row +sum after at most `r` factors is bounded by + +\[ + M_r=\sum_{k=0}^r {r\choose k} + (|\Re\pi^k|+|\Im\pi^k|). +\] + +This follows by expanding a tensor row; its entries are powers of `pi`, one +for each subset. A smaller partial row is covered by the same nonnegative +bound. For `r=9`, `M_r=3363`. Thus `M_r H` bounds stored encoder components; +`3 M_r H` is a conservative bound for its two-step arithmetic temporaries. + +A row of a `k`-factor inverse sweep is a signed sum of `2^k` inputs divided by +`pi^k`. Its real component row sum is +`2^k (|Re pi^-k|+|Im pi^-k|)=|Re pi^k|+|Im pi^k|`, at most +`2^ceil(r/2)`. Therefore decoder components are bounded by `2^ceil(r/2) H`, +and its subtraction/numerator temporaries by four times that amount. These +are sufficient arithmetic bounds, not a compression or precision advantage. + +For the direct collector suppose its six admitted entrance fields have +integer numerator components bounded by `H`. The sum of five sources has +Hilbert norm at most `5 sqrt(2N) H`. Every exact native prefix is unitary, +including each wrapper. At `N=512`, **160 H** bounds every native-prefix real +component; **161 H** bounds the updated query. A conservative signed-floor +pair scratch bound is **800 H**. Gathers and ungathers are bounded sums of at +most five unchanged sources. Partially written stages store either preceding +or completed pair values, so these same bounds cover the entire execution. + +For the optional cold caller, now let `H` bound its **raw coefficient** entrance. +Encoding gives `3363 H`; the collector therefore gives an encoded query bound +`161*3363 H=541443 H`. Decoding that query gives at most +`32*161*3363 H=17326176 H`. The conservative complete scratch bound is four +times this last quantity, **69304704 H**, which also dominates the encoder, +native pair, source-bank decoding and cleanup temporaries. These composed +bounds make the optional caller's finite-width obligation explicit; they are +not measured peaks or necessary widths. + +For a nonnegative integer component bound `M`, +`1+ceil_log2(M+1)` signed bits suffice. This states an explicit finite range; +an actual fixed-width implementation must use that range, retain the required +grid and charge its bit arithmetic. The older sharp scalar-grid/Clifford +denominator results remain credited and unchanged. + +## 9. Evidence boundary and stopping decision + +The written arguments hold at every finite rank. The new managed-Python model +and finite source checks are bounded by nine address bits, 512 complex entries +and 8,192 magnitude bits per admitted input or returned array component. +Signed storage may require another bit; exact arithmetic temporaries have the +additional finite headroom derived above. The functional model allocates fresh +lists, while the direct ledger prices the separately specified in-place codec +and credited cycle-scratch algorithm. It is not a measurement of Python +allocation. Membership checks and snapshots inside verification are test work; +a production caller must establish or pay for its lattice entrance. +Managed allocation and verification snapshots are not a physical memory +implementation. Exact checks use explicit exceptions, including under Python +optimization. + +Finite verification binds the two archived recipes, checks exact operators and +both literal directions on admitted states, tests dirty collector endpoints, +and exercises the missing-prefix, phase-alphabet, wrong weighting, quarter-ADD, +intertwiner and source/invoice failure boundaries. The separate checker uses +its own representation and does not derive a nonlinear universal theorem from +finite basis samples. Source-native correctness, physical ownership, eventual +recursive prices and human/proof-kernel admission remain separate premises. + +The result stops at a phase-compatible exactness theorem, one actual complete +local collector, an explicit codec/intertwiner, and their full direct logical +ledger. It neither proves that earlier arbitrary P104 inputs satisfy the +entrance nor extends the contract to the later quarter ADDs. A larger caller +needs an actual admitted source of this state and a compatible fully charged +consumer. No selected frontier, all-size supplier, new scalar-grid guard, +physical storage saving or new kappa follows. + +Prepared by Clear1nsight with substantial OpenAI assistance. Separate automated +derivation and review are not independent human or formal-kernel verification. +Apache-2.0; predecessor authors and original source notices retain their credit. diff --git a/research/p104-stagewise-entrance/inputs/PR3416_PROOF.md b/research/p104-stagewise-entrance/inputs/PR3416_PROOF.md new file mode 100644 index 0000000000..276f61cb64 --- /dev/null +++ b/research/p104-stagewise-entrance/inputs/PR3416_PROOF.md @@ -0,0 +1,117 @@ +# Exact covariance of the archived P104 native recipes + +All statements concern the two frozen PR2586 inputs in SOURCES.json, at nine +address bits. The ground field is Q(i), and arrays have 512 complex entries. +The word and native archive are ywz65's work. This package supplies a separate +finite verification of their native change-of-chart identities. It does not +construct a new native word or strengthen the original native invoice. + +## Canonical charts and the precise claim + +Write computational basis vectors as |x>, for x in F_2^9. For an independent +ordered frame W=(w_0,...,w_(r-1)), complete these columns greedily with the +standard basis e_0,...,e_8. Let G be the resulting binary matrix, A=G^-1, +and Q=I+A^T A over F_2. Set + + q(x) = sum_j Q_jj x_j + 2 sum_(j = i^q(x) |A x>. + +The phases use the binary representatives 0 and 1 of Q. Define + + C(a,b) = ((a+b+i(a-b))/2, (a+b-i(a-b))/2). + +For 0 to i^p(x) |B x+b>, using its archived address rows, offset, +linear Z4 phase, quadratic binary rows and constant Gaussian phase. The +verifier validates bijectivity and all numeric ranges before computing its +operator. All arithmetic is integral or Gaussian dyadic, with no numerical +tolerance and no floating point. + +The certified finite theorem is + + U = Delta_new Delta_old^-1 + +for every one of the 1,245 archived records, as operators on every vector in +Q(i)^512. Their 2,070 occurrences are each matched to the literal word's +recorded old frame, new frame and positive rank. Their chronological incoming +frames, all ADD common-frame constraints, private frame lifetimes and final +frames are checked. This covariance theorem does not itself prove the scalar +word's dirty restoration or zero erasure values. Those are separate obligations. + +## Complete operator comparison + +Use P(p,x,z)=i^p X^x Z^z, so + + P(p,x,z)|v> = i^(p+2 z.v)|v+x>, + P(p,x,z) P(q,u,w) = P(p+q+2 z.u, x+u, z+w). + +Phases are reduced modulo 4 and binary sums are XOR. A signed tableau records +the exact conjugates of the nine X_j and nine Z_j, including their phases. +For a one-coordinate C, + + C X C^-1 = X, + C Z C^-1 = -Y = i^3 XZ. + +Its inverse sends Z to Y=i XZ. These formulas follow directly from the +stated two-by-two matrix. `c_table` uses those identities. For every monomial +appearing in an actual recipe or canonical chart, `monomial_table` reconstructs +its candidate Pauli images, then checks each identity on all 512 computational +columns. In particular, for M|v>=i^q(v)|a(v)>, conjugation has address difference +`a(v+x)+a(v)` and phase difference `p+q(v+x)-q(v)+2 z.v`. +The check compares these with the proposed output Pauli at every v. No +inference from rank, unsigned symplectic data, or a few sampled inputs is used. +The product law then composes the exact signed actions through each circuit. + +Here is why those 18 identities determine an operator up to a scalar. +If invertible U and V have the same signed conjugation action, V^-1 U +commutes with every Z_j and X_j. Commuting with all Z_j makes V^-1 U diagonal +in the computational basis, because distinct addresses have different joint +Z eigenvalues. Commuting with every X_j makes its diagonal entries equal +along every cube edge. The cube is connected, so V^-1 U=lambda I. All factors +here are unitary and hence invertible. No external irreducibility theorem is +needed for this finite argument. + +Finally the checker compares the complete, exact nonzero column U|0> with +V|0>. Equality forces lambda=1. The column is stored as Gaussian integer +numerators over one power of two. Removing only common factors of two gives +a unique representation for a nonzero dyadic column. The stored receipt +contains a digest of each fully compared tableau and anchor, alongside frames, +rank and occurrences. Digests summarize the comparisons; the verifier does not +accept an identity by comparing hashes of operators. + +This criterion is established predecessor mathematics. In particular, +Tekalign's PR3218 supplies a separate Pauli-plus-anchor comparator and proof. +The present contribution is its independent implementation and exhaustive +application to the PR2586 corpus required by PR3406's stated proof dependency. + +## Connection to the Newton source theorem + +PR3406 at `18a054fd585ab4b2010770ec83cba0c9f28184e3` proves its sharp source +criterion under these exact native identities. This certificate supplies that +finite inherited premise. With the other hypotheses and proof of that pending +result retained, its entrance remains 4 B_9 on 104 independent Y inputs, +2 B_9 on 78 independent N inputs, and B_9 on the other 176 public inputs. +Here B_9 is the Gaussian Newton module introduced for this application by +Clear1nsight/PR3382. This does not independently recertify every other lemma or +turn that conditional restricted-state contract into an actual-caller theorem. + +The result is author-checked exact arithmetic, with a separately implemented +comparison path and independent dense controls. It has no human or proof-kernel +review. Physical storage, owners, routing, rounded recursive children, actual +input preparation, a favorable complete bill, tensor-depth transfer and the +selected multiplication theorem remain outside scope. No new kappa is claimed. diff --git a/research/p104-stagewise-entrance/inputs/PR3426_PROOF.md b/research/p104-stagewise-entrance/inputs/PR3426_PROOF.md new file mode 100644 index 0000000000..c7007ae86f --- /dev/null +++ b/research/p104-stagewise-entrance/inputs/PR3426_PROOF.md @@ -0,0 +1,145 @@ +# Correlated first-collector entrance + +Let `pi=1+i`, and let `B=B9` be the Gaussian Newton lattice + +\[ + B=\{f(x)=\sum_{S\subseteq[9]}a_S x^S:\pi^{|S|}\mid a_S\}. +\] + +It is a free `Z[i]` module of rank 512. All statements below concern the +literal PR2586 word at its first collector entrance, immediately before +zero-based event 2025. The exact sources and dependencies are in SOURCES.json. + +## Inherited operator hypotheses + +We use PR3382's theorem that the actual Gaussian wrappers and coordinate +butterflies are automorphisms of B, and agree with their signed-floor +implementations on B. Their inverses preserve B as well. +We use PR3416's finite native covariance theorem, including global phase. +Writing `A_H` for the empty-to-frame operator, each ideal transport from H +to K equals `A_K A_H^-1`. Thus every ideal bank has a well-defined +frame-normalized value `A_H^-1 v`. A transport leaves that value fixed. +An ADD with a common source/destination frame adds its stated scalar multiple +of the normalized source. These dependencies are inherited, not re-proved by +our three numerical fixtures. + +## The ideal final-cut classification + +Take arbitrary initial values of the 58 dependencies in B. Denote the five +initial D values by `d_j`, the initial Q7 by `q`, and the 52 initial Y values +by `y_s`. No independence restriction is imposed on these values. + +Backward slicing the authenticated destination-first word gives 257 events. +There are 200 transports and 57 ADDs. Fifty-two ADDs are positive quarters, +and five subtract initial D values into Q7 before those D banks acquire +any quarter contribution. The program groups the Y sources into disjoint +sets `S_j` of sizes 3, 7, 7, 11 and 24 for D31, D30, D29, D28 and D27. +The complete source/event lists and coefficient rows are in RECEIPT.json. +For example, `S_31={Y27,Y26,Y99}`, read at 1090, 1129 and 1231. +All 52 source paths contain transports only before their required read. + +An induction in source order, using the common ADD frames, proves + +\[ + D_j^{cut}=A_{F_D}\left(d_j+\frac14\sum_{s\in S_j}y_s\right), + \qquad + Q7^{cut}=A_{[364]}\left(q-\sum_jd_j\right), +\] + +where `F_D=[256,136,64,40,16,4,2,1]`. This is an ideal rational Gaussian +operator identity. It does not assume intermediate values are integral or +that an unrestricted signed-floor execution follows this identity. + +Since `d_j,q` belong to B and both displayed frame operators are +B-automorphisms, all six ideal outputs belong to B if and only if + +\[ + \boxed{\ \sum_{s\in S_j}y_s\in4B\quad\text{for each of the five groups.}\ } +\] + +Necessity follows by applying the inverse frame and subtracting `d_j`. +Sufficiency follows by adding a B quarter-sum to `d_j`; Q7 is always in B. +This proves the full ideal criterion for this stated initial B domain. + +For each group choose its first source as pivot. Keep the other Y coordinates +and replace the pivot coordinate by the sum of its group. The inverse replaces +the pivot by that sum minus the other group coordinates. These are integral +inverse changes of bank coordinates. The checker constructs both 52-by-52 +matrices and verifies both products are the identity. Consequently the admitted +Y module is isomorphic, by this explicit change of coordinates, to + +\[ + B^{47}\mathbin{\oplus}(4B)^5. +\] + +Every ideal admitted input is obtained by choosing arbitrary nonpivot Y +values in B, arbitrary `z_j` in B, and setting +`y_pivot=4 z_j-sum(nonpivot values in its group)`. +The quotient of `B^52` by this module is exactly `(B/4B)^5`, of cardinality +`2^10240`. This is an algebraic index, not a storage or operation bill. +PR3423's separate `y_s in 4B` restrictions characterize its stronger invariant +that every relevant prefix stays in B. They remain sufficient but are not +necessary for the ideal final cut. + +## A literal reachable cancellation + +Set `Y27=64 delta_0`, `Y26=-64 delta_0`, and every other component of all +358 initial banks to zero. Each nonzero initial bank is in B and outside 4B. +Indeed every Newton coefficient of `delta_0` is a sign, and +`v_pi(64)=12`. The degree-nine condition for 4B would require valuation 13. + +The checker executes every event from 0 through 2024 with exact Gaussian +integer components. Every fractional ADD is checked for componentwise exact +division. All 883 native occurrences are bound to their old/new frames and +ranks. Zero-input transports stay zero. On all active coordinate pairs, it +compares the literal signed-floor result against the ideal Gaussian pair. +All 7,680 comparisons pass across 26 active native occurrences. + +The first non-B event output is D31 at 1090. Its mask-349 Newton coefficient +is `-4-4i`, with degree six and pi valuation five. At the collector entrance, +all six produced banks are literally zero. The two nonzero initial Y values +are distinct physical roles. Their frames follow their actual histories, +so the cancellation is not an identification of storage roles. + +Deleting the Y26 input leaves the actual Y27-only counterexample from PR3423. +Our separate full-prefix implementation reproduces its failing D31 output, +with 256 nonzero Gaussian components and the same final array hash. The +amplitude-256 positive control stays admitted. These controls retain the +actual prefix and do not substitute an ADD at a freely chosen read point. + +The numerical fixture is a finite certificate. It also gives a narrow +analytic extension. A Gaussian integer multiple of this initial vector has +a Gaussian integer ideal state at every certified stage, because all those +states are Gaussian integer and the ideal operations are Gaussian linear. +For a coordinate pair, Gaussian integrality of the ideal outputs means the +real and imaginary input differences have the same parity. The literal pair +then equals the ideal pair, since +`floor(a/2)+ceil(b/2)=(a+b)/2` when `a,b` have the same parity. +Induction therefore proves the same exact full-prefix cancellation for every +Gaussian integer multiple. When the multiplier is not divisible by pi, the +two initial banks remain outside 4B and event 1090 still leaves B. +This extension is a proved consequence of the integral trace, not an +exhaustive numerical sweep of multipliers. + +## Scope and remaining obligations + +The universal theorem is about the ideal final cut. The exact literal trace +establishes one strict cancellation example and its Gaussian multiples. +A general correlated-domain classification for arbitrary rounded executions +is not proved. The 52-source prefix theorem in PR3423 and the independent +product-domain theorem in PR3406 are not contradicted. + +We do not supply a caller that prepares these correlations, control other +collectors, price ownership, route sources, preserve all downstream recipient +histories, or change PR3423's unchanged-profile stopping decision. A final-cut +cancellation cannot remove costs from the consumer or compiler without an +additional argument. No supplier admission, improved kappa, selected-frontier +change or complete multiplication theorem follows. + +Credit ywz65/PR2586 for the word and recipes, Arham Tahir/PR2665 for the +retained inputs, Clear1nsight/PR3382 and PR3423 for the Newton domain and actual +producer/consumer work, Tekalign/PR3025 for the signed-floor bijection, +Ross Richardson/PR3068 for the exactness-domain question, Nick Petalas/PR3406 +and PR3416, and all retained native, geometry, compiler and precision lineage. +The new result is the correlated ideal entrance and the exact literal +cancellation separating it from the prefix invariant. Apache-2.0. diff --git a/research/p104-stagewise-entrance/inputs/pr3382_model.py b/research/p104-stagewise-entrance/inputs/pr3382_model.py new file mode 100644 index 0000000000..4dd24a2627 --- /dev/null +++ b/research/p104-stagewise-entrance/inputs/pr3382_model.py @@ -0,0 +1,428 @@ +"""Exact Gaussian Newton-lattice reference for the pinned P104 collector. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +The all-rank statements are written in PROOF.md. This finite reference accepts +at most nine address bits and 8192 magnitude bits per real array component. It imports +no predecessor implementation and makes no recursive or physical cost claim. +""" + +from math import comb, isqrt + +MAX_RANK = 9 +MAX_COMPONENT_BITS = 8192 +PI = (1, 1) +ZERO = (0, 0) + + +class ModelError(ValueError): + """A malformed input or violated finite-reference contract.""" + + +class OutsideLattice(ModelError): + """A required exact Gaussian division is unavailable.""" + + +def require(condition, message): + if not condition: + raise ModelError(message) + + +def rank_check(rank): + require(type(rank) is int and 0 <= rank <= MAX_RANK, "rank must be in 0..9") + return rank + + +def gaussian_check(value): + require(type(value) is tuple and len(value) == 2, "Gaussian value must be a pair") + require(all(type(x) is int for x in value), "Gaussian components must be integers") + require(all(x.bit_length() <= MAX_COMPONENT_BITS for x in value), + "Gaussian component exceeds finite reference limit") + return value + + +def validate(values, rank=None): + require(type(values) is list and values, "array must be a nonempty list") + size = len(values) + require(size <= 1 << MAX_RANK and size & (size - 1) == 0, "binary array length") + actual = size.bit_length() - 1 + if rank is not None: + require(rank_check(rank) == actual, "array rank mismatch") + for value in values: + gaussian_check(value) + return actual + + +def add(a, b): + return a[0] + b[0], a[1] + b[1] + + +def sub(a, b): + return a[0] - b[0], a[1] - b[1] + + +def mul(a, b): + return a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0] + + +def rot(value, phase): + a, b = value + return ((a, b), (-b, a), (-a, -b), (b, -a))[phase % 4] + + +def times_pi(value): + return value[0] - value[1], value[0] + value[1] + + +def divide_pi(value): + a, b = value + if (a + b) % 2: + raise OutsideLattice("not divisible by 1+i") + return (a + b) // 2, (b - a) // 2 + + +def half_exact(value): + if value[0] % 2 or value[1] % 2: + raise OutsideLattice("ideal Gaussian pair has a nonintegral component") + return value[0] // 2, value[1] // 2 + + +def pi_power(exponent): + rank_check(exponent) + result = (1, 0) + for _ in range(exponent): + result = times_pi(result) + return result + + +def encode(coefficients): + """E_r c, with E_1(c0,c1)=(c0,c0+(1+i)c1), in address-bit order.""" + rank = validate(coefficients) + out = coefficients[:] + for bit in range(rank): + step = 1 << bit + for address in range(len(out)): + if not address & step: + out[address | step] = add(out[address], times_pi(out[address | step])) + validate(out, rank) + return out + + +def decode(values): + """Exact E_r inverse; membership fails on an unavailable pi division.""" + rank = validate(values) + out = values[:] + for bit in reversed(range(rank)): + step = 1 << bit + for address in range(len(out)): + if not address & step: + out[address | step] = divide_pi(sub(out[address | step], out[address])) + validate(out, rank) + return out + + +def member(values): + validate(values) + try: + decode(values) + except OutsideLattice: + return False + return True + + +def newton(values): + """Unweighted multilinear coefficients, obtained by Boolean differences.""" + rank = validate(values) + out = values[:] + for bit in range(rank): + step = 1 << bit + for address in range(len(out)): + if not address & step: + out[address | step] = sub(out[address | step], out[address]) + validate(out, rank) + return out + + +def ideal_pair_numerators(a, b, inverse=False): + """Return twice C(a,b), so nonintegral examples can be checked exactly.""" + gaussian_check(a) + gaussian_check(b) + require(type(inverse) is bool, "inverse flag must be Boolean") + total = add(a, b) + difference = rot(sub(a, b), 3 if inverse else 1) + return add(total, difference), sub(total, difference) + + +def ideal_pair(a, b, inverse=False): + first, second = ideal_pair_numerators(a, b, inverse) + return half_exact(first), half_exact(second) + + +def lift_pair(a, b, inverse=False): + """Literal componentwise signed-floor lifting, without a grid change.""" + gaussian_check(a) + gaussian_check(b) + require(type(inverse) is bool, "inverse flag must be Boolean") + difference = sub(a, b) + middle = add(b, (difference[0] // 2, difference[1] // 2)) + difference = rot(difference, 3 if inverse else 1) + second = sub(middle, (difference[0] // 2, difference[1] // 2)) + return add(second, difference), second + + +def stage(values, bit, inverse=False, literal=False): + rank = validate(values) + require(type(bit) is int and 0 <= bit < rank, "address bit outside array") + require(type(inverse) is bool and type(literal) is bool, "stage flags must be Boolean") + out = values[:] + step = 1 << bit + pair = lift_pair if literal else ideal_pair + for address in range(len(out)): + if not address & step: + other = address | step + out[address], out[other] = pair(out[address], out[other], inverse) + validate(out, rank) + return out + + +def ideal_stage(values, bit, inverse=False): + return stage(values, bit, inverse=inverse) + + +def lift_stage(values, bit, inverse=False): + return stage(values, bit, inverse=inverse, literal=True) + + +def gate_bits(kind, bits, rank): + require(kind in ("C", "CINV", "S", "SINV", "X", "SWAP", "CNOT", "CZ"), + "unsupported gate") + count = 2 if kind in ("SWAP", "CNOT", "CZ") else 1 + require(type(bits) in (tuple, list) and len(bits) == count, "gate arity") + require(all(type(bit) is int and 0 <= bit < rank for bit in bits), "gate address bits") + require(len(set(bits)) == len(bits), "gate bits must be distinct") + return tuple(bits) + + +def value_gate(values, kind, bits): + """The physical Gaussian gate; CNOT bits are (control,target).""" + rank = validate(values) + bits = gate_bits(kind, bits, rank) + if kind in ("C", "CINV"): + return ideal_stage(values, bits[0], inverse=kind == "CINV") + out = [ZERO] * len(values) + for address, value in enumerate(values): + target, phase = address, 0 + first = (address >> bits[0]) & 1 + if kind == "X": + target ^= 1 << bits[0] + elif kind in ("S", "SINV"): + phase = first * (1 if kind == "S" else 3) + elif kind == "CNOT": + target ^= first << bits[1] + elif kind == "CZ": + phase = 2 * first * ((address >> bits[1]) & 1) + elif first != ((address >> bits[1]) & 1): + target ^= (1 << bits[0]) | (1 << bits[1]) + out[target] = rot(value, phase) + return out + + +def coefficient_pair(a, b, kind): + if kind == "C": + return add(a, b), rot(b, 1) + if kind == "CINV": + last = rot(b, 3) + return sub(a, last), last + if kind == "S": + return a, rot(add(a, b), 1) + if kind == "SINV": + return a, sub(rot(b, 3), a) + require(kind == "X", "unsupported coefficient pair") + return add(a, times_pi(b)), rot(b, 2) + + +def coefficient_gate(coefficients, kind, bits): + """Direct integral E^-1 gate E formulas; no encode/decode calls.""" + rank = validate(coefficients) + bits = gate_bits(kind, bits, rank) + if kind == "SWAP": + return value_gate(coefficients, kind, bits) + out = coefficients[:] + first = 1 << bits[0] + if len(bits) == 1: + for address in range(len(out)): + if not address & first: + other = address | first + out[address], out[other] = coefficient_pair(out[address], out[other], kind) + validate(out, rank) + return out + second = 1 << bits[1] + for address in range(len(out)): + if address & (first | second): + continue + a, b, c, d = (out[address | mask] for mask in (0, first, second, first | second)) + if kind == "CNOT": + out[address | first] = add(add(b, c), times_pi(d)) + out[address | first | second] = sub(rot(times_pi(c), 1), d) + else: + require(kind == "CZ", "unsupported coefficient block") + out[address | first | second] = sub(add(rot(a, 1), rot(times_pi(add(b, c)), 1)), d) + validate(out, rank) + return out + + +def wrapper_plan(record): + """Exact source convention: input x receives its phase, then moves to Ax+b.""" + keys = {"matrix_rows", "offset", "linear_Z4", "quadratic_rows", "phase"} + require(type(record) is dict and set(record) == keys, "wrapper schema") + rows, linear, quadratic = (record[name] for name in + ("matrix_rows", "linear_Z4", "quadratic_rows")) + require(type(rows) is list, "wrapper matrix rows") + rank = rank_check(len(rows)) + require(type(linear) is list and type(quadratic) is list, "wrapper phase arrays") + require(len(linear) == len(quadratic) == rank, "wrapper dimensions") + size = 1 << rank + require(all(type(row) is int and 0 <= row < size for row in rows + quadratic), + "wrapper binary rows") + require(all(type(value) is int and 0 <= value < 4 for value in linear), "linear phases") + require(type(record["offset"]) is int and 0 <= record["offset"] < size, "affine offset") + require(type(record["phase"]) is int and 0 <= record["phase"] < 4, "global phase") + result = [] + for address in range(size): + target = record["offset"] + phase = record["phase"] + for j in range(rank): + target ^= ((rows[j] & address).bit_count() & 1) << j + if address >> j & 1: + phase += linear[j] + for k in range(j + 1, rank): + phase += 2 * ((quadratic[j] >> k) & 1) * ((address >> k) & 1) + result.append((target, phase % 4)) + require(len({target for target, _ in result}) == size, "wrapper must be bijective") + return result + + +def wrapper(values, record, inverse=False): + validate(values) + require(type(inverse) is bool, "inverse flag must be Boolean") + plan = wrapper_plan(record) + require(len(plan) == len(values), "wrapper and array dimensions") + out = [ZERO] * len(values) + for source, (target, phase) in enumerate(plan): + if inverse: + out[source] = rot(values[target], -phase) + else: + out[target] = rot(values[source], phase) + return out + + +def codec_ledger(rank): + rank_check(rank) + size = 1 << rank + pairs = rank * size // 2 + return {"rank": rank, "complex_coordinates": size, "pairs_per_direction": pairs, + "encode": {"gaussian_adds": pairs, "pi_multiplications": pairs, + "real_add_subtracts": 4 * pairs, "component_reads": 4 * pairs, + "component_writes": 2 * pairs}, + "decode": {"gaussian_subtracts": pairs, "exact_pi_divisions": pairs, + "real_add_subtracts": 4 * pairs, "exact_real_halves": 2 * pairs, + "component_reads": 4 * pairs, "component_writes": 2 * pairs}, + "owned_in_place_complex_words": size, "pair_real_work_words": 4, + "borrowed_input_copy_included": False, "routing_included": False} + + +def codec_bounds(rank, component_bound): + """Sufficient integer bounds, per codec's own entrance; not physical prices.""" + rank_check(rank) + require(type(component_bound) is int and component_bound >= 0, "nonnegative bound") + gain = sum(comb(rank, k) * sum(abs(x) for x in pi_power(k)) for k in range(rank + 1)) + inverse_gain = 1 << ((rank + 1) // 2) + return {"rank": rank, "entrance_component_bound": component_bound, + "encode_component_gain": gain, "encode_component_bound": gain * component_bound, + "encode_scratch_bound": 3 * gain * component_bound, + "decode_component_gain": inverse_gain, + "decode_component_bound": inverse_gain * component_bound, + "decode_scratch_bound": 4 * inverse_gain * component_bound} + + +def collector_bounds(rank, source_count, component_bound): + rank_check(rank) + require(type(source_count) is int and 1 <= source_count <= 5, "source count in 1..5") + require(type(component_bound) is int and component_bound >= 0, "nonnegative bound") + size = 1 << rank + root = isqrt(2 * size) + if root * root < 2 * size: + root += 1 + native = source_count * root * component_bound + return {"rank": rank, "entrance_component_bound": component_bound, + "source_count": source_count, "native_prefix_component_bound": native, + "query_component_bound": native + component_bound, + "pair_scratch_component_bound": 5 * native, + "assumption": "exact unitary native prefixes on the admitted lattice"} + + +def collector_ledger(rank, native_rank, wrapper_cycle_counts): + """Complete direct collector counts; four actual source wrappers are required.""" + rank_check(rank) + require(type(native_rank) is int and 1 <= native_rank <= rank, "native rank") + size = 1 << rank + require(type(wrapper_cycle_counts) is list and len(wrapper_cycle_counts) == 4, + "four literal wrapper cycle counts required") + require(all(type(c) is int and 1 <= c <= size for c in wrapper_cycle_counts), + "wrapper cycle count") + pairs = native_rank * size + swaps = 4 * size + sum(wrapper_cycle_counts) + return {"complex_coordinates": size, "native_rank_each_direction": native_rank, + "paired_butterflies": pairs, "field_adds": 11, + "real_add_subtracts": 8 * pairs + 22 * size, + "floor_halves": 4 * pairs, "butterfly_quarter_turns": pairs, + "wrapper_cycle_counts": wrapper_cycle_counts[:], + "wrapper_cycles": sum(wrapper_cycle_counts), "wrapper_swaps": swaps, + "wrapper_unit_phases": 4 * size, + "butterfly_component_reads": 4 * pairs, "butterfly_component_writes": 4 * pairs, + "field_add_component_reads": 44 * size, "field_add_component_writes": 22 * size, + "source_component_reads_within_field_adds": 20 * size, + "wrapper_swap_component_reads": 4 * swaps, "wrapper_swap_component_writes": 4 * swaps, + "private_initialization_components": 2 * size, "private_zero_check_components": 2 * size, + "borrowed_source_complex_words": 5 * size, "mutable_query_complex_words": size, + "owned_private_complex_words": size, "wrapper_zero_scratch_complex_words": 1, + "pair_real_work_words": 4, "codecs_included": False, + "physical_routing_and_recursive_tariff_included": False} + + +def cold_codec_ledger(rank): + """Optional T=E^-1 U E caller: prepare five owned source banks and query.""" + codec = codec_ledger(rank) + size = 1 << rank + pairs = codec["pairs_per_direction"] + return {"rank": rank, "encodes": 6, "decodes": 6, + "owned_source_copy_adds": 5, "owned_source_cleanup_adds": 5, + "extra_owned_source_complex_words": 5 * size, + "extra_private_initialization_components": 10 * size, + "extra_private_zero_check_components": 10 * size, + "codec_real_add_subtracts": 48 * pairs, + "codec_exact_real_halves": 12 * pairs, + "codec_pi_multiplications": 6 * pairs, "codec_exact_pi_divisions": 6 * pairs, + "codec_component_reads": 48 * pairs, "codec_component_writes": 24 * pairs, + "copy_cleanup_real_add_subtracts": 20 * size, + "copy_cleanup_component_reads": 40 * size, + "copy_cleanup_component_writes": 20 * size, + "add_to_direct_collector_invoice": True, + "logical_output_map": "T = E_r^-1 U E_r", + "original_U_caller_admitted": False, + "physical_routing_and_recursive_tariff_included": False} + + +def cold_codec_bounds(rank, component_bound): + """Compose the optional cold caller's bounds from its raw coefficient entry.""" + encoder = codec_bounds(rank, component_bound) + physical = collector_bounds(rank, 5, encoder["encode_component_bound"]) + decoder = codec_bounds(rank, physical["query_component_bound"]) + return {"rank": rank, "raw_entrance_component_bound": component_bound, + "encoded_component_bound": encoder["encode_component_bound"], + "native_prefix_component_bound": physical["native_prefix_component_bound"], + "encoded_query_component_bound": physical["query_component_bound"], + "decoded_query_component_bound": decoder["decode_component_bound"], + "complete_scratch_component_bound": max(encoder["encode_scratch_bound"], + physical["pair_scratch_component_bound"], + decoder["decode_scratch_bound"]), + "logical_output_map": "T = E_r^-1 U E_r"} From 4e4b08c689242f7f3be2e5e08dc1ae8d728ff920 Mon Sep 17 00:00:00 2001 From: Clear Insight Date: Sun, 18 Oct 2026 13:50:07 +1100 Subject: [PATCH 2/2] Classify and encode the exact correlated P104 producer entrance --- research/p104-stagewise-entrance/COSTS.md | 309 + research/p104-stagewise-entrance/PROOF.md | 418 + research/p104-stagewise-entrance/README.md | 256 + research/p104-stagewise-entrance/RECEIPT.json | 17450 ++++++++++++++++ research/p104-stagewise-entrance/SOURCES.json | 313 + research/p104-stagewise-entrance/TASK.json | 405 + research/p104-stagewise-entrance/VERIFY.json | 38 + research/p104-stagewise-entrance/admission.py | 102 + .../p104-stagewise-entrance/classifier.py | 229 + research/p104-stagewise-entrance/costs.py | 104 + .../p104-stagewise-entrance/independent.py | 606 + .../independent_cost.py | 235 + research/p104-stagewise-entrance/source.py | 269 + research/p104-stagewise-entrance/verify.py | 289 + 14 files changed, 21023 insertions(+) create mode 100644 research/p104-stagewise-entrance/COSTS.md create mode 100644 research/p104-stagewise-entrance/PROOF.md create mode 100644 research/p104-stagewise-entrance/README.md create mode 100644 research/p104-stagewise-entrance/RECEIPT.json create mode 100644 research/p104-stagewise-entrance/SOURCES.json create mode 100644 research/p104-stagewise-entrance/TASK.json create mode 100644 research/p104-stagewise-entrance/VERIFY.json create mode 100644 research/p104-stagewise-entrance/admission.py create mode 100644 research/p104-stagewise-entrance/classifier.py create mode 100644 research/p104-stagewise-entrance/costs.py create mode 100644 research/p104-stagewise-entrance/independent.py create mode 100644 research/p104-stagewise-entrance/independent_cost.py create mode 100644 research/p104-stagewise-entrance/source.py create mode 100644 research/p104-stagewise-entrance/verify.py diff --git a/research/p104-stagewise-entrance/COSTS.md b/research/p104-stagewise-entrance/COSTS.md new file mode 100644 index 0000000000..580057b88f --- /dev/null +++ b/research/p104-stagewise-entrance/COSTS.md @@ -0,0 +1,309 @@ +# Direct preparation cost and quotient audit + +This note prices the explicit preparation from **52 owned Gaussian coefficient +banks to the admitted Y module**. It uses the actual inverse donor paths, +the extra right wrappers, and the groupwise bank differences. It does not +price an arbitrary pre-existing Y caller, the other events of the original +prefix, or the 675 external-recipient histories. + +The inventory was independently reconstructed from the frozen WORD and +NATIVE data, without importing the package source layer, classifier, or a +predecessor executable. It is a constructive direct arithmetic schedule, +not a minimum, a physical tape tariff, or a supplier improvement. The +[proof](PROOF.md) states the admission theorem and codec contract; +[SOURCES.json](SOURCES.json) retains the exact origins and mathematical +dependencies. + +## 1. What the quotient counts mean + +Put $R=\mathbb Z[i]$, $\pi=1+i$, and $B=B_9$. The 32 intervals without +a D transport contribute diagonal exponents +$\max(4-|S|,0)$. The 15 rank-one intervals contribute +$\max(4-|S\setminus\{0\}|,0)$. Each of the five terminal coordinates +contributes exponent four on all 512 coefficients. + +| Exponent | No-transport multiplicity | Rank-one multiplicity | Terminal multiplicity | Aggregate | +|---|---:|---:|---:|---:| +| 0 | 32 × 382 | 15 × 326 | 0 | 17,114 | +| 1 | 32 × 84 | 15 × 112 | 0 | 4,368 | +| 2 | 32 × 36 | 15 × 56 | 0 | 1,992 | +| 3 | 32 × 9 | 15 × 16 | 0 | 528 | +| 4 | 32 × 1 | 15 × 2 | 5 × 512 | 2,622 | + +The quotient of $B^{52}$ by the exact stagewise entrance $\mathcal M$ is + +$$ +(R/(\pi))^{4368}\oplus(R/(\pi^2))^{1992} +\oplus(R/(\pi^3))^{528}\oplus(R/(\pi^4))^{2622}. +$$ + +The exponent-zero coordinates have trivial quotient factors. All 52 input +banks remain present; each admitted module has the same full Gaussian rank. +The index is + +$$ +[B^{52}:\mathcal M] +=2^{4368+2(1992)+3(528)+4(2622)} +=2^{20424}. +$$ + +For the ideal terminal-only module $\mathcal I$ from PR #3426 and the +stronger product entrance $\mathcal P=(4B)^{52}$, the inclusions are strict: + +$$ +\mathcal P\subsetneq\mathcal M\subsetneq\mathcal I,\qquad +[B^{52}:\mathcal I]=2^{10240},\quad +[B^{52}:\mathcal P]=2^{106496}. +$$ + +Consequently $[\mathcal I:\mathcal M]=2^{10184}$ and +$[\mathcal M:\mathcal P]=2^{86072}$. These quantify the additional +stagewise constraints and the larger allowed correlated set. They are not +saved physical bits, compressed storage, or eliminated operations. + +The elementary checks behind the first two rows are + +$$ +\sum_{j=0}^{3}(4-j)\binom9j=187,\qquad +2\sum_{j=0}^{3}(4-j)\binom8j=280, +$$ +$$ +32(187)+15(280)+5(2048)=20424. +$$ + +## 2. Actual path reconstruction + +The independent counter finds the first C allocation at zero-based event +2025, derives the five D source roles from the following five collector ADDs, +and finds their earlier quarter reads in the original order. It obtains group +sizes 3, 7, 7, 11 and 24. + +For each nonterminal read, it follows that D bank's native history from its +initial empty frame to the read frame. It separately checks the interval to +the next read. Every selected native occurrence is bound to the archive's +old frame, new frame and rank. The 32 empty intervals and 15 single rank-one +intervals yield 47 preparation paths. + +A rank-one coordinate first needs the inverse of its actual right wrapper. +It then uses the inverse D path, with native occurrences reversed and each +native inverted in its actual factor order. This is a constructive schedule +on independently supplied coefficient arrays. Repeated uses of one source +recipe are counted once per prepared array, not once per distinct archive +record. + +| Preparation part | Native occurrences | Rank sum | Wrapper occurrences | Wrapper cycles | Gaussian payload SWAPs | +|---|---:|---:|---:|---:|---:| +| Inverse donor paths | 158 | 281 | 316 | 9,748 | 152,044 | +| Extra inverse right wrappers | 0 | 0 | 15 | 704 | 6,976 | +| Total | 158 | 281 | 331 | 10,452 | 159,020 | + +Each rank unit acts on 256 address pairs, giving **71,936 pair applications**. +Each wrapper permutation is reconstructed on all 512 addresses and checked +to be a bijection. A cycle of length $l$ uses $l-1$ direct payload SWAPs, +so the total is + +$$ +331(512)-10452=159020. +$$ + +These are reversible gates on two owned Gaussian payload words. They need no +separate clean swap ancilla. This is different from the credited predecessor +schedule using $N+c$ swaps through one owned zero Gaussian scratch word; +those two invoices must not be mixed. Permutation cycles are unchanged by +taking the inverse. + +## 3. Phases and the complete arithmetic subtotal + +The wrapper phase is evaluated at its source address, using its recorded +constant phase, linear terms and only strict-upper quadratic terms $j1$ obstruction. A larger exact input domain does +not change that law or remove native children. This result narrows the missing +admission question; it does not reopen the stopped supplier construction or +claim a new $\kappa$. + +The actual word and native recipes remain ywz65's PR #2586 contribution, +retained through Arham Tahir's source package. Nick Petalas's PR #3426 supplies +the ideal correlated classification and this literal-admission handoff; his +PR #3416 supplies the inherited covariance theorem. Clear1nsight's PR #3382 +and PR #3423 supply the Newton application and prior actual-interface work. +Tekalign's signed-floor and native-comparison lineage, Ross Richardson's +exactness-domain work, and Jose Manuel/Vasek's conditional cost stop retain +their credit. This audit used separate automated source/count reconstruction, +not external human or formal proof-kernel verification. + +Prepared by Clear1nsight with substantial OpenAI assistance. Apache-2.0. diff --git a/research/p104-stagewise-entrance/PROOF.md b/research/p104-stagewise-entrance/PROOF.md new file mode 100644 index 0000000000..8e10fbbeae --- /dev/null +++ b/research/p104-stagewise-entrance/PROOF.md @@ -0,0 +1,418 @@ +# Chronological partial sums classify the exact producer entrance + +Clear1nsight, with substantial OpenAI assistance. This note supplies the +mathematical derivation and an abstract reversible arithmetic schedule. Source +authentication, the actual path invoice, and replay evidence belong to the +package verifier. The inherited word and native recipes are unchanged. + +## 1. The classified contract + +Write $R=\mathbb Z[i]$, $\pi=1+i$, + +$$ +E_r=\begin{pmatrix}1&0\\1&\pi\end{pmatrix}^{\otimes r}, +\qquad B_r=E_rR^{2^r}. +$$ + +Address bit zero is the first tensor coordinate. The actual source uses $r=9$. +The formulas below hold at every rank at which the named gate exists; the +finite reference accepts ranks at most nine. + +The target is the fixed 257-event backward cone ending immediately before word +event 2025, with five targets D31, D30, D29, D28, D27 and Q7. Its 58 initial +banks are those six banks and 52 Y banks. All initial banks are required to be +in $B_9$. The D and Q values may be arbitrary dirty values in that domain. + +We classify exactly the following conjunction: + +1. Every quarter-ADD in this cone has a Gaussian-integral increment. +2. At every native pair in this cone, literal signed-floor execution equals the + stated ideal complex-linear gate. +3. All six target arrays at the cut belong to $B_9$. + +This is a necessary-and-sufficient description within the stated initial +domain. It is not a classification of genuinely rounded paths whose later +errors happen to cancel. It is also not a universal execution theorem for the +omitted events of the full 2025-event prefix: some of these Y banks feed other +D banks outside the cone. It neither admits the later external recipients nor +prices a physical caller. + +The native covariance, including global phase, is inherited from PR #3416. +The $B_r$-automorphisms and the literal pair criterion are inherited from +PR #3382; the relevant pair calculation is recalled below. PR #3426 supplies +the five terminal group-sum condition and explicitly leaves these stagewise +conditions open. The new step is to separate those conditions into independent +chronological partial-sum coordinates and solve every actual interval. + +## 2. Why the source correlations separate + +The source parser binds all selected ADDs and transports to the frozen WORD +and NATIVE bytes. It checks that the five groups have sizes $3,7,7,11,24$, +that each of the 52 Y sources occurs in exactly one group and once in that +group, and that all of these ADDs have coefficient $+1/4$. There are also +five coefficient $-1$ ADDs from the initial dirty Ds into Q7, before any +Y quarter is added to those Ds. + +For a group of size $m$, let $y_1,\ldots,y_m\in B_9$ be its initial Y +values in their actual read order and put + +$$ +p_t=\sum_{u=1}^t y_u,\qquad p_0=0. +$$ + +The change between $y$ and $p$ is triangular and unimodular over $R$: + +$$ +y_1=p_1,\qquad y_t=p_t-p_{t-1}\quad(t>1). +$$ + +It therefore maps $B_9^m$ bijectively to itself. The 52 partial-sum banks +are independent coordinates, not 52 simultaneous constraints on one bank. + +Let $A_H$ be the actual ideal native map from the initial empty frame to the +frame of a read, with its authenticated phase. Covariance gives the physical +D value immediately after that read as + +$$ +A_H\left(d+\frac{p_t}{4}\right), +$$ + +where $d\in B_9$ is the initial dirty D value. The same expression, with the +actual composed map in place of $A_H$, holds after each subsequent complete +stage until the next read. Every transformed dirty term is Gaussian integral, +so subtracting it leaves an integrality condition on $p_t/4$ alone. + +The interval includes the array immediately after the current quarter, every +literal pair stage of an intervening native, and the array immediately before +the next quarter. These endpoint requirements are necessary. They are also +sufficient for exact quarter increments: at a common read frame, subtracting +the old and new integral D states gives precisely $A_Hy_t/4$. For the first +read the old partial sum is zero. Thus no additional coupling between +successive partial-sum coordinates has been discarded. + +The exact source has 47 nonterminal intervals: **32 have no D transport and +15 have exactly one rank-one D transport**. That native is its actual right +monomial wrapper, then $C_0$, then its actual left monomial wrapper. No +paired-inverse substitute or frame-name-only identification is used. The five +terminal intervals are dealt with by the final-cut condition. + +## 3. Two local diagonal profiles + +### 3.1 No intervening transport + +Put + +$$ +L_0=B_r\cap4R^{2^r}. +$$ + +For $q=E_rc$, its unweighted Boolean Newton coefficient indexed by a subset +$S$ is $\pi^{|S|}c_S$. Boolean Möbius inversion and its inverse both have +integer entries. Consequently $q\in4R^{2^r}$ if and only if all those +Newton coefficients are divisible by $4$, equivalently by $\pi^4$. +Thus + +$$ +L_0=E_r\operatorname{diag} + \left(\pi^{\max(4-|S|,0)}\right)R^{2^r}. +\tag{1} +$$ + +For an actual zero-transport gap at frame $H$, the allowed initial partial +sum is exactly $A_H^{-1}L_0$. This includes both interval endpoints, which +are at the same frame and have the same D value. + +### 3.2 One actual rank-one transport + +Let its right wrapper be $M_R$ and put $P=M_RA_H$. Monomial wrappers and +their inverses preserve $4R^{2^r}$. They also preserve $B_r$ by the +inherited source-bound theorem. The interval condition is therefore exactly + +$$ +q=Pp_t\in4R^{2^r},\qquad C_0q\in4R^{2^r}. +\tag{2} +$$ + +Split the bit-zero pairs of $q\in B_r$ as + +$$ +q(x,0)=f(x),\qquad q(x,1)=f(x)+\pi g(x), +\qquad f,g\in B_{r-1}. +$$ + +The source's ideal gate is + +$$ +C=\frac1\pi\begin{pmatrix}i&1\\1&i\end{pmatrix}, +\qquad C(f,f+\pi g)=(f+g,f+i g). +$$ + +Conditions (2) are equivalent to $f,g\in4R^{2^{r-1}}$: necessity follows +by subtracting $q(x,0)=f(x)$ from $(C_0q)(x,0)=f(x)+g(x)$; sufficiency +follows directly from all four displayed values. Applying (1) separately to +the two coefficient blocks gives + +$$ +L_1=E_r\operatorname{diag} + \left(\pi^{\max(4-|S\setminus\{0\}|,0)}\right)R^{2^r}. +\tag{3} +$$ + +The allowed initial partial sum is exactly $P^{-1}L_1$. The left wrapper +adds no further divisibility condition because it is an integral monomial +automorphism, but its endpoint and its charged execution remain in the source +word. This is why testing the quarter output alone would give a larger, +incorrect domain. + +### 3.3 Terminal intervals and the literal pair + +At the cut the five Ds have the actual frame +$O=[256,136,64,40,16,4,2,1]$. A D has value +$A_O(d+p_m/4)$. Since $A_O$ is a bijection on +$B_r$ and $d\in B_r$, its membership in $B_r$ is equivalent to +$p_m\in4B_r$. That condition also keeps every remaining stage of this D in +$B_r$. Q7 remains in $B_r$, since it only combines the initially admitted +dirty D/Q values before its last transport. Thus each terminal coordinate has +the profile $4E_rR^{2^r}$, independently of its final read frame. + +For clarity, equality with the signed-floor pair does **not** require each +internal floor half to be an exact division. If the pair difference is +$(u,v)\in\mathbb Z^2$, ideal outputs are Gaussian integral exactly when +$u\equiv v\pmod2$. In that case + +$$ +\lfloor u/2\rfloor-\lfloor-v/2\rfloor=(u+v)/2, +\quad +\lfloor v/2\rfloor-\lfloor u/2\rfloor=(v-u)/2. +$$ + +These identities hold for positive and negative integers. They give the +literal output exactly, including the odd/odd case. If the parities differ, +the ideal pair is nonintegral and cannot equal an integer literal output. +This proves the necessity and sufficiency used above; the inverse pair has +the corresponding calculation with $i$ replaced by $-i$. + +## 4. The resulting exact module + +At rank nine the canonical diagonal exponents are: + +| Interval | Number | Multiplicities of exponents $0,1,2,3,4$ | Index exponent | +|---|---:|---|---:| +| No transport | 32 | $382,84,36,9,1$ | 187 | +| One rank-one transport | 15 | $326,112,56,16,2$ | 280 | +| Terminal $4B_9$ | 5 | $0,0,0,0,512$ | 2048 | + +Here the index is $2^e$ when the index exponent is $e$, because +$|R/(\pi^k)|=2^k$. The actual frame pullbacks are automorphisms of $B_9$, +and the partial-sum bank change is unimodular. Therefore they do not alter the +quotient type. The complete Y entrance is explicitly isomorphic, in these +coordinates, to the product of the 52 displayed diagonal modules. Its +quotient inside $B_9^{52}$ is + +$$ +(R/(\pi))^{4368}\oplus +(R/(\pi^2))^{1992}\oplus +(R/(\pi^3))^{528}\oplus +(R/(\pi^4))^{2622}. +$$ + +There are also 17,114 unrestricted Gaussian coefficient coordinates. The +total index exponent is + +$$ +32\cdot187+15\cdot280+5\cdot2048=20424. +$$ + +This adds 10,184 stagewise divisibility bits to PR #3426's terminal-only +algebraic index exponent 10,240. These are algebraic quotient counts, not a +physical storage bill or an operation lower bound. In particular, they do not +remove any ownership, precision, routing, or restoration obligation. + +## 5. An explicit typed preparation and inverse + +The in-place entry contract is 52 owned coefficient banks containing +independent arbitrary arrays $a_t\in R^{512}$, together with six separately +admitted dirty D/Q banks in $B_9$. The encoder touches the 52 owned banks; +it leaves those six dirty banks and all other roles unchanged. For each +partial-sum slot, form the appropriate profile: + +$$ +p_t=\begin{cases} +A_H^{-1}E_9D_0a_t,&\text{no transport},\\ +A_H^{-1}M_R^{-1}E_9D_1a_t,&\text{one rank-one transport},\\ +4E_9a_t,&\text{terminal}. +\end{cases} +$$ + +The terminal convention is **positive $4$**, whereas $\pi^4=-4$; the two +images agree but their coefficient fixtures have different signs. Use the +actual inverse path in reverse chronological order, not merely a matrix +having the same frame label. Then recover all Y banks by the groupwise +differences $y_t=p_t-p_{t-1}$. The five D and Q inputs retain their separate +$B_9$ contract. + +Every step is bijective between its stated domains. To invert, compute the +chronological partial sums, apply the actual forward path and (for a rank-one +gap) its right wrapper, apply $E_9^{-1}$, and perform the profile's exact +Gaussian divisions. Terminal decoding divides the Newton coefficients by +positive $4$. An unavailable division rejects. It never rounds an input +into the domain. + +The parameters range over the entire product $R^{512\cdot52}$, so this is +an arbitrary-parameter module construction. It is not restricted to Gaussian +multiples of the paired Y27/Y26 family in PR #3426. That family remains a +credited regression example inside the classified domain. + +`classifier.py` implements the diagonal maps and the bank-coordinate change +without importing a native implementation. Its outputs are exact Python +integers and it does not mutate its inputs. The source layer separately +performs the authenticated frame maps. The functional arrays allocated by +these references are not presented as a measured in-place physical layout. + +## 6. Constructive arithmetic invoice and width + +One in-place $E_r$ schedule uses $r2^{r-1}$ Gaussian additions and the +same number of multiplications by $\pi$. Its inverse uses Gaussian +subtractions and exact divisions by $\pi$. Applying the diagonal one +$\pi$-step at a time costs the sum of its exponents. A terminal multiplication +by positive $4$ is implemented as two Gaussian doublings per entry. + +At rank nine, preparation of all 52 profiles, before their actual frame +pullbacks, costs: + +| Operation | Constructive count | +|---|---:| +| Gaussian additions in the 52 Newton encoders | 119,808 | +| Gaussian multiplications by $\pi$, including the diagonal profiles | 129,992 | +| Gaussian doublings for the five terminal profiles | 5,120 | +| Field subtractions to recover the 52 Y banks | 47 | +| Gaussian subtractions represented by those field subtractions | 24,064 | + +The 47 field differences can be performed in place from the last bank to the +first within each group. Their inverse runs forward. The full preparation +also includes **all 47 nonterminal actual inverse frame paths and all 15 +extra inverse right wrappers**. The source audit finds 158 native occurrences +with total rank 281 in those paths: 71,936 pair gates and 316 native wrappers, +plus the 15 extra wrappers, for 331 wrappers in total. Actual wrapper cycles, +phases, and scratch are recorded in the source-bound invoice. They are not +zero and are not included in the table. + +The literal signed-floor backend uses eight real additions/subtractions and +four real floor-halves per pair, with unit phases separately counted. Counting +one Gaussian addition or $\pi$ multiplication as two real additions gives the +following complete arithmetic sum for preparation, with all frame paths: + +$$ +8\cdot71936+2\cdot119808+2\cdot129992 ++2\cdot5120+2\cdot24064=1,133,456 +$$ + +real additions/subtractions, together with 287,744 real floor-halves. Wrapper +movement and phase costs remain distinct invoice entries. Undo executes the +reversed paths and the exact profile inverses: its real-addition count is +1,123,216, since the 10,240 real terminal doublings become exact halvings. +It additionally has 259,984 real exact halves from Gaussian $\pi$ divisions +and 10,240 real terminal exact halves, as well as the same 287,744 native +floor-halves. These are constructive schedules, with no minimality claim. + +For a finite-width interpretation, let every real and imaginary component of +every supplied coefficient have absolute value at most $H$. The exact +coefficient-to-profile component gains at rank nine are 3456, 3828, and +13,452 for the three rows of the profile table. For example, the first is + +$$ +\sum_{d=0}^9 {9\choose d} + 2^{\lceil\max(4,d)/2\rceil}=3456. +$$ + +The rank-one gain is + +$$ +\sum_{d=0}^8{8\choose d} +[2^{\lceil\max(4,d)/2\rceil} ++2^{\lceil(\max(4,d)+1)/2\rceil}]=3828. +$$ + +These are absolute row sums in real coordinates and bound intermediate +Newton-encoder states as well. + +Every ideal native stage and monomial wrapper is unitary. A 512-entry array +with component bound $M$ has Euclidean norm at most $32M$, so every stage +of a frame pullback has component bound at most $32M$. Thus a nonterminal +partial sum has component bound at most $32\cdot3828H=122,496H$. Terminal +partial sums have bound $13,452H$. The bank-difference schedule has bound +$244,992H$. Separately, allowing a conservative factor five on the native +stage bound for the literal pair's difference, middle, and restore temporaries +gives the encoder-work bound $5\cdot122,496H=612,480H$. +Constant arithmetic work space and diagonal/Newton scratch also +fit this bound. This is less than $2^{20}H$. + +Conversely, if an admitted prepared Y input has component bound $J$, a +partial sum has bound $24J$. Its forward path has bound $768J$, the +Newton decoder has component gain at most 32, and exact profile divisions +do not increase the component bound. A conservative decoder stored bound is +$24,576J$, with temporary bound $98,304J<2^{17}J$. A signed storage +implementation needs a sign bit in addition to these magnitude bounds. +Widths must be reserved explicitly; the Python reference supplies no fixed +width physical implementation. These are codec bounds, not admission or +width statements about an omitted caller or external recipient. + +## 7. What this preparation does and does not pay for + +The preparation is a bijection **from arbitrary coefficient banks to admitted +native-domain Y banks**. It does not preserve the original interpretation of +an arbitrary pre-existing Y input. A caller must supply and prove the +appropriate input/output intertwining for this changed coordinate contract. + +If raw coefficient sources must remain borrowed and unchanged, one explicit +abstract schedule uses 52 owned zero banks, 52 copy ADDs, the preparation, +its inverse after the caller has returned the prepared banks, and 52 cleanup +subtractions against the unchanged sources. That final return is an input +condition to this schedule; it is not proved by a producer-only analysis. +Producing the six dirty D/Q banks from raw coefficients would separately +require six Newton encoders and their ownership/restoration contract. Allowing +arbitrary initially admitted dirty D/Q values does not declare them zero. + +Actual tape routes, copy tariffs, bounded-width gate implementation, supplier +and consumer interfaces, return frames, scratch ownership and liveness, and +any displaced-work credit remain explicit obligations. This result makes a +correlated stagewise producer entrance constructive and reviewable. It does +not reopen the frozen 599/584 profile screen or certify a fully paid caller. + +## 8. Lineage and limits of the new result + +The frozen word is ywz65's PR #2586 word, with its existing native archive and +collector lineage. The source-bound Newton domain and gate intertwiners are +from Clear1nsight's PR #3382; the literal actual-interface analysis is from +Clear1nsight's PR #3423; exact native covariance with phase is from PR #3416. +Nick Petalas / petalas's PR #3426 establishes the ideal correlated terminal +module and a nontrivial exact literal family, and names the stagewise +classification answered here. The wider lattice and collector predecessors +retain their credit in the package source manifest. + +The new universal statement is the explicit product of the two interval +profiles and five terminal profiles, transported by the actual histories and +the unimodular partial-sum change. Finite replay checks its application to +the frozen word; it is not substituted for the algebraic necessity proof. +No predecessor source, selected frontier, full-word claim, or external-port +scope is changed. + +## Concurrent sharp calibration + +At the submission checkpoint, Nick Petalas's independently developed +[PR #3449](https://github.com/CrocSwap/integer-mult-bounds/pull/3449), +head `5cb2ff187a27de1cbd1a37933f7228b35b15702b`, was public. It proves the +sharp $2^{280}$ module for the named $Y27=y$, $Y26=-y$ family across +events 1090, 1092, and 1129, with other sources in $4B_9$. Its Newton +exponent $\max(|S|,4+1_{0\in S})$ equals equation (3) after subtracting +$|S|$ to pass to weighted coefficient coordinates. That supplies a matching +independent calibration of the rank-one formula. Its proof was read at the +checkpoint, after this package's full module and dense receipt had been +constructed. No code, certificate, or provisional claim from it is imported. + +The contribution here is the complete 58-bank entrance, all 47 independently +parameterised intermediate partial sums and five terminal sums, the actual-path +encoder/inverse, and their direct cost/width obligations. No priority over the +concurrent local result is claimed. See [COSTS.md](COSTS.md) for the explicitly +stated component-overwrite model behind the optional SWAP/phase lowering; it +is not an assertion about the repository's stricter ADD tariff. diff --git a/research/p104-stagewise-entrance/README.md b/research/p104-stagewise-entrance/README.md new file mode 100644 index 0000000000..dd0e3bcec2 --- /dev/null +++ b/research/p104-stagewise-entrance/README.md @@ -0,0 +1,256 @@ +# Exact correlated entrance for the first P104 collector + +Clear1nsight, with substantial OpenAI assistance from four concurrent agents. + +This package answers the stagewise admission question left by +[PR #3426](https://github.com/CrocSwap/integer-mult-bounds/pull/3426). +It gives the **maximal correlated entrance within the 58 initial Newton +banks** for exact literal execution of the first collector's **257-event +producer dependency cone**, followed by six admitted collector inputs. It +also supplies an explicit reversible parameterisation and its direct +arithmetic and width bill. + +The result is a local module theorem. Its index is $2^{20424}$, compared with +$2^{10240}$ for the predecessor's ideal final-cut conditions. The additional +factor $2^{10184}$ measures stagewise divisibility constraints. These are +algebraic indices, not saved storage bits or a supplier improvement. + +The frozen main is `6f100d4bb5083f8c35d96fd95a539811c62f245c`. The scientific +WORD and NATIVE bytes are the existing PR #2586 inputs retained through +PR #2665. The selected frontier and the conditional unchanged-profile +**599/584** cost stop are preserved. + +## Exact scope + +Let $R=\mathbb Z[i]$, $\pi=1+i$, and + +$$ +E_r=\begin{pmatrix}1&0\\1&\pi\end{pmatrix}^{\otimes r}, +\qquad B_r=E_rR^{2^r}. +$$ + +The actual rank is nine, with 512 Gaussian coordinates per bank. Initially, +the 52 Y banks and the six dirty banks D31, D30, D29, D28, D27 and Q7 all +belong to $B_9$. Those six dirty values are arbitrary admitted values. + +The classified contract requires every fractional ADD in the selected cone +to have an integral increment, every native pair's literal signed-floor +output to equal its ideal output, and all six target arrays immediately +before zero-based event 2025 to belong to $B_9$. The proof establishes both +necessity and sufficiency within this initial domain. + +The original prefix has 2,025 events, of which 1,768 are outside this cone. +This theorem does not admit their omitted arithmetic histories, the later +external recipients, or genuinely rounded trajectories whose errors later +cancel. The cone contains 200 native occurrences, 52 positive quarter-ADDs, +and five early dirty D-to-Q subtractions. The native rank sum is 354. + +## The admission theorem + +In each actual chronological Y group, replace its sources by independent +partial-sum coordinates + +$$ +p_t=y_1+\cdots+y_t,\qquad y_t=p_t-p_{t-1},\qquad p_0=0. +$$ + +This bank change is unimodular. The five groups have sizes 3, 7, 7, 11 and +24. Their 47 nonterminal intervals have only two types. The five final +partial sums supply the terminal conditions. + +| Partial-sum interval | Count | Diagonal exponent in weighted Newton coordinates | Local index | +|---|---:|---|---:| +| No D transport | 32 | $\max(4-|S|,0)$ | $2^{187}$ | +| One actual rank-one D transport | 15 | $\max(4-|S\setminus\{0\}|,0)$ | $2^{280}$ | +| Terminal sum | 5 | $4$ on every coefficient | $2^{2048}$ | + +For a read-frame map $A_H$ and a rank-one native's actual right wrapper +$M_R$, the nonterminal modules are respectively $A_H^{-1}L_0$ and +$(M_RA_H)^{-1}L_1$, with the displayed diagonal profiles defining $L_0$ +and $L_1$. Every terminal sum belongs to $4B_9$. + +The rank-one condition comes from testing both sides of its actual $C_0$ +stage. Writing a bit-zero pair as $(f,f+\pi g)$ gives +$C(f,f+\pi g)=(f+g,f+ig)$. Both arrays are divisible by four exactly when +both $f$ and $g$ are divisible by four. Testing only the quarter output +would miss this extra condition. + +Consequently the quotient of $B_9^{52}$ by the exact Y entrance +$\mathcal M$ is + +$$ +(R/(\pi))^{4368}\oplus(R/(\pi^2))^{1992} +\oplus(R/(\pi^3))^{528}\oplus(R/(\pi^4))^{2622}. +$$ + +There are also 17,114 unrestricted Gaussian coefficient coordinates. The +index exponent is $32(187)+15(280)+5(2048)=20424$. For the predecessor's +ideal entrance $\mathcal I$ and the strong independent product entrance, + +$$ +(4B_9)^{52}\subsetneq\mathcal M\subsetneq\mathcal I, +\qquad [\mathcal I:\mathcal M]=2^{10184}, +\qquad [\mathcal M:(4B_9)^{52}]=2^{86072}. +$$ + +[PROOF.md](PROOF.md) includes the dirty-input argument, sufficiency of the +quarter increments, terminal admission, and the literal pair parity +criterion. Odd internal floor-halves are allowed when the complete pair +still equals its integral ideal output. + +## Constructive encoder and inverse + +The encoder takes **52 owned arbitrary Gaussian coefficient banks**. It +applies each local diagonal profile and Newton encoder, follows the actual +inverse frame history, applies the extra inverse right wrapper where +required, and finally takes groupwise backward differences. Terminal scaling +uses positive $4$, since $\pi^4=-4$ has a different parameter convention. + +The inverse takes forward partial sums, follows the actual forward histories, +and performs exact Newton and diagonal divisions. It rejects unavailable +divisions. These maps are a bijection onto the entire classified entrance. +The six already admitted dirty D/Q banks are supplied separately. + +This parameterisation changes the numerical meaning of arbitrary raw source +arrays. A useful caller still needs an input/output intertwiner and a proved +returned-source, frame, and ownership contract. Functional Python arrays are +reference implementations of the algebraic schedule, without a measured +physical in-place layout. + +## Direct preparation costs + +The actual 47 nonterminal inverse paths contain 158 native occurrences of +total rank 281. Including the 15 extra right wrappers gives 331 wrapper +occurrences, 10,452 permutation cycles, and 159,020 direct Gaussian payload +SWAPs. The independent counter reconstructs these histories from the frozen +inputs without importing the primary implementation. + +| Arithmetic category | Encoder | Decoder | +|---|---:|---:| +| Real ADD/subtract subtotal before SWAP and phase lowering | 1,133,456 | 1,123,216 | +| Native real signed floor-halves | 287,744 | 287,744 | +| Additional exact real halves | 0 | 270,224 | +| Native pair applications | 71,936 | 71,936 | +| Gaussian payload SWAPs | 159,020 | 159,020 | + +Wrapper phases, native quarter turns, and movement are separately itemised +in [COSTS.md](COSTS.md). Its optional component-arithmetic lowering permits +source-minus-target overwrites; it is not the repository's stricter ADD +tariff. The resulting schedules are constructive upper bounds, with no +minimality claim. + +For raw coefficient component bound $H$, all encoder work is bounded by +$612480H<2^{20}H$. For an admitted Y component bound $J$, decoder work is +bounded by $98304J<2^{17}J$. Signed storage also needs a sign bit. These +bounds concern this codec; physical routing, control, copies, the six dirty +inputs, caller execution, and recursive tariffs still need their own bill. + +## Reproduction and evidence + +No third-party Python dependency is required. The registered Python 3.12 +commands run with ordinary and optimised interpretation: + +```sh +python3 -B scripts/research_package.py --package research/p104-stagewise-entrance --check-only +python3 -B scripts/research_package.py --package research/p104-stagewise-entrance +``` + +Both registered modes passed on CPython 3.12.14, producing the same complete +typed receipt. Its file SHA-256 is +`91b4f644189bacdd19952e360d55d3738a915e50cf98001baf7f47fda54bd561`; +its canonical scientific digest is +`f2ec5be0707ab21f9f7fae68ebb91e862c8ee8eff094fc2e62b37af39b9a0f49`. +Metadata and source pins also passed. Separate CLI processes in a disposable +Git-free copy rejected a missing WORD, a corrupted WORD, and a receipt with +Boolean `true` replacing integer `1`, each for the intended reason. + +Inside a Git-free package export, run: + +```sh +python3 -I -B research/p104-stagewise-entrance/verify.py +python3 -I -O -B research/p104-stagewise-entrance/verify.py +``` + +The verifier rebuilds [RECEIPT.json](RECEIPT.json) and compares its full typed +contents. It authenticates scientific and retained predecessor bytes before +mathematics and again before success. Its six implementation modules execute +from captured source bytes, and their hashes and the verifier hash are +recorded and rechecked. An explicit generation command uses exclusive +creation, so it cannot overwrite an existing receipt silently. + +The evidence includes: + +- Separate primary D-path and independent Y-path constructions agreeing on + the dense initial and cut hashes, with 52 codec roundtrips. Both evaluate + the actual cone and each checks all six full-array cut formulae. +- A deterministic dense fixture checking all 90,624 literal/ideal native + pairs and all 52 exact quarter reads. It passes through a non-$B_9$ + intermediate D28 value at event 1087 and returns admitted cut arrays. +- Two ideal-admitted controls rejected by the module decoder and literal + trace. Their first failures are an inexact quarter at event 1087 and an + inexact native pair at event 1089. +- The credited PR #3426 paired-$64$ family passing the cone and giving a + zero cut. Its cone counts are distinct from that predecessor's full-prefix + experiment. +- Independent threshold checks for every one of the 512 basis directions + in each nonterminal profile, plus an independently reconstructed cost + invoice. The written proof supplies universal necessity and sufficiency; + finite basis checks alone are not a proof for nonlinear rounded paths. +- Rejection of duplicate-key, floating, nonfinite, and Boolean-as-integer + receipt data, unavailable exact profile divisions, and a corrupt frozen + scientific source. + +The reused PR #3382 model is a dependency of the primary implementation. +`independent.py` and `independent_cost.py` import neither it nor the primary +layers. Complete native covariance is inherited from PR #3416; binding the +recipes here does not recertify its full 1,245-record theorem. No independent +human review or formal proof-kernel acceptance is claimed. + +## Coordination and credit + +The canonical claim is +[Discussion #2750, comment 19009685](https://github.com/CrocSwap/integer-mult-bounds/discussions/2750#discussioncomment-19009685). +The submission checkpoint found unchanged main and completed all four +open-PR pages, 368 records, alongside targeted Discussion refreshes. This is +a scoped overlap review, not a complete novelty certificate. + +The mathematical and source predecessors include ywz65's PR #2586 word, +Arham Tahir's PR #2665 retention, Clear1nsight's PR #3382 Newton domain and +PR #3423 producer interfaces, Nick Petalas's PR #3416 native covariance and +PR #3426 ideal correlated entrance, Tekalign's PR #3025 literal-floor and +PR #3218 phase-sensitive checks, Ross Richardson's PR #3068 domain question, +and Jose Manuel and Vasek W's inherited unchanged-profile cost stop. +[SOURCES.json](SOURCES.json) records exact source identities and retained +proofs, with the older collector lineage retained in the exported sources. + +Nick Petalas's concurrent +[PR #3449](https://github.com/CrocSwap/integer-mult-bounds/pull/3449), at +`5cb2ff187a27de1cbd1a37933f7228b35b15702b`, independently gives the sharp +index-$280$ condition for the particular Y27/Y26 rank-one window. Its proof +was read at submission and agrees with the local profile above. This package +adds the general 58-bank module, all 52 independent partial-sum coordinates, +and the actual-path codec and bill. No priority over that concurrent local +formula is claimed. + +Hiroki Kumazaki's PR #3446 recipient closure and Nick Petalas's PR #3448 +all-depth product entrance are complementary results. Their complete +executables were not replayed here, and their scopes are not absorbed into +this producer claim. + +## Open next questions + +1. **Which actual caller consumes these coefficient coordinates and returns + the prepared banks for undo?** Name its output, prove the input/output + intertwiner and return equations, and price copies, control, routes, + widths, cleanup, and displaced work. No such paid caller is supplied by + this producer theorem. +2. **What further stagewise conditions does that caller need outside the + cone?** Intersect this explicit module with its additional authenticated + reads and recipient histories. Coordinate with PR #3446's closure and + PR #3449's noncone-read handoff. The required whole execution and ownership + boundary must be specified first. +3. **Can a named changed supplier profile afford the complete bill?** Declare + the changed coverage or cost hypothesis and apply a fully charged + optimistic moment screen before another supplier construction round. + The unchanged 599/584 screen remains a stop; the larger admission module + supplies no new selected frontier or all-size transfer. diff --git a/research/p104-stagewise-entrance/RECEIPT.json b/research/p104-stagewise-entrance/RECEIPT.json new file mode 100644 index 0000000000..9a1fc154b0 --- /dev/null +++ b/research/p104-stagewise-entrance/RECEIPT.json @@ -0,0 +1,17450 @@ +{ + "controls": { + "native": { + "failure": { + "address": 0, + "bank": "D28", + "bit": 0, + "event": 1089, + "inputs": [ + [ + 0, + 0 + ], + [ + -1, + 0 + ] + ], + "kind": "nonintegral_ideal_pair", + "twice_ideal": [ + [ + -1, + 1 + ], + [ + -1, + -1 + ] + ] + }, + "ideal_group_sums_zero": true, + "initial_sha256": "7d0b75a35b53853425df123d21aa204026ee121b1896fc7ea1f89cca9bfddd62", + "ok": false, + "pairs_checked": 66816, + "profile_admitted": false + }, + "paired64": { + "cut_in_b": { + "D27": true, + "D28": true, + "D29": true, + "D30": true, + "D31": true, + "Q7": true + }, + "cut_sha256": "7a8dada02354a244485e2ea97a2d6d3826f1ddbb9cfeda2de90bc026afa1c044", + "first_non_b": { + "bank": "D31", + "event": 1090 + }, + "ideal_group_sums_zero": true, + "initial_sha256": "1b08d299fd9dab5599a7fa476fe40cce961705d5f444a9a6363647dabce34eef", + "max_state_component": 64, + "ok": true, + "pairs_checked": 90624, + "profile_admitted": true + }, + "quarter": { + "failure": { + "bank": "D28", + "component": 0, + "coordinate": 0, + "denominator": 4, + "event": 1087, + "kind": "nonintegral_fractional_add", + "numerator": 1, + "source": "Y103", + "value": 1 + }, + "ideal_group_sums_zero": true, + "initial_sha256": "27f1fd8d745e271eee471dd1bee81c6fa4bb4d275aaad66670ad5da3ec000925", + "ok": false, + "pairs_checked": 66816, + "profile_admitted": false + } + }, + "dense_fixture": { + "actual_path_codec_roundtrips": 52, + "cut_in_b": { + "D27": true, + "D28": true, + "D29": true, + "D30": true, + "D31": true, + "Q7": true + }, + "cut_sha256": "049e894e20c96bf4662310f44ca9327e6e03996100116023fe0dbc89940bcc74", + "first_non_b": { + "bank": "D28", + "event": 1087 + }, + "full_array_cut_equations_checked": 6, + "initial_bank_sha256": { + "D27": "3fde5f1da58f029ace9ead6f7c1e157224663fa02fc93636533c46d8c73bc1cb", + "D28": "62bc0e4ad1bca2e750e1cb8a0c980ba763f848d47281c5513c52a82cb61add3b", + "D29": "689df5ee4abedf7e31498572019e549e9510715a20f4d415710dc539effa60a4", + "D30": "c0fc005fa7ea3f512b3978a893052d2134a40147fb13a1ba6d61d4f8b1224b52", + "D31": "39cd411d051e174d250b3e73501082e9266ab5f7050cd71ccd74cd99e978a643", + "Q7": "05fc2e65372df70075e6da95edbfe63b3caaaa9c4bc1f8a3b8c585057fcc31c3", + "Y100": "66d4ab31977cb64cc574a459ae3189b4d20287e7c6c80d273ec18dc535b377da", + "Y101": "a779738e9faa142a066e3e6a335ec2c2a2f6930190b9bf3fb132fea1110ee5b9", + "Y102": "6c0df766afaf967dca4d6d50ffa30adaed00f0c860190cc25d859c2d80f781db", + "Y103": "8312a3bfe4241d4887999ac5333701065247ac7a3730100ce37d46283ec99e06", + "Y22": "dbbed8cf72f95cb507f4ae84e9b807cc92090559eb3320b8b36d66725b215cd1", + "Y23": "48fc268d10142a30a9e3863ccf66fbc0f00f198d31ce7b4cd96b6d07a276d647", + "Y24": "a6f988ab721a8ccaac1d06645ba5642bd98db5c27882221743a1a422b2cbfe8f", + "Y25": "3b6bca5508489b4c6796c59da2d5c61e5d6ad1d30c79e91f451f1b9bfd32202a", + "Y26": "99c42f893e2caefb826d9410a8fd15d28e34ea2ea4bf4623634a43d7af9707ab", + "Y27": "fe7d99fce9af767c621a6cd240cc80e6e113d5a91032b0f6e8ea11c3b4b11c1a", + "Y28": "63f819a903638c9124d1158029c45a137f82dd2c3fa57e8028f2944d0d4f7686", + "Y29": "7706794260284649bb8079323de526c4add31b595052de25ce24e29c33742177", + "Y30": "348e2b88ed5914ab3d490d724e4be18b984992291b75ef87c47ad9635aabb981", + "Y31": "cf31eca33c66ee787557c2f44e6149e9fd8510eb34a4f0570f75ef512b929833", + "Y32": "15eb7343f4f03074e3a6481bd7862068026013213d242bbc5a1d5875c018e89b", + "Y63": "f91127cf620b032f63199bd15cc04ad8f0e22b77c9451c8c357d3bb11ec0a047", + "Y64": "c4c2268ad9c987de064854b64f3f1a3b974ea3f65f85adad4a9d2a4b60e98286", + "Y65": "0b51ac406ecece931aacb8f1e2d3ee02a623cc74ba04140f42a7e1562deafff5", + "Y66": "36b403be7d52e5d0905c123709a66ae800f62991a5d5db6337dad966ecfeb39d", + "Y67": "f74e85818f1276d562d8a67f0136cf7bffce6475051ce9afdfb3013de822f648", + "Y68": "ae380f1c109a4b5263e8a7aba3670a3af5ad1930a99579a0accca4fd89f91e7a", + "Y69": "6d3ea11fe370daf96262ac70cfa4aecf31ccb197be780c5c6070e76f567b587c", + "Y70": "7f85ca5dfc74f008835228661d1fa3f6d3f73e8f5b5f6f8c89c70c0d230f1295", + "Y71": "15715d8cd756ce5e5c50c55c9b20058a912ebc1533e2f6958bcf7e5bd0d4e898", + "Y72": "e7e7322b1372c0259ee3ce8ef617ac4e1105ee28e91452c7bd9f06221cf07cf9", + "Y73": "18e04888363262595c0513dd9ca913dda323202bb13e5be64c0e62b2ae23d24c", + "Y74": "3afeb0f1932c39b8eb243bdb33acca73d8f900e4dfd8910f848be8e70497293b", + "Y75": "2adb7a314ada8c64a16527fee11c0efd8310e441d89fb5ad92985557c8b32127", + "Y76": "3f20981f2505b6bc7ee085991ca4976134fb0d10a862bee4b8a3566c44a08172", + "Y77": "924d2763feed20eb1795c52c2a6b9bc2a2acbec83a1264153936591b3799eb16", + "Y78": "2a6a15ecf7ce6ae8269dacb8cc9d25e66429a7c09a1116a537d99446049347b0", + "Y79": "7cdd6163e1ddc95861850d75e484d728039ad6277d28d112eaf12be49c79f9f4", + "Y80": "bbdd6bd40150cb7fceff161b1952b60c49a72754ed409c90456edd7d02c8bf67", + "Y81": "f11306967c6a96464734af67f3ca3b67098c04f75b51a2f20191ae6f15f6e39a", + "Y82": "c2d672f1ad2dfe989d6ad127774469b721f897325b69aa77f6583acfc63fa7db", + "Y83": "ebf039dcb428317c8265b2e67f7f4fb1094889eb6f8aaad652ccb945c0bd5e72", + "Y84": "6ccdeb81276886409c942da31b99954a24f256c24567c3b141918603eb31bef4", + "Y85": "ec92b4b22acc859901e8c582e0718914dbdd42bcec9f3e3d2714eae89be90d84", + "Y86": "d2c97109a5050b9ce5c517ff946dab19fcb07131474d740f7851f5b412bcec7d", + "Y87": "a6225bbf9e23648c34ef8ddbaef843459a57df238abecebc46aa39e30cbfc763", + "Y88": "8ec0bde47dea667e8a2a1b4c828bfe96585275b51a221686985902fb5e33b2dd", + "Y89": "8372a417186571cb15178f1c205fcd19d62bdaa7373c5ddc9541fd0399fb40f6", + "Y90": "a602a579046181d7107c01d65b5d1a8e317766ffcdb58eb52ba8deb97456075e", + "Y91": "58758a9338c08934406459b71080e33349844046d378e8fa64335a569d52ecbd", + "Y92": "be12d788849aef74f0adbc46dabdf408c3c204e8ebe35750f5766978aeb33f2f", + "Y93": "e3b833572a307a6b33486b75e6e2601ebf91e48bd295e3fd58f49d48b3126048", + "Y94": "7b1e20c94cbf0d7a40a725e5def8768e591d927a48e533ca844b3acfa6d250b0", + "Y95": "5d72251328540dcb439867022a87974936483094202347e546700a3ca65506eb", + "Y96": "4489c74abf21be03a0e0ef045c291bd3bd142fa2ff9c50094e9bcb07ac03c3c1", + "Y97": "3a00e19ac60282ea06022fb9591304a296d575109c0fb5d24caafb87a37388dd", + "Y98": "edc9e0febc909a73ef0c7fa7783e7148d758129aa702816f86650d27c1bd189a", + "Y99": "82feeca04bd0654b086841cb90f08482b6c99602a73a1c7a895a741ef1c37f26" + }, + "initial_sha256": "4a1ead3a71275d790b35a2289640c293f02026a9fe7985b7a8aed84eaf3fa706", + "max_state_component": 1332, + "ok": true, + "pairs_checked": 90624 + }, + "implementation_sha256": { + "admission.py": "00bd8c666fa758e76e47fb3e8835dd71770d1ce32c55d71d8d003dca2da15709", + "classifier.py": "3e42ba4e5fa1cc819f3e7b773b38ca47476bf85f581f888cc99690e1cf2f2b40", + "costs.py": "ae0c8a721d825eec69d36e645b30ce42337cc820655503298d9b459a695a79d8", + "independent.py": "50f65c0430f63a51048e78fde3aab5e99d5a450fedbec03254bdf6079f749be0", + "independent_cost.py": "3aa08580f25fcee22a1cd438950fb0bfe54b12eafdf09e493f5dc3efdf9e5009", + "source.py": "c54dabffe141de6befb6069e145c5ccbde629e76afb0f0afa3eb07bd72ab4b25", + "verify.py": "befbd6483191e7708e4ca19cf01235f7090613685086e633fbdcc85b6bab68aa" + }, + "independent": { + "cone": { + "count": 257, + "events": [ + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 908, + 909, + 910, + 911, + 912, + 913, + 914, + 915, + 916, + 917, + 972, + 980, + 981, + 982, + 983, + 984, + 985, + 986, + 987, + 988, + 989, + 990, + 991, + 992, + 993, + 994, + 995, + 996, + 997, + 998, + 999, + 1000, + 1001, + 1002, + 1003, + 1004, + 1005, + 1006, + 1007, + 1008, + 1009, + 1010, + 1011, + 1012, + 1013, + 1014, + 1015, + 1016, + 1017, + 1018, + 1019, + 1020, + 1051, + 1052, + 1053, + 1054, + 1055, + 1056, + 1057, + 1058, + 1059, + 1060, + 1061, + 1085, + 1087, + 1089, + 1090, + 1092, + 1093, + 1095, + 1097, + 1100, + 1103, + 1106, + 1109, + 1121, + 1124, + 1126, + 1128, + 1129, + 1131, + 1133, + 1135, + 1138, + 1141, + 1144, + 1147, + 1149, + 1152, + 1155, + 1157, + 1159, + 1161, + 1162, + 1164, + 1166, + 1169, + 1172, + 1175, + 1177, + 1179, + 1222, + 1224, + 1226, + 1228, + 1230, + 1231, + 1233, + 1235, + 1238, + 1240, + 1242, + 1245, + 1247, + 1250, + 1252, + 1254, + 1257, + 1259, + 1262, + 1264, + 1267, + 1269, + 1271, + 1273, + 1275, + 1277, + 1279, + 1281, + 1283, + 1285, + 1287, + 1289, + 1292, + 1294, + 1296, + 1298, + 1389, + 1391, + 1393, + 1395, + 1397, + 1399, + 1401, + 1403, + 1406, + 1408, + 1410, + 1412, + 1415, + 1417, + 1419, + 1421, + 1423, + 1425, + 1427, + 1429, + 1431, + 1433, + 1436, + 1438, + 1440, + 1442, + 1444, + 1446, + 1448, + 1450, + 1452, + 1453, + 1455, + 1457, + 1459, + 1461, + 1598, + 1600, + 1602, + 1604, + 1606, + 1608, + 1610, + 1612, + 1614, + 1616, + 1618, + 1620, + 1622, + 1624, + 1626, + 1628, + 1630, + 1632, + 1633, + 1635, + 1637, + 1639, + 1641, + 1643, + 1817, + 1819, + 1821, + 1823, + 1825, + 1827, + 1829, + 1831 + ], + "events_sha256": "798d43437c1911e7237d5eb7ce92f496b2ef6dca05359110349eca1c5386bdf4", + "initial_count": 58, + "initial_roles": [ + "D27", + "D28", + "D29", + "D30", + "D31", + "Q7", + "Y100", + "Y101", + "Y102", + "Y103", + "Y22", + "Y23", + "Y24", + "Y25", + "Y26", + "Y27", + "Y28", + "Y29", + "Y30", + "Y31", + "Y32", + "Y63", + "Y64", + "Y65", + "Y66", + "Y67", + "Y68", + "Y69", + "Y70", + "Y71", + "Y72", + "Y73", + "Y74", + "Y75", + "Y76", + "Y77", + "Y78", + "Y79", + "Y80", + "Y81", + "Y82", + "Y83", + "Y84", + "Y85", + "Y86", + "Y87", + "Y88", + "Y89", + "Y90", + "Y91", + "Y92", + "Y93", + "Y94", + "Y95", + "Y96", + "Y97", + "Y98", + "Y99" + ], + "native_rank_sum": 354 + }, + "controls": { + "first_quarter": { + "first_failure": { + "address": 0, + "event": 1087, + "kind": "nonintegral_quarter", + "source": "Y103", + "value": [ + 1, + 0 + ] + }, + "ideal_group_sums_zero": true, + "initial_B": true, + "initial_sha256": "27f1fd8d745e271eee471dd1bee81c6fa4bb4d275aaad66670ad5da3ec000925" + }, + "known_paired64": { + "active_native_events": [ + 130, + 131, + 1056, + 1057, + 1092, + 1097 + ], + "counts": { + "additions": 57, + "literal_pair_comparisons": 2048, + "native_occurrences": 200, + "quarter_reads": 52 + }, + "cut_bank_sha256": { + "D27": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "D28": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "D29": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "D30": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "D31": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16", + "Q7": "c8e145f4220685e764568718191bfa96c3227f8b845bc8032698b49d8f8b4d16" + }, + "cut_sha256": "7a8dada02354a244485e2ea97a2d6d3826f1ddbb9cfeda2de90bc026afa1c044", + "first_non_B": { + "bank": "D31", + "event": 1090 + }, + "initial_sha256": "1b08d299fd9dab5599a7fa476fe40cce961705d5f444a9a6363647dabce34eef" + }, + "post_native": { + "first_failure": { + "address": 0, + "bit": 0, + "event": 1089, + "inputs": [ + [ + 0, + 0 + ], + [ + -1, + 0 + ] + ], + "kind": "nonintegral_native_pair", + "literal": [ + [ + -1, + 1 + ], + [ + -1, + 0 + ] + ], + "numerators": [ + [ + -1, + 1 + ], + [ + -1, + -1 + ] + ] + }, + "ideal_group_sums_zero": true, + "initial_B": true, + "initial_sha256": "7d0b75a35b53853425df123d21aa204026ee121b1896fc7ea1f89cca9bfddd62" + } + }, + "generated_fixture": { + "active_native_events": [ + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 909, + 911, + 913, + 915, + 917, + 972, + 980, + 981, + 982, + 983, + 984, + 985, + 986, + 987, + 988, + 989, + 990, + 991, + 992, + 993, + 994, + 995, + 996, + 997, + 998, + 999, + 1000, + 1001, + 1002, + 1003, + 1004, + 1005, + 1006, + 1007, + 1008, + 1009, + 1010, + 1011, + 1012, + 1013, + 1014, + 1015, + 1016, + 1017, + 1018, + 1019, + 1020, + 1051, + 1052, + 1053, + 1054, + 1055, + 1056, + 1057, + 1058, + 1059, + 1060, + 1061, + 1085, + 1089, + 1092, + 1095, + 1097, + 1100, + 1103, + 1106, + 1109, + 1121, + 1124, + 1128, + 1131, + 1133, + 1135, + 1138, + 1141, + 1144, + 1147, + 1149, + 1152, + 1155, + 1161, + 1164, + 1166, + 1169, + 1172, + 1175, + 1179, + 1222, + 1224, + 1230, + 1233, + 1235, + 1238, + 1240, + 1242, + 1245, + 1247, + 1250, + 1252, + 1254, + 1257, + 1259, + 1262, + 1264, + 1267, + 1269, + 1273, + 1275, + 1277, + 1279, + 1285, + 1287, + 1289, + 1292, + 1298, + 1395, + 1397, + 1399, + 1401, + 1403, + 1406, + 1408, + 1410, + 1412, + 1415, + 1417, + 1419, + 1427, + 1429, + 1431, + 1433, + 1436, + 1438, + 1440, + 1442, + 1444, + 1452, + 1461, + 1598, + 1600, + 1602, + 1604, + 1606, + 1608, + 1610, + 1612, + 1632, + 1643 + ], + "actual_source_paths": true, + "checked_partial_sums": 52, + "counts": { + "additions": 57, + "literal_pair_comparisons": 90624, + "native_occurrences": 200, + "quarter_reads": 52 + }, + "cut_bank_sha256": { + "D27": "d751955da588107ae95b78d8f31d92d1fc530fdb9243598fce546c7697dd9464", + "D28": "7c239a608c222f5b8fb00bba96c9240360f614288e1d00d31c80aa04b22c2bb4", + "D29": "383194b6e6547d2fe44cf1f6d3cd4f3f7cf17a839cb4a6bb3a042ca38f3b2539", + "D30": "0a2317c42eb5f1cb2b22938191c7542cbf3dc89b0dfe713bcb96a4374e77a2c2", + "D31": "5f757b4d3e571937012707feff42c69a7b719712f99ab71c11dfdd653f5e07d1", + "Q7": "b0e1b7cdf73ce06f3c5b051290c6e3c0212ff1d1dc5bd874fb1eacc7b581ff03" + }, + "cut_sha256": "049e894e20c96bf4662310f44ca9327e6e03996100116023fe0dbc89940bcc74", + "first_non_B": { + "bank": "D28", + "event": 1087 + }, + "full_array_cut_formula_checks": 6, + "initial_sha256": "4a1ead3a71275d790b35a2289640c293f02026a9fe7985b7a8aed84eaf3fa706" + }, + "groups": [ + { + "bank": "D31", + "reads": [ + { + "event": 1090, + "source": "Y27" + }, + { + "event": 1129, + "source": "Y26" + }, + { + "event": 1231, + "source": "Y99" + } + ] + }, + { + "bank": "D30", + "reads": [ + { + "event": 1093, + "source": "Y93" + }, + { + "event": 1126, + "source": "Y94" + }, + { + "event": 1226, + "source": "Y96" + }, + { + "event": 1228, + "source": "Y95" + }, + { + "event": 1389, + "source": "Y102" + }, + { + "event": 1391, + "source": "Y101" + }, + { + "event": 1393, + "source": "Y100" + } + ] + }, + { + "bank": "D29", + "reads": [ + { + "event": 1177, + "source": "Y65" + }, + { + "event": 1294, + "source": "Y64" + }, + { + "event": 1296, + "source": "Y63" + }, + { + "event": 1453, + "source": "Y70" + }, + { + "event": 1455, + "source": "Y69" + }, + { + "event": 1457, + "source": "Y68" + }, + { + "event": 1459, + "source": "Y66" + } + ] + }, + { + "bank": "D28", + "reads": [ + { + "event": 1087, + "source": "Y103" + }, + { + "event": 1162, + "source": "Y31" + }, + { + "event": 1271, + "source": "Y22" + }, + { + "event": 1421, + "source": "Y29" + }, + { + "event": 1423, + "source": "Y28" + }, + { + "event": 1425, + "source": "Y23" + }, + { + "event": 1633, + "source": "Y78" + }, + { + "event": 1635, + "source": "Y75" + }, + { + "event": 1637, + "source": "Y74" + }, + { + "event": 1639, + "source": "Y73" + }, + { + "event": 1641, + "source": "Y72" + } + ] + }, + { + "bank": "D27", + "reads": [ + { + "event": 1157, + "source": "Y98" + }, + { + "event": 1159, + "source": "Y97" + }, + { + "event": 1281, + "source": "Y79" + }, + { + "event": 1283, + "source": "Y71" + }, + { + "event": 1446, + "source": "Y84" + }, + { + "event": 1448, + "source": "Y77" + }, + { + "event": 1450, + "source": "Y25" + }, + { + "event": 1614, + "source": "Y92" + }, + { + "event": 1616, + "source": "Y88" + }, + { + "event": 1618, + "source": "Y87" + }, + { + "event": 1620, + "source": "Y83" + }, + { + "event": 1622, + "source": "Y76" + }, + { + "event": 1624, + "source": "Y67" + }, + { + "event": 1626, + "source": "Y32" + }, + { + "event": 1628, + "source": "Y30" + }, + { + "event": 1630, + "source": "Y24" + }, + { + "event": 1817, + "source": "Y91" + }, + { + "event": 1819, + "source": "Y90" + }, + { + "event": 1821, + "source": "Y89" + }, + { + "event": 1823, + "source": "Y86" + }, + { + "event": 1825, + "source": "Y85" + }, + { + "event": 1827, + "source": "Y82" + }, + { + "event": 1829, + "source": "Y81" + }, + { + "event": 1831, + "source": "Y80" + } + ] + } + ], + "inputs": { + "NATIVE.json.gz": "ab91c78835c3e10cf3b2cb8a5d4e0b7cfc3df1ae5a811298d27842f2193e1e3d", + "WORD.json": "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50" + }, + "profiles": { + "rank_one": { + "counts": { + "0": 326, + "1": 112, + "2": 56, + "3": 16, + "4": 2 + }, + "exponents": [ + 4, + 4, + 3, + 3, + 3, + 3, + 2, + 2, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "index_log2": 280, + "minimal_basis_checks": 512, + "strict_preceding_exponent_rejections": 186 + }, + "terminal": { + "counts": { + "4": 512 + }, + "index_log2": 2048 + }, + "whole": { + "counts": { + "0": 17114, + "1": 4368, + "2": 1992, + "3": 528, + "4": 2622 + }, + "index_log2": 20424 + }, + "zero": { + "counts": { + "0": 382, + "1": 84, + "2": 36, + "3": 9, + "4": 1 + }, + "exponents": [ + 4, + 3, + 3, + 2, + 3, + 2, + 2, + 1, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "index_log2": 187, + "minimal_basis_checks": 512, + "strict_preceding_exponent_rejections": 130 + } + }, + "scope": "257-event dependency cone; full-word frame binding is structural only", + "slots": [ + { + "bank": "D31", + "event": 1090, + "frame": [ + 157, + 56, + 2 + ], + "kind": "rank_one", + "next_event": 1129, + "source": "Y27", + "source_path": [ + 131, + 1056 + ], + "transport_event": 1092 + }, + { + "bank": "D31", + "event": 1129, + "frame": [ + 152, + 56, + 5, + 2 + ], + "kind": "rank_one", + "next_event": 1231, + "source": "Y26", + "source_path": [ + 130, + 1057, + 1097 + ], + "transport_event": 1131 + }, + { + "bank": "D31", + "event": 1231, + "frame": [ + 320, + 152, + 56, + 5, + 2 + ], + "kind": "terminal", + "next_event": null, + "source": "Y99", + "source_path": [ + 203, + 984 + ], + "transport_event": null + }, + { + "bank": "D30", + "event": 1093, + "frame": [ + 80, + 61, + 2 + ], + "kind": "rank_one", + "next_event": 1126, + "source": "Y93", + "source_path": [ + 197, + 990 + ], + "transport_event": 1095 + }, + { + "bank": "D30", + "event": 1126, + "frame": [ + 272, + 80, + 61, + 2 + ], + "kind": "rank_one", + "next_event": 1226, + "source": "Y94", + "source_path": [ + 198, + 989 + ], + "transport_event": 1128 + }, + { + "bank": "D30", + "event": 1226, + "frame": [ + 272, + 157, + 80, + 61, + 2 + ], + "kind": "zero", + "next_event": 1228, + "source": "Y96", + "source_path": [ + 200, + 987, + 1121 + ], + "transport_event": null + }, + { + "bank": "D30", + "event": 1228, + "frame": [ + 272, + 157, + 80, + 61, + 2 + ], + "kind": "rank_one", + "next_event": 1389, + "source": "Y95", + "source_path": [ + 199, + 988 + ], + "transport_event": 1230 + }, + { + "bank": "D30", + "event": 1389, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "kind": "zero", + "next_event": 1391, + "source": "Y102", + "source_path": [ + 206, + 981, + 1124, + 1222 + ], + "transport_event": null + }, + { + "bank": "D30", + "event": 1391, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "kind": "zero", + "next_event": 1393, + "source": "Y101", + "source_path": [ + 205, + 982, + 1224 + ], + "transport_event": null + }, + { + "bank": "D30", + "event": 1393, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "kind": "terminal", + "next_event": null, + "source": "Y100", + "source_path": [ + 204, + 983 + ], + "transport_event": null + }, + { + "bank": "D29", + "event": 1177, + "frame": [ + 204, + 40, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1294, + "source": "Y65", + "source_path": [ + 169, + 1018 + ], + "transport_event": 1179 + }, + { + "bank": "D29", + "event": 1294, + "frame": [ + 137, + 69, + 40, + 21, + 2 + ], + "kind": "zero", + "next_event": 1296, + "source": "Y64", + "source_path": [ + 168, + 1019 + ], + "transport_event": null + }, + { + "bank": "D29", + "event": 1296, + "frame": [ + 137, + 69, + 40, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1453, + "source": "Y63", + "source_path": [ + 167, + 1020, + 1138 + ], + "transport_event": 1298 + }, + { + "bank": "D29", + "event": 1453, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "zero", + "next_event": 1455, + "source": "Y70", + "source_path": [ + 174, + 1013 + ], + "transport_event": null + }, + { + "bank": "D29", + "event": 1455, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "zero", + "next_event": 1457, + "source": "Y69", + "source_path": [ + 173, + 1014, + 1250 + ], + "transport_event": null + }, + { + "bank": "D29", + "event": 1457, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "zero", + "next_event": 1459, + "source": "Y68", + "source_path": [ + 172, + 1015, + 1147, + 1252 + ], + "transport_event": null + }, + { + "bank": "D29", + "event": 1459, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "terminal", + "next_event": null, + "source": "Y66", + "source_path": [ + 170, + 1017, + 1103, + 1149, + 1254 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1087, + "frame": [ + 85, + 56, + 2 + ], + "kind": "rank_one", + "next_event": 1162, + "source": "Y103", + "source_path": [ + 207, + 980 + ], + "transport_event": 1089 + }, + { + "bank": "D28", + "event": 1162, + "frame": [ + 64, + 45, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1271, + "source": "Y31", + "source_path": [ + 135, + 1052, + 1106 + ], + "transport_event": 1164 + }, + { + "bank": "D28", + "event": 1271, + "frame": [ + 64, + 40, + 16, + 5, + 2 + ], + "kind": "rank_one", + "next_event": 1421, + "source": "Y22", + "source_path": [ + 126, + 1061 + ], + "transport_event": 1273 + }, + { + "bank": "D28", + "event": 1421, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "zero", + "next_event": 1423, + "source": "Y29", + "source_path": [ + 133, + 1054, + 1267 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1423, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "zero", + "next_event": 1425, + "source": "Y28", + "source_path": [ + 132, + 1055, + 1169, + 1269 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1425, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "rank_one", + "next_event": 1633, + "source": "Y23", + "source_path": [ + 127, + 1060 + ], + "transport_event": 1427 + }, + { + "bank": "D28", + "event": 1633, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1635, + "source": "Y78", + "source_path": [ + 182, + 1005, + 1141, + 1257, + 1406 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1635, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1637, + "source": "Y75", + "source_path": [ + 179, + 1008, + 1235, + 1408 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1637, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1639, + "source": "Y74", + "source_path": [ + 178, + 1009 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1639, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1641, + "source": "Y73", + "source_path": [ + 177, + 1010, + 1410 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1641, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "terminal", + "next_event": null, + "source": "Y72", + "source_path": [ + 176, + 1011, + 1259, + 1412 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1157, + "frame": [ + 360, + 136, + 21, + 2 + ], + "kind": "zero", + "next_event": 1159, + "source": "Y98", + "source_path": [ + 202, + 985 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1159, + "frame": [ + 360, + 136, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1281, + "source": "Y97", + "source_path": [ + 201, + 986, + 1085 + ], + "transport_event": 1161 + }, + { + "bank": "D27", + "event": 1281, + "frame": [ + 260, + 136, + 108, + 21, + 2 + ], + "kind": "zero", + "next_event": 1283, + "source": "Y79", + "source_path": [ + 183, + 1004 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1283, + "frame": [ + 260, + 136, + 108, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1446, + "source": "Y71", + "source_path": [ + 175, + 1012, + 1172 + ], + "transport_event": 1285 + }, + { + "bank": "D27", + "event": 1446, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "kind": "zero", + "next_event": 1448, + "source": "Y84", + "source_path": [ + 188, + 999 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1448, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "kind": "zero", + "next_event": 1450, + "source": "Y77", + "source_path": [ + 181, + 1006, + 1287 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1450, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1614, + "source": "Y25", + "source_path": [ + 129, + 1058, + 1166, + 1289 + ], + "transport_event": 1452 + }, + { + "bank": "D27", + "event": 1614, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1616, + "source": "Y92", + "source_path": [ + 196, + 991, + 1275, + 1436 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1616, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1618, + "source": "Y88", + "source_path": [ + 192, + 995, + 1292, + 1438 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1618, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1620, + "source": "Y87", + "source_path": [ + 191, + 996, + 1440 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1620, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1622, + "source": "Y83", + "source_path": [ + 187, + 1000 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1622, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1624, + "source": "Y76", + "source_path": [ + 180, + 1007, + 1429 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1624, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1626, + "source": "Y67", + "source_path": [ + 171, + 1016, + 1109, + 1175, + 1277, + 1442 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1626, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1628, + "source": "Y32", + "source_path": [ + 136, + 1051, + 1155, + 1279, + 1444 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1628, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1630, + "source": "Y30", + "source_path": [ + 134, + 1053, + 1152, + 1262, + 1431 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1630, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "rank_one", + "next_event": 1817, + "source": "Y24", + "source_path": [ + 128, + 1059, + 1264, + 1433 + ], + "transport_event": 1632 + }, + { + "bank": "D27", + "event": 1817, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1819, + "source": "Y91", + "source_path": [ + 195, + 992, + 1133, + 1238, + 1397, + 1598 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1819, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1821, + "source": "Y90", + "source_path": [ + 194, + 993, + 1100, + 1135, + 1240, + 1399, + 1600 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1821, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1823, + "source": "Y89", + "source_path": [ + 193, + 994, + 1144, + 1245, + 1415, + 1602 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1823, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1825, + "source": "Y86", + "source_path": [ + 190, + 997, + 1242, + 1401, + 1604 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1825, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1827, + "source": "Y85", + "source_path": [ + 189, + 998, + 1247, + 1417, + 1606 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1827, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1829, + "source": "Y82", + "source_path": [ + 186, + 1001, + 1403, + 1608 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1829, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1831, + "source": "Y81", + "source_path": [ + 185, + 1002, + 1610 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1831, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "terminal", + "next_event": null, + "source": "Y80", + "source_path": [ + 184, + 1003, + 1419, + 1612 + ], + "transport_event": null + } + ], + "status": "PASS_INDEPENDENT_STAGEWISE_ENTRANCE" + }, + "independent_cost": { + "cut": 2025, + "decode": { + "bank_sums": 47, + "codec_exact_real_halvings": 270224, + "native_real_floor_halvings": 287744, + "real_add_sub": 1123216 + }, + "decoder_forward_wrapper_phase_histogram": { + "0": 61696, + "1": 29312, + "2": 32512, + "3": 45952 + }, + "encode": { + "bank_differences": 47, + "extra_diagonal_pi_multiplications": 10184, + "native_real_floor_halvings": 287744, + "newton_tensor_pairs": 119808, + "real_add_sub_excluding_doublings": 1123216, + "real_add_sub_if_doubling_is_add": 1133456, + "real_doublings": 10240, + "terminal_gaussian_doublings": 5120 + }, + "encoder_inverse_wrapper_phase_histogram": { + "0": 61696, + "1": 45952, + "2": 32512, + "3": 29312 + }, + "gap_counts": { + "0": 32, + "1": 15 + }, + "gaps": [ + { + "donor": "D31", + "donor_path": [ + 909 + ], + "gap_rank": 1, + "gap_transport": [ + 1092 + ], + "next_event": 1129, + "position": 0, + "read_event": 1090 + }, + { + "donor": "D31", + "donor_path": [ + 909, + 1092 + ], + "gap_rank": 1, + "gap_transport": [ + 1131 + ], + "next_event": 1231, + "position": 1, + "read_event": 1129 + }, + { + "donor": "D30", + "donor_path": [ + 911 + ], + "gap_rank": 1, + "gap_transport": [ + 1095 + ], + "next_event": 1126, + "position": 0, + "read_event": 1093 + }, + { + "donor": "D30", + "donor_path": [ + 911, + 1095 + ], + "gap_rank": 1, + "gap_transport": [ + 1128 + ], + "next_event": 1226, + "position": 1, + "read_event": 1126 + }, + { + "donor": "D30", + "donor_path": [ + 911, + 1095, + 1128 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1228, + "position": 2, + "read_event": 1226 + }, + { + "donor": "D30", + "donor_path": [ + 911, + 1095, + 1128 + ], + "gap_rank": 1, + "gap_transport": [ + 1230 + ], + "next_event": 1389, + "position": 3, + "read_event": 1228 + }, + { + "donor": "D30", + "donor_path": [ + 911, + 1095, + 1128, + 1230 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1391, + "position": 4, + "read_event": 1389 + }, + { + "donor": "D30", + "donor_path": [ + 911, + 1095, + 1128, + 1230 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1393, + "position": 5, + "read_event": 1391 + }, + { + "donor": "D29", + "donor_path": [ + 913 + ], + "gap_rank": 1, + "gap_transport": [ + 1179 + ], + "next_event": 1294, + "position": 0, + "read_event": 1177 + }, + { + "donor": "D29", + "donor_path": [ + 913, + 1179 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1296, + "position": 1, + "read_event": 1294 + }, + { + "donor": "D29", + "donor_path": [ + 913, + 1179 + ], + "gap_rank": 1, + "gap_transport": [ + 1298 + ], + "next_event": 1453, + "position": 2, + "read_event": 1296 + }, + { + "donor": "D29", + "donor_path": [ + 913, + 1179, + 1298 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1455, + "position": 3, + "read_event": 1453 + }, + { + "donor": "D29", + "donor_path": [ + 913, + 1179, + 1298 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1457, + "position": 4, + "read_event": 1455 + }, + { + "donor": "D29", + "donor_path": [ + 913, + 1179, + 1298 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1459, + "position": 5, + "read_event": 1457 + }, + { + "donor": "D28", + "donor_path": [ + 915 + ], + "gap_rank": 1, + "gap_transport": [ + 1089 + ], + "next_event": 1162, + "position": 0, + "read_event": 1087 + }, + { + "donor": "D28", + "donor_path": [ + 915, + 1089 + ], + "gap_rank": 1, + "gap_transport": [ + 1164 + ], + "next_event": 1271, + "position": 1, + "read_event": 1162 + }, + { + "donor": "D28", + "donor_path": [ + 915, + 1089, + 1164 + ], + "gap_rank": 1, + "gap_transport": [ + 1273 + ], + "next_event": 1421, + "position": 2, + "read_event": 1271 + }, + { + "donor": "D28", + "donor_path": [ + 915, + 1089, + 1164, + 1273 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1423, + "position": 3, + "read_event": 1421 + }, + { + "donor": "D28", + "donor_path": [ + 915, + 1089, + 1164, + 1273 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1425, + "position": 4, + "read_event": 1423 + }, + { + "donor": "D28", + "donor_path": [ + 915, + 1089, + 1164, + 1273 + ], + "gap_rank": 1, + "gap_transport": [ + 1427 + ], + "next_event": 1633, + "position": 5, + "read_event": 1425 + }, + { + "donor": "D28", + "donor_path": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1635, + "position": 6, + "read_event": 1633 + }, + { + "donor": "D28", + "donor_path": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1637, + "position": 7, + "read_event": 1635 + }, + { + "donor": "D28", + "donor_path": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1639, + "position": 8, + "read_event": 1637 + }, + { + "donor": "D28", + "donor_path": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1641, + "position": 9, + "read_event": 1639 + }, + { + "donor": "D27", + "donor_path": [ + 917 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1159, + "position": 0, + "read_event": 1157 + }, + { + "donor": "D27", + "donor_path": [ + 917 + ], + "gap_rank": 1, + "gap_transport": [ + 1161 + ], + "next_event": 1281, + "position": 1, + "read_event": 1159 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1283, + "position": 2, + "read_event": 1281 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161 + ], + "gap_rank": 1, + "gap_transport": [ + 1285 + ], + "next_event": 1446, + "position": 3, + "read_event": 1283 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1448, + "position": 4, + "read_event": 1446 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1450, + "position": 5, + "read_event": 1448 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285 + ], + "gap_rank": 1, + "gap_transport": [ + 1452 + ], + "next_event": 1614, + "position": 6, + "read_event": 1450 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1616, + "position": 7, + "read_event": 1614 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1618, + "position": 8, + "read_event": 1616 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1620, + "position": 9, + "read_event": 1618 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1622, + "position": 10, + "read_event": 1620 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1624, + "position": 11, + "read_event": 1622 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1626, + "position": 12, + "read_event": 1624 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1628, + "position": 13, + "read_event": 1626 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1630, + "position": 14, + "read_event": 1628 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452 + ], + "gap_rank": 1, + "gap_transport": [ + 1632 + ], + "next_event": 1817, + "position": 15, + "read_event": 1630 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1819, + "position": 16, + "read_event": 1817 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1821, + "position": 17, + "read_event": 1819 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1823, + "position": 18, + "read_event": 1821 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1825, + "position": 19, + "read_event": 1823 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1827, + "position": 20, + "read_event": 1825 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1829, + "position": 21, + "read_event": 1827 + }, + { + "donor": "D27", + "donor_path": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "gap_rank": 0, + "gap_transport": [], + "next_event": 1831, + "position": 22, + "read_event": 1829 + } + ], + "groups": [ + { + "donor": "D31", + "source_reads": [ + [ + 1090, + "Y27" + ], + [ + 1129, + "Y26" + ], + [ + 1231, + "Y99" + ] + ] + }, + { + "donor": "D30", + "source_reads": [ + [ + 1093, + "Y93" + ], + [ + 1126, + "Y94" + ], + [ + 1226, + "Y96" + ], + [ + 1228, + "Y95" + ], + [ + 1389, + "Y102" + ], + [ + 1391, + "Y101" + ], + [ + 1393, + "Y100" + ] + ] + }, + { + "donor": "D29", + "source_reads": [ + [ + 1177, + "Y65" + ], + [ + 1294, + "Y64" + ], + [ + 1296, + "Y63" + ], + [ + 1453, + "Y70" + ], + [ + 1455, + "Y69" + ], + [ + 1457, + "Y68" + ], + [ + 1459, + "Y66" + ] + ] + }, + { + "donor": "D28", + "source_reads": [ + [ + 1087, + "Y103" + ], + [ + 1162, + "Y31" + ], + [ + 1271, + "Y22" + ], + [ + 1421, + "Y29" + ], + [ + 1423, + "Y28" + ], + [ + 1425, + "Y23" + ], + [ + 1633, + "Y78" + ], + [ + 1635, + "Y75" + ], + [ + 1637, + "Y74" + ], + [ + 1639, + "Y73" + ], + [ + 1641, + "Y72" + ] + ] + }, + { + "donor": "D27", + "source_reads": [ + [ + 1157, + "Y98" + ], + [ + 1159, + "Y97" + ], + [ + 1281, + "Y79" + ], + [ + 1283, + "Y71" + ], + [ + 1446, + "Y84" + ], + [ + 1448, + "Y77" + ], + [ + 1450, + "Y25" + ], + [ + 1614, + "Y92" + ], + [ + 1616, + "Y88" + ], + [ + 1618, + "Y87" + ], + [ + 1620, + "Y83" + ], + [ + 1622, + "Y76" + ], + [ + 1624, + "Y67" + ], + [ + 1626, + "Y32" + ], + [ + 1628, + "Y30" + ], + [ + 1630, + "Y24" + ], + [ + 1817, + "Y91" + ], + [ + 1819, + "Y90" + ], + [ + 1821, + "Y89" + ], + [ + 1823, + "Y86" + ], + [ + 1825, + "Y85" + ], + [ + 1827, + "Y82" + ], + [ + 1829, + "Y81" + ], + [ + 1831, + "Y80" + ] + ] + } + ], + "height": { + "bank_difference_factor": 244992, + "coefficient_to_local_value_row_gains": { + "rank_one": 3828, + "terminal": 13452, + "zero": 3456 + }, + "inverse_path_payload_factor": 122496, + "pair_work_factor": 612480, + "terminal_difference_factor": 135948 + }, + "ideal_index_log2": 10240, + "index_log2": 20424, + "inverse_donor_native_occurrences": 158, + "inverse_donor_occurrence_rows": [ + { + "event": 909, + "group": "D31", + "position": 0, + "rank": 3 + }, + { + "event": 1092, + "group": "D31", + "position": 1, + "rank": 1 + }, + { + "event": 909, + "group": "D31", + "position": 1, + "rank": 3 + }, + { + "event": 911, + "group": "D30", + "position": 0, + "rank": 3 + }, + { + "event": 1095, + "group": "D30", + "position": 1, + "rank": 1 + }, + { + "event": 911, + "group": "D30", + "position": 1, + "rank": 3 + }, + { + "event": 1128, + "group": "D30", + "position": 2, + "rank": 1 + }, + { + "event": 1095, + "group": "D30", + "position": 2, + "rank": 1 + }, + { + "event": 911, + "group": "D30", + "position": 2, + "rank": 3 + }, + { + "event": 1128, + "group": "D30", + "position": 3, + "rank": 1 + }, + { + "event": 1095, + "group": "D30", + "position": 3, + "rank": 1 + }, + { + "event": 911, + "group": "D30", + "position": 3, + "rank": 3 + }, + { + "event": 1230, + "group": "D30", + "position": 4, + "rank": 1 + }, + { + "event": 1128, + "group": "D30", + "position": 4, + "rank": 1 + }, + { + "event": 1095, + "group": "D30", + "position": 4, + "rank": 1 + }, + { + "event": 911, + "group": "D30", + "position": 4, + "rank": 3 + }, + { + "event": 1230, + "group": "D30", + "position": 5, + "rank": 1 + }, + { + "event": 1128, + "group": "D30", + "position": 5, + "rank": 1 + }, + { + "event": 1095, + "group": "D30", + "position": 5, + "rank": 1 + }, + { + "event": 911, + "group": "D30", + "position": 5, + "rank": 3 + }, + { + "event": 913, + "group": "D29", + "position": 0, + "rank": 4 + }, + { + "event": 1179, + "group": "D29", + "position": 1, + "rank": 1 + }, + { + "event": 913, + "group": "D29", + "position": 1, + "rank": 4 + }, + { + "event": 1179, + "group": "D29", + "position": 2, + "rank": 1 + }, + { + "event": 913, + "group": "D29", + "position": 2, + "rank": 4 + }, + { + "event": 1298, + "group": "D29", + "position": 3, + "rank": 1 + }, + { + "event": 1179, + "group": "D29", + "position": 3, + "rank": 1 + }, + { + "event": 913, + "group": "D29", + "position": 3, + "rank": 4 + }, + { + "event": 1298, + "group": "D29", + "position": 4, + "rank": 1 + }, + { + "event": 1179, + "group": "D29", + "position": 4, + "rank": 1 + }, + { + "event": 913, + "group": "D29", + "position": 4, + "rank": 4 + }, + { + "event": 1298, + "group": "D29", + "position": 5, + "rank": 1 + }, + { + "event": 1179, + "group": "D29", + "position": 5, + "rank": 1 + }, + { + "event": 913, + "group": "D29", + "position": 5, + "rank": 4 + }, + { + "event": 915, + "group": "D28", + "position": 0, + "rank": 3 + }, + { + "event": 1089, + "group": "D28", + "position": 1, + "rank": 1 + }, + { + "event": 915, + "group": "D28", + "position": 1, + "rank": 3 + }, + { + "event": 1164, + "group": "D28", + "position": 2, + "rank": 1 + }, + { + "event": 1089, + "group": "D28", + "position": 2, + "rank": 1 + }, + { + "event": 915, + "group": "D28", + "position": 2, + "rank": 3 + }, + { + "event": 1273, + "group": "D28", + "position": 3, + "rank": 1 + }, + { + "event": 1164, + "group": "D28", + "position": 3, + "rank": 1 + }, + { + "event": 1089, + "group": "D28", + "position": 3, + "rank": 1 + }, + { + "event": 915, + "group": "D28", + "position": 3, + "rank": 3 + }, + { + "event": 1273, + "group": "D28", + "position": 4, + "rank": 1 + }, + { + "event": 1164, + "group": "D28", + "position": 4, + "rank": 1 + }, + { + "event": 1089, + "group": "D28", + "position": 4, + "rank": 1 + }, + { + "event": 915, + "group": "D28", + "position": 4, + "rank": 3 + }, + { + "event": 1273, + "group": "D28", + "position": 5, + "rank": 1 + }, + { + "event": 1164, + "group": "D28", + "position": 5, + "rank": 1 + }, + { + "event": 1089, + "group": "D28", + "position": 5, + "rank": 1 + }, + { + "event": 915, + "group": "D28", + "position": 5, + "rank": 3 + }, + { + "event": 1427, + "group": "D28", + "position": 6, + "rank": 1 + }, + { + "event": 1273, + "group": "D28", + "position": 6, + "rank": 1 + }, + { + "event": 1164, + "group": "D28", + "position": 6, + "rank": 1 + }, + { + "event": 1089, + "group": "D28", + "position": 6, + "rank": 1 + }, + { + "event": 915, + "group": "D28", + "position": 6, + "rank": 3 + }, + { + "event": 1427, + "group": "D28", + "position": 7, + "rank": 1 + }, + { + "event": 1273, + "group": "D28", + "position": 7, + "rank": 1 + }, + { + "event": 1164, + "group": "D28", + "position": 7, + "rank": 1 + }, + { + "event": 1089, + "group": "D28", + "position": 7, + "rank": 1 + }, + { + "event": 915, + "group": "D28", + "position": 7, + "rank": 3 + }, + { + "event": 1427, + "group": "D28", + "position": 8, + "rank": 1 + }, + { + "event": 1273, + "group": "D28", + "position": 8, + "rank": 1 + }, + { + "event": 1164, + "group": "D28", + "position": 8, + "rank": 1 + }, + { + "event": 1089, + "group": "D28", + "position": 8, + "rank": 1 + }, + { + "event": 915, + "group": "D28", + "position": 8, + "rank": 3 + }, + { + "event": 1427, + "group": "D28", + "position": 9, + "rank": 1 + }, + { + "event": 1273, + "group": "D28", + "position": 9, + "rank": 1 + }, + { + "event": 1164, + "group": "D28", + "position": 9, + "rank": 1 + }, + { + "event": 1089, + "group": "D28", + "position": 9, + "rank": 1 + }, + { + "event": 915, + "group": "D28", + "position": 9, + "rank": 3 + }, + { + "event": 917, + "group": "D27", + "position": 0, + "rank": 4 + }, + { + "event": 917, + "group": "D27", + "position": 1, + "rank": 4 + }, + { + "event": 1161, + "group": "D27", + "position": 2, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 2, + "rank": 4 + }, + { + "event": 1161, + "group": "D27", + "position": 3, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 3, + "rank": 4 + }, + { + "event": 1285, + "group": "D27", + "position": 4, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 4, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 4, + "rank": 4 + }, + { + "event": 1285, + "group": "D27", + "position": 5, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 5, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 5, + "rank": 4 + }, + { + "event": 1285, + "group": "D27", + "position": 6, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 6, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 6, + "rank": 4 + }, + { + "event": 1452, + "group": "D27", + "position": 7, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 7, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 7, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 7, + "rank": 4 + }, + { + "event": 1452, + "group": "D27", + "position": 8, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 8, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 8, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 8, + "rank": 4 + }, + { + "event": 1452, + "group": "D27", + "position": 9, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 9, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 9, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 9, + "rank": 4 + }, + { + "event": 1452, + "group": "D27", + "position": 10, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 10, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 10, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 10, + "rank": 4 + }, + { + "event": 1452, + "group": "D27", + "position": 11, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 11, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 11, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 11, + "rank": 4 + }, + { + "event": 1452, + "group": "D27", + "position": 12, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 12, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 12, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 12, + "rank": 4 + }, + { + "event": 1452, + "group": "D27", + "position": 13, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 13, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 13, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 13, + "rank": 4 + }, + { + "event": 1452, + "group": "D27", + "position": 14, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 14, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 14, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 14, + "rank": 4 + }, + { + "event": 1452, + "group": "D27", + "position": 15, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 15, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 15, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 15, + "rank": 4 + }, + { + "event": 1632, + "group": "D27", + "position": 16, + "rank": 1 + }, + { + "event": 1452, + "group": "D27", + "position": 16, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 16, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 16, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 16, + "rank": 4 + }, + { + "event": 1632, + "group": "D27", + "position": 17, + "rank": 1 + }, + { + "event": 1452, + "group": "D27", + "position": 17, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 17, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 17, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 17, + "rank": 4 + }, + { + "event": 1632, + "group": "D27", + "position": 18, + "rank": 1 + }, + { + "event": 1452, + "group": "D27", + "position": 18, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 18, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 18, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 18, + "rank": 4 + }, + { + "event": 1632, + "group": "D27", + "position": 19, + "rank": 1 + }, + { + "event": 1452, + "group": "D27", + "position": 19, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 19, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 19, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 19, + "rank": 4 + }, + { + "event": 1632, + "group": "D27", + "position": 20, + "rank": 1 + }, + { + "event": 1452, + "group": "D27", + "position": 20, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 20, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 20, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 20, + "rank": 4 + }, + { + "event": 1632, + "group": "D27", + "position": 21, + "rank": 1 + }, + { + "event": 1452, + "group": "D27", + "position": 21, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 21, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 21, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 21, + "rank": 4 + }, + { + "event": 1632, + "group": "D27", + "position": 22, + "rank": 1 + }, + { + "event": 1452, + "group": "D27", + "position": 22, + "rank": 1 + }, + { + "event": 1285, + "group": "D27", + "position": 22, + "rank": 1 + }, + { + "event": 1161, + "group": "D27", + "position": 22, + "rank": 1 + }, + { + "event": 917, + "group": "D27", + "position": 22, + "rank": 4 + } + ], + "limits": [ + "Mutable in-place coefficient banks; functional Python allocation is not priced.", + "Swaps and Gaussian phase applications remain separately listed primitives.", + "Counts do not price an arbitrary caller, borrowed copies, all physical routing/control or recursive bill.", + "A codec inverse is proved only on its image; this does not admit an intervening consumer.", + "Preparation arithmetic does not prove all omitted original-prefix events exact." + ], + "method": "Independent direct JSON/gzip source scan; no package imports", + "optional_fully_lowered_real_arithmetic": { + "component_swap_real_adds": 441600, + "encode_real_add_sub_excluding_doublings": 2518936, + "encode_real_add_sub_including_doublings": 2529176, + "explicit_real_negations": 212224, + "gaussian_swap_real_adds": 954120, + "model": "Gaussian payload SWAP=6 real add/sub; real-component SWAP=3 add/sub; each +/-i has one negation, each -1 two; no extra clean swap ancilla; source-minus-target overwrite is permitted, so this is not the strict target-ADD tariff.", + "phase_and_native_quarter_turn_component_swaps": 147200 + }, + "pair_applications": 71936, + "quotient_exponent_histogram": { + "0": 17114, + "1": 4368, + "2": 1992, + "3": 528, + "4": 2622 + }, + "rank_mass": 281, + "source_hashes": { + "NATIVE.json.gz": "ab91c78835c3e10cf3b2cb8a5d4e0b7cfc3df1ae5a811298d27842f2193e1e3d", + "WORD.json": "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50" + }, + "status": "PASS", + "strong_4B52_index_log2": 106496, + "wrapper_cycles": 10452, + "wrapper_groups": { + "inverse donor path": { + "cycles": 9748, + "occurrences": 316, + "swaps": 152044 + }, + "inverse extra right wrapper": { + "cycles": 704, + "occurrences": 15, + "swaps": 6976 + } + }, + "wrapper_occurrences": 331, + "wrapper_phase_applications": 169472, + "wrapper_rows": [ + { + "cycle_lengths": { + "14": 8, + "2": 8, + "28": 12, + "4": 12 + }, + "cycles": 40, + "event": 1092, + "group": "D31", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 0, + "purpose": "inverse extra right wrapper", + "record": 316, + "side": "right", + "swaps": 472 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 909, + "group": "D31", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 0, + "purpose": "inverse donor path", + "record": 48, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 909, + "group": "D31", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 0, + "purpose": "inverse donor path", + "record": 48, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "14": 9, + "2": 1, + "28": 9, + "4": 1, + "7": 18 + }, + "cycles": 40, + "event": 1131, + "group": "D31", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 1, + "purpose": "inverse extra right wrapper", + "record": 302, + "side": "right", + "swaps": 472 + }, + { + "cycle_lengths": { + "1": 4, + "21": 4, + "3": 4, + "42": 8, + "6": 8, + "7": 4 + }, + "cycles": 32, + "event": 1092, + "group": "D31", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 316, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "14": 8, + "2": 8, + "28": 12, + "4": 12 + }, + "cycles": 40, + "event": 1092, + "group": "D31", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 316, + "side": "right", + "swaps": 472 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 909, + "group": "D31", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 48, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 909, + "group": "D31", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 48, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "10": 3, + "2": 1, + "20": 9, + "4": 3, + "40": 6, + "5": 6, + "8": 2 + }, + "cycles": 32, + "event": 1095, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 0, + "purpose": "inverse extra right wrapper", + "record": 182, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 0, + "purpose": "inverse donor path", + "record": 16, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 0, + "purpose": "inverse donor path", + "record": 16, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1128, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse extra right wrapper", + "record": 787, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1095, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 182, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "1": 2, + "10": 3, + "2": 1, + "20": 9, + "4": 3, + "40": 6, + "5": 6, + "8": 2 + }, + "cycles": 32, + "event": 1095, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 182, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 16, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 16, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 4, + "21": 4, + "3": 4, + "42": 8, + "6": 8, + "7": 4 + }, + "cycles": 32, + "event": 1128, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 787, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1128, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 787, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1095, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 182, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "1": 2, + "10": 3, + "2": 1, + "20": 9, + "4": 3, + "40": 6, + "5": 6, + "8": 2 + }, + "cycles": 32, + "event": 1095, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 182, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 16, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 16, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "124": 4, + "4": 4 + }, + "cycles": 8, + "event": 1230, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 3, + "purpose": "inverse extra right wrapper", + "record": 841, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "21": 4, + "3": 4, + "42": 8, + "6": 8, + "7": 4 + }, + "cycles": 32, + "event": 1128, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 787, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1128, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 787, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1095, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 182, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "1": 2, + "10": 3, + "2": 1, + "20": 9, + "4": 3, + "40": 6, + "5": 6, + "8": 2 + }, + "cycles": 32, + "event": 1095, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 182, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 16, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 16, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 2, + "21": 24, + "3": 2 + }, + "cycles": 28, + "event": 1230, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 841, + "side": "left", + "swaps": 484 + }, + { + "cycle_lengths": { + "124": 4, + "4": 4 + }, + "cycles": 8, + "event": 1230, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 841, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "21": 4, + "3": 4, + "42": 8, + "6": 8, + "7": 4 + }, + "cycles": 32, + "event": 1128, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 787, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1128, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 787, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1095, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 182, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "1": 2, + "10": 3, + "2": 1, + "20": 9, + "4": 3, + "40": 6, + "5": 6, + "8": 2 + }, + "cycles": 32, + "event": 1095, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 182, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 16, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 16, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 2, + "21": 24, + "3": 2 + }, + "cycles": 28, + "event": 1230, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 841, + "side": "left", + "swaps": 484 + }, + { + "cycle_lengths": { + "124": 4, + "4": 4 + }, + "cycles": 8, + "event": 1230, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 841, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "21": 4, + "3": 4, + "42": 8, + "6": 8, + "7": 4 + }, + "cycles": 32, + "event": 1128, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 787, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1128, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 787, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1095, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 182, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "1": 2, + "10": 3, + "2": 1, + "20": 9, + "4": 3, + "40": 6, + "5": 6, + "8": 2 + }, + "cycles": 32, + "event": 1095, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 182, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 16, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 911, + "group": "D30", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 16, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 4, + "124": 2, + "2": 2, + "31": 4, + "4": 2, + "62": 2 + }, + "cycles": 16, + "event": 1179, + "group": "D29", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 0, + "purpose": "inverse extra right wrapper", + "record": 346, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 0, + "purpose": "inverse donor path", + "record": 62, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 0, + "purpose": "inverse donor path", + "record": 62, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 1179, + "group": "D29", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 346, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "124": 2, + "2": 2, + "31": 4, + "4": 2, + "62": 2 + }, + "cycles": 16, + "event": 1179, + "group": "D29", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 346, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 62, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 62, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "12": 40, + "4": 8 + }, + "cycles": 48, + "event": 1298, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 2, + "purpose": "inverse extra right wrapper", + "record": 274, + "side": "right", + "swaps": 464 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 1179, + "group": "D29", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 346, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "124": 2, + "2": 2, + "31": 4, + "4": 2, + "62": 2 + }, + "cycles": 16, + "event": 1179, + "group": "D29", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 346, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 62, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 62, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1298, + "group": "D29", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 274, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "12": 40, + "4": 8 + }, + "cycles": 48, + "event": 1298, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 274, + "side": "right", + "swaps": 464 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 1179, + "group": "D29", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 346, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "124": 2, + "2": 2, + "31": 4, + "4": 2, + "62": 2 + }, + "cycles": 16, + "event": 1179, + "group": "D29", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 346, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 62, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 62, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1298, + "group": "D29", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 274, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "12": 40, + "4": 8 + }, + "cycles": 48, + "event": 1298, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 274, + "side": "right", + "swaps": 464 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 1179, + "group": "D29", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 346, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "124": 2, + "2": 2, + "31": 4, + "4": 2, + "62": 2 + }, + "cycles": 16, + "event": 1179, + "group": "D29", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 346, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 62, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 62, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1298, + "group": "D29", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 274, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "12": 40, + "4": 8 + }, + "cycles": 48, + "event": 1298, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 274, + "side": "right", + "swaps": 464 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 1179, + "group": "D29", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 346, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "124": 2, + "2": 2, + "31": 4, + "4": 2, + "62": 2 + }, + "cycles": 16, + "event": 1179, + "group": "D29", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 346, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 62, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 913, + "group": "D29", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 62, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 64, + "2": 128, + "3": 192 + }, + "position": 0, + "purpose": "inverse extra right wrapper", + "record": 187, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 0, + "purpose": "inverse donor path", + "record": 19, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 0, + "purpose": "inverse donor path", + "record": 19, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 32, + "2": 48, + "4": 96 + }, + "cycles": 176, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse extra right wrapper", + "record": 171, + "side": "right", + "swaps": 336 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 187, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 64, + "2": 128, + "3": 192 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 187, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 19, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 19, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 4, + "2": 2, + "4": 6, + "8": 60 + }, + "cycles": 72, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 2, + "purpose": "inverse extra right wrapper", + "record": 170, + "side": "right", + "swaps": 440 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 171, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 32, + "2": 48, + "4": 96 + }, + "cycles": 176, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 171, + "side": "right", + "swaps": 336 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 187, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 64, + "2": 128, + "3": 192 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 187, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 19, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 19, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 2, + "12": 40, + "3": 2, + "6": 4 + }, + "cycles": 48, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 170, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "1": 4, + "2": 2, + "4": 6, + "8": 60 + }, + "cycles": 72, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 170, + "side": "right", + "swaps": 440 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 171, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 32, + "2": 48, + "4": 96 + }, + "cycles": 176, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 171, + "side": "right", + "swaps": 336 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 187, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 64, + "2": 128, + "3": 192 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 187, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 19, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 19, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 2, + "12": 40, + "3": 2, + "6": 4 + }, + "cycles": 48, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 170, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "1": 4, + "2": 2, + "4": 6, + "8": 60 + }, + "cycles": 72, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 170, + "side": "right", + "swaps": 440 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 171, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 32, + "2": 48, + "4": 96 + }, + "cycles": 176, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 171, + "side": "right", + "swaps": 336 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 187, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 64, + "2": 128, + "3": 192 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 187, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 19, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 19, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "4": 128 + }, + "cycles": 128, + "event": 1427, + "group": "D28", + "inverse_phase_counts": { + "0": 0, + "1": 128, + "2": 0, + "3": 384 + }, + "position": 5, + "purpose": "inverse extra right wrapper", + "record": 258, + "side": "right", + "swaps": 384 + }, + { + "cycle_lengths": { + "1": 2, + "12": 40, + "3": 2, + "6": 4 + }, + "cycles": 48, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 170, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "1": 4, + "2": 2, + "4": 6, + "8": 60 + }, + "cycles": 72, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 170, + "side": "right", + "swaps": 440 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 171, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 32, + "2": 48, + "4": 96 + }, + "cycles": 176, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 171, + "side": "right", + "swaps": 336 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 187, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 64, + "2": 128, + "3": 192 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 187, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 19, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 19, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 64, + "7": 64 + }, + "cycles": 128, + "event": 1427, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 258, + "side": "left", + "swaps": 384 + }, + { + "cycle_lengths": { + "4": 128 + }, + "cycles": 128, + "event": 1427, + "group": "D28", + "inverse_phase_counts": { + "0": 0, + "1": 128, + "2": 0, + "3": 384 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 258, + "side": "right", + "swaps": 384 + }, + { + "cycle_lengths": { + "1": 2, + "12": 40, + "3": 2, + "6": 4 + }, + "cycles": 48, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 170, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "1": 4, + "2": 2, + "4": 6, + "8": 60 + }, + "cycles": 72, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 170, + "side": "right", + "swaps": 440 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 171, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 32, + "2": 48, + "4": 96 + }, + "cycles": 176, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 171, + "side": "right", + "swaps": 336 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 187, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 64, + "2": 128, + "3": 192 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 187, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 19, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 19, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 64, + "7": 64 + }, + "cycles": 128, + "event": 1427, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 258, + "side": "left", + "swaps": 384 + }, + { + "cycle_lengths": { + "4": 128 + }, + "cycles": 128, + "event": 1427, + "group": "D28", + "inverse_phase_counts": { + "0": 0, + "1": 128, + "2": 0, + "3": 384 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 258, + "side": "right", + "swaps": 384 + }, + { + "cycle_lengths": { + "1": 2, + "12": 40, + "3": 2, + "6": 4 + }, + "cycles": 48, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 170, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "1": 4, + "2": 2, + "4": 6, + "8": 60 + }, + "cycles": 72, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 170, + "side": "right", + "swaps": 440 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 171, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 32, + "2": 48, + "4": 96 + }, + "cycles": 176, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 171, + "side": "right", + "swaps": 336 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 187, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 64, + "2": 128, + "3": 192 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 187, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 19, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 19, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 64, + "7": 64 + }, + "cycles": 128, + "event": 1427, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 258, + "side": "left", + "swaps": 384 + }, + { + "cycle_lengths": { + "4": 128 + }, + "cycles": 128, + "event": 1427, + "group": "D28", + "inverse_phase_counts": { + "0": 0, + "1": 128, + "2": 0, + "3": 384 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 258, + "side": "right", + "swaps": 384 + }, + { + "cycle_lengths": { + "1": 2, + "12": 40, + "3": 2, + "6": 4 + }, + "cycles": 48, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 170, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "1": 4, + "2": 2, + "4": 6, + "8": 60 + }, + "cycles": 72, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 170, + "side": "right", + "swaps": 440 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 171, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 32, + "2": 48, + "4": 96 + }, + "cycles": 176, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 171, + "side": "right", + "swaps": 336 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 187, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 64, + "2": 128, + "3": 192 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 187, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 19, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 19, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 64, + "7": 64 + }, + "cycles": 128, + "event": 1427, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 258, + "side": "left", + "swaps": 384 + }, + { + "cycle_lengths": { + "4": 128 + }, + "cycles": 128, + "event": 1427, + "group": "D28", + "inverse_phase_counts": { + "0": 0, + "1": 128, + "2": 0, + "3": 384 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 258, + "side": "right", + "swaps": 384 + }, + { + "cycle_lengths": { + "1": 2, + "12": 40, + "3": 2, + "6": 4 + }, + "cycles": 48, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 170, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "1": 4, + "2": 2, + "4": 6, + "8": 60 + }, + "cycles": 72, + "event": 1273, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 128, + "2": 0, + "3": 128 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 170, + "side": "right", + "swaps": 440 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 171, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 32, + "2": 48, + "4": 96 + }, + "cycles": 176, + "event": 1164, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 171, + "side": "right", + "swaps": 336 + }, + { + "cycle_lengths": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 187, + "side": "left", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 1089, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 64, + "2": 128, + "3": 192 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 187, + "side": "right", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 19, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "event": 915, + "group": "D28", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 19, + "side": "right", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 0, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 0, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 1, + "purpose": "inverse extra right wrapper", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 1, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 2, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 3, + "purpose": "inverse extra right wrapper", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 3, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 4, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 5, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 6, + "purpose": "inverse extra right wrapper", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 6, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 7, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 8, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 9, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 10, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 10, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 10, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 10, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 10, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 10, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 10, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 10, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 11, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 11, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 11, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 11, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 11, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 11, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 11, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 11, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 12, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 12, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 12, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 12, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 12, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 12, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 12, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 12, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 13, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 13, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 13, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 13, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 13, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 13, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 13, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 13, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 14, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 14, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 14, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 14, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 14, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 14, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 14, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 14, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 2, + "15": 8, + "3": 2, + "30": 12, + "6": 4 + }, + "cycles": 28, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 15, + "purpose": "inverse extra right wrapper", + "record": 621, + "side": "right", + "swaps": 484 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 15, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 15, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 15, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 15, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 15, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 15, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 15, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 15, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 2, + "17": 30 + }, + "cycles": 32, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 16, + "purpose": "inverse donor path", + "record": 621, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 2, + "15": 8, + "3": 2, + "30": 12, + "6": 4 + }, + "cycles": 28, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 16, + "purpose": "inverse donor path", + "record": 621, + "side": "right", + "swaps": 484 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 16, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 16, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 16, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 16, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 16, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 16, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 16, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 16, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 2, + "17": 30 + }, + "cycles": 32, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 17, + "purpose": "inverse donor path", + "record": 621, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 2, + "15": 8, + "3": 2, + "30": 12, + "6": 4 + }, + "cycles": 28, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 17, + "purpose": "inverse donor path", + "record": 621, + "side": "right", + "swaps": 484 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 17, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 17, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 17, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 17, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 17, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 17, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 17, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 17, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 2, + "17": 30 + }, + "cycles": 32, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 18, + "purpose": "inverse donor path", + "record": 621, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 2, + "15": 8, + "3": 2, + "30": 12, + "6": 4 + }, + "cycles": 28, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 18, + "purpose": "inverse donor path", + "record": 621, + "side": "right", + "swaps": 484 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 18, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 18, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 18, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 18, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 18, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 18, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 18, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 18, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 2, + "17": 30 + }, + "cycles": 32, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 19, + "purpose": "inverse donor path", + "record": 621, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 2, + "15": 8, + "3": 2, + "30": 12, + "6": 4 + }, + "cycles": 28, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 19, + "purpose": "inverse donor path", + "record": 621, + "side": "right", + "swaps": 484 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 19, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 19, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 19, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 19, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 19, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 19, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 19, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 19, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 2, + "17": 30 + }, + "cycles": 32, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 20, + "purpose": "inverse donor path", + "record": 621, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 2, + "15": 8, + "3": 2, + "30": 12, + "6": 4 + }, + "cycles": 28, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 20, + "purpose": "inverse donor path", + "record": 621, + "side": "right", + "swaps": 484 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 20, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 20, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 20, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 20, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 20, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 20, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 20, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 20, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 2, + "17": 30 + }, + "cycles": 32, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 21, + "purpose": "inverse donor path", + "record": 621, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 2, + "15": 8, + "3": 2, + "30": 12, + "6": 4 + }, + "cycles": 28, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 21, + "purpose": "inverse donor path", + "record": 621, + "side": "right", + "swaps": 484 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 21, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 21, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 21, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 21, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 21, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 21, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 21, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 21, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + }, + { + "cycle_lengths": { + "1": 2, + "17": 30 + }, + "cycles": 32, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 22, + "purpose": "inverse donor path", + "record": 621, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "1": 2, + "15": 8, + "3": 2, + "30": 12, + "6": 4 + }, + "cycles": 28, + "event": 1632, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 22, + "purpose": "inverse donor path", + "record": 621, + "side": "right", + "swaps": 484 + }, + { + "cycle_lengths": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "position": 22, + "purpose": "inverse donor path", + "record": 624, + "side": "left", + "swaps": 464 + }, + { + "cycle_lengths": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "event": 1452, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 22, + "purpose": "inverse donor path", + "record": 624, + "side": "right", + "swaps": 488 + }, + { + "cycle_lengths": { + "1": 4, + "35": 12, + "5": 12, + "7": 4 + }, + "cycles": 32, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 22, + "purpose": "inverse donor path", + "record": 626, + "side": "left", + "swaps": 480 + }, + { + "cycle_lengths": { + "8": 64 + }, + "cycles": 64, + "event": 1285, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 22, + "purpose": "inverse donor path", + "record": 626, + "side": "right", + "swaps": 448 + }, + { + "cycle_lengths": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 256, + "1": 256, + "2": 0, + "3": 0 + }, + "position": 22, + "purpose": "inverse donor path", + "record": 1021, + "side": "left", + "swaps": 510 + }, + { + "cycle_lengths": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "event": 1161, + "group": "D27", + "inverse_phase_counts": { + "0": 192, + "1": 128, + "2": 64, + "3": 128 + }, + "position": 22, + "purpose": "inverse donor path", + "record": 1021, + "side": "right", + "swaps": 508 + }, + { + "cycle_lengths": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 22, + "purpose": "inverse donor path", + "record": 105, + "side": "left", + "swaps": 496 + }, + { + "cycle_lengths": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "event": 917, + "group": "D27", + "inverse_phase_counts": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "position": 22, + "purpose": "inverse donor path", + "record": 105, + "side": "right", + "swaps": 504 + } + ], + "wrapper_swaps": 159020 + }, + "logical_codec_invoice": { + "borrowed_source_copy_option": { + "cleanup_field_subtracts": 52, + "copy_field_adds": 52, + "owned_zero_banks": 52, + "precondition": "Prepared banks are returned unchanged in their entrance frame before inversion and cleanup; this cone theorem does not prove that return." + }, + "forward": { + "real_add_subtracts_before_swap_phase_lowering": 1133456, + "real_add_subtracts_with_swaps_and_negations": 2741400, + "real_floor_halves": 287744 + }, + "gaussian_differences": 24064, + "gaussian_payload_words": 26624, + "gaussian_pi_steps": 129992, + "group_field_differences": 47, + "inherited_unchanged_profile_stop": "599/584 > 1; no changed supplier profile is proposed", + "kind": "constructive_logical_upper_bound_not_physical_supplier_invoice", + "native_pairs_per_direction": 71936, + "native_quarter_turns": 71936, + "newton_additions": 119808, + "optional_lowering": { + "extra_real_adds_for_swaps": 1395720, + "gaussian_swap_real_adds": 6, + "real_component_swap_adds": 3, + "real_swap_schedule": [ + "x <- x+y", + "y <- x-y", + "x <- x-y" + ], + "scope": "Exact unbounded component arithmetic permits source-minus-target overwrite and unary zero-minus-value. This is not automatically the repository strict target-ADD tariff. Fixed-width overflow and physical bit costs remain obligations.", + "unary_negations_as_zero_minus_value": 212224 + }, + "owned_coefficient_banks": 52, + "path_inventory": { + "extra_right_wrapper_events": [ + 1092, + 1131, + 1095, + 1128, + 1230, + 1179, + 1298, + 1089, + 1164, + 1273, + 1427, + 1161, + 1285, + 1452, + 1632 + ], + "gaussian_payload_swaps": 159020, + "inverse_wrapper_phase_histogram": { + "0": 61696, + "1": 45952, + "2": 32512, + "3": 29312 + }, + "native_event_occurrences": [ + 909, + 909, + 1092, + 911, + 911, + 1095, + 911, + 1095, + 1128, + 911, + 1095, + 1128, + 911, + 1095, + 1128, + 1230, + 911, + 1095, + 1128, + 1230, + 913, + 913, + 1179, + 913, + 1179, + 913, + 1179, + 1298, + 913, + 1179, + 1298, + 913, + 1179, + 1298, + 915, + 915, + 1089, + 915, + 1089, + 1164, + 915, + 1089, + 1164, + 1273, + 915, + 1089, + 1164, + 1273, + 915, + 1089, + 1164, + 1273, + 915, + 1089, + 1164, + 1273, + 1427, + 915, + 1089, + 1164, + 1273, + 1427, + 915, + 1089, + 1164, + 1273, + 1427, + 915, + 1089, + 1164, + 1273, + 1427, + 917, + 917, + 917, + 1161, + 917, + 1161, + 917, + 1161, + 1285, + 917, + 1161, + 1285, + 917, + 1161, + 1285, + 917, + 1161, + 1285, + 1452, + 917, + 1161, + 1285, + 1452, + 917, + 1161, + 1285, + 1452, + 917, + 1161, + 1285, + 1452, + 917, + 1161, + 1285, + 1452, + 917, + 1161, + 1285, + 1452, + 917, + 1161, + 1285, + 1452, + 917, + 1161, + 1285, + 1452, + 917, + 1161, + 1285, + 1452, + 917, + 1161, + 1285, + 1452, + 1632, + 917, + 1161, + 1285, + 1452, + 1632, + 917, + 1161, + 1285, + 1452, + 1632, + 917, + 1161, + 1285, + 1452, + 1632, + 917, + 1161, + 1285, + 1452, + 1632, + 917, + 1161, + 1285, + 1452, + 1632, + 917, + 1161, + 1285, + 1452, + 1632 + ], + "native_occurrence_count": 158, + "native_rank_mass": 281, + "swap_contract": "Direct Gaussian payload SWAP gates on owned words, n-cycles per permutation; different from the n+cycles clean-scratch implementation.", + "wrapper_count": 331, + "wrapper_cycle_sum": 10452, + "wrapper_cycles": [ + 8, + 16, + 40, + 8, + 16, + 32, + 40, + 40, + 32, + 32, + 32, + 32, + 32, + 2, + 32, + 8, + 32, + 32, + 2, + 32, + 32, + 8, + 32, + 32, + 2, + 32, + 32, + 8, + 8, + 32, + 32, + 2, + 32, + 32, + 8, + 28, + 8, + 32, + 32, + 2, + 32, + 32, + 8, + 28, + 8, + 8, + 8, + 16, + 8, + 8, + 8, + 16, + 8, + 8, + 8, + 16, + 48, + 8, + 8, + 8, + 16, + 8, + 48, + 8, + 8, + 8, + 16, + 8, + 48, + 8, + 8, + 8, + 16, + 8, + 48, + 32, + 32, + 16, + 32, + 32, + 8, + 16, + 176, + 32, + 32, + 8, + 16, + 32, + 176, + 72, + 32, + 32, + 8, + 16, + 32, + 176, + 48, + 72, + 32, + 32, + 8, + 16, + 32, + 176, + 48, + 72, + 32, + 32, + 8, + 16, + 32, + 176, + 48, + 72, + 128, + 32, + 32, + 8, + 16, + 32, + 176, + 48, + 72, + 128, + 128, + 32, + 32, + 8, + 16, + 32, + 176, + 48, + 72, + 128, + 128, + 32, + 32, + 8, + 16, + 32, + 176, + 48, + 72, + 128, + 128, + 32, + 32, + 8, + 16, + 32, + 176, + 48, + 72, + 128, + 128, + 16, + 8, + 16, + 8, + 4, + 16, + 8, + 2, + 4, + 16, + 8, + 2, + 4, + 64, + 16, + 8, + 2, + 4, + 32, + 64, + 16, + 8, + 2, + 4, + 32, + 64, + 16, + 8, + 2, + 4, + 32, + 64, + 24, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 28, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 32, + 28, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 32, + 28, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 32, + 28, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 32, + 28, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 32, + 28, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 32, + 28, + 16, + 8, + 2, + 4, + 32, + 64, + 48, + 24, + 32, + 28 + ], + "wrapper_phase_positions": 169472 + }, + "reverse": { + "real_add_subtracts_before_swap_phase_lowering": 1123216, + "real_add_subtracts_with_swaps_and_negations": 2731160, + "real_halves": 557968 + }, + "separate_already_admitted_dirty_banks": 6, + "terminal_gaussian_doublings": 5120, + "unpriced": [ + "An actual caller and its changed logical input/output interpretation", + "Physical word ownership, control, layout and routing", + "Bit complexity and fixed-width gate implementation", + "Omitted prefix branches and compatible complete external consumer", + "Recursive child/coverage costs and all-size transfer" + ], + "width_bounds": { + "coefficient_component_limit": "H", + "decoder_input_component_limit": "J", + "decoder_work_component_gain": 98304, + "encoder_work_component_gain": 612480, + "nonterminal_profile_component_gain": 3828, + "prepared_source_component_gain": 244992, + "terminal_component_gain": 13452, + "unitary_path_component_gain": 122496 + } + }, + "profiles": { + "additional_stagewise_index_log2": 10184, + "ideal_final_only_index_log2": 10240, + "local": { + "rank_one": { + "coefficient_to_value_component_gain": 3828, + "decode_schedule": { + "exact_gaussian_halvings": 0, + "exact_gaussian_pi_divisions": 2584, + "gaussian_subtractions": 2304 + }, + "dimension": 512, + "encode_schedule": { + "gaussian_additions": 2304, + "gaussian_doublings": 0, + "gaussian_pi_multiplications": 2584 + }, + "exponent_histogram": { + "0": 326, + "1": 112, + "2": 56, + "3": 16, + "4": 2 + }, + "exponents": [ + 4, + 4, + 3, + 3, + 3, + 3, + 2, + 2, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "kind": "rank_one", + "pi_index_exponent": 280, + "rank": 9, + "source_path_cost_included": false + }, + "terminal": { + "coefficient_to_value_component_gain": 13452, + "decode_schedule": { + "exact_gaussian_halvings": 1024, + "exact_gaussian_pi_divisions": 2304, + "gaussian_subtractions": 2304 + }, + "dimension": 512, + "encode_schedule": { + "gaussian_additions": 2304, + "gaussian_doublings": 1024, + "gaussian_pi_multiplications": 2304 + }, + "exponent_histogram": { + "0": 0, + "1": 0, + "2": 0, + "3": 0, + "4": 512 + }, + "exponents": [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + "kind": "terminal", + "pi_index_exponent": 2048, + "rank": 9, + "source_path_cost_included": false + }, + "zero": { + "coefficient_to_value_component_gain": 3456, + "decode_schedule": { + "exact_gaussian_halvings": 0, + "exact_gaussian_pi_divisions": 2491, + "gaussian_subtractions": 2304 + }, + "dimension": 512, + "encode_schedule": { + "gaussian_additions": 2304, + "gaussian_doublings": 0, + "gaussian_pi_multiplications": 2491 + }, + "exponent_histogram": { + "0": 382, + "1": 84, + "2": 36, + "3": 9, + "4": 1 + }, + "exponents": [ + 4, + 3, + 3, + 2, + 3, + 2, + 2, + 1, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2, + 2, + 1, + 2, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "kind": "zero", + "pi_index_exponent": 187, + "rank": 9, + "source_path_cost_included": false + } + }, + "strong_independent_4B_index_log2": 106496, + "whole_exponent_histogram": { + "0": 17114, + "1": 4368, + "2": 1992, + "3": 528, + "4": 2622 + }, + "whole_index_log2": 20424 + }, + "rejection_checks": [ + "strict_json", + "strict_json", + "strict_json", + "boolean_is_not_integer_one", + "outside_zero", + "outside_rank_one", + "outside_terminal", + "corrupt_scientific_source" + ], + "result": "PASS_EXACT_STAGEWISE_ENTRANCE", + "schema_version": 1, + "scope": "Exact literal-equals-ideal257-event producer cone and six admitted outputs, not arbitrary rounded paths or the whole prefix", + "source_sha256": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "inputs/PR3382_PROOF.md": "1ca8c0e7e78f0f39de6cff7accc68ccd3901bfb50759bf7a2e2896bcf63bf081", + "inputs/PR3416_PROOF.md": "0dc1c35158902299fc8748c8baf89205483562f041e9050580e6579c331ebeb5", + "inputs/PR3426_PROOF.md": "892df1e84bfe8858e45b3bda45d76154a28b5f17e8f1789169d6e112ff0164d1", + "inputs/pr3382_model.py": "74c83367887dd885137b222155c86389fe0be9f1293a6f0e5fdb51d71f435fdd", + "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", + "upstream/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "structure": { + "cut_frames": { + "D27": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "D28": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "D29": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "D30": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "D31": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "Q7": [ + 364 + ] + }, + "cut_paths": { + "D27": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "D28": [ + 915, + 1089, + 1164, + 1273, + 1427, + 1643 + ], + "D29": [ + 913, + 1179, + 1298, + 1461 + ], + "D30": [ + 911, + 1095, + 1128, + 1230, + 1395 + ], + "D31": [ + 909, + 1092, + 1131, + 1233 + ], + "Q7": [ + 972 + ] + }, + "dependencies": [ + "D27", + "D28", + "D29", + "D30", + "D31", + "Q7", + "Y100", + "Y101", + "Y102", + "Y103", + "Y22", + "Y23", + "Y24", + "Y25", + "Y26", + "Y27", + "Y28", + "Y29", + "Y30", + "Y31", + "Y32", + "Y63", + "Y64", + "Y65", + "Y66", + "Y67", + "Y68", + "Y69", + "Y70", + "Y71", + "Y72", + "Y73", + "Y74", + "Y75", + "Y76", + "Y77", + "Y78", + "Y79", + "Y80", + "Y81", + "Y82", + "Y83", + "Y84", + "Y85", + "Y86", + "Y87", + "Y88", + "Y89", + "Y90", + "Y91", + "Y92", + "Y93", + "Y94", + "Y95", + "Y96", + "Y97", + "Y98", + "Y99" + ], + "gaps": [ + { + "bank": "D31", + "event": 1090, + "frame": [ + 157, + 56, + 2 + ], + "kind": "rank_one", + "next_event": 1129, + "path_to_read": [ + 909 + ], + "source": "Y27", + "source_path_to_read": [ + 131, + 1056 + ], + "transport_event": 1092 + }, + { + "bank": "D31", + "event": 1129, + "frame": [ + 152, + 56, + 5, + 2 + ], + "kind": "rank_one", + "next_event": 1231, + "path_to_read": [ + 909, + 1092 + ], + "source": "Y26", + "source_path_to_read": [ + 130, + 1057, + 1097 + ], + "transport_event": 1131 + }, + { + "bank": "D31", + "event": 1231, + "frame": [ + 320, + 152, + 56, + 5, + 2 + ], + "kind": "terminal", + "next_event": null, + "path_to_read": [ + 909, + 1092, + 1131 + ], + "source": "Y99", + "source_path_to_read": [ + 203, + 984 + ], + "transport_event": null + }, + { + "bank": "D30", + "event": 1093, + "frame": [ + 80, + 61, + 2 + ], + "kind": "rank_one", + "next_event": 1126, + "path_to_read": [ + 911 + ], + "source": "Y93", + "source_path_to_read": [ + 197, + 990 + ], + "transport_event": 1095 + }, + { + "bank": "D30", + "event": 1126, + "frame": [ + 272, + 80, + 61, + 2 + ], + "kind": "rank_one", + "next_event": 1226, + "path_to_read": [ + 911, + 1095 + ], + "source": "Y94", + "source_path_to_read": [ + 198, + 989 + ], + "transport_event": 1128 + }, + { + "bank": "D30", + "event": 1226, + "frame": [ + 272, + 157, + 80, + 61, + 2 + ], + "kind": "zero", + "next_event": 1228, + "path_to_read": [ + 911, + 1095, + 1128 + ], + "source": "Y96", + "source_path_to_read": [ + 200, + 987, + 1121 + ], + "transport_event": null + }, + { + "bank": "D30", + "event": 1228, + "frame": [ + 272, + 157, + 80, + 61, + 2 + ], + "kind": "rank_one", + "next_event": 1389, + "path_to_read": [ + 911, + 1095, + 1128 + ], + "source": "Y95", + "source_path_to_read": [ + 199, + 988 + ], + "transport_event": 1230 + }, + { + "bank": "D30", + "event": 1389, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "kind": "zero", + "next_event": 1391, + "path_to_read": [ + 911, + 1095, + 1128, + 1230 + ], + "source": "Y102", + "source_path_to_read": [ + 206, + 981, + 1124, + 1222 + ], + "transport_event": null + }, + { + "bank": "D30", + "event": 1391, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "kind": "zero", + "next_event": 1393, + "path_to_read": [ + 911, + 1095, + 1128, + 1230 + ], + "source": "Y101", + "source_path_to_read": [ + 205, + 982, + 1224 + ], + "transport_event": null + }, + { + "bank": "D30", + "event": 1393, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "kind": "terminal", + "next_event": null, + "path_to_read": [ + 911, + 1095, + 1128, + 1230 + ], + "source": "Y100", + "source_path_to_read": [ + 204, + 983 + ], + "transport_event": null + }, + { + "bank": "D29", + "event": 1177, + "frame": [ + 204, + 40, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1294, + "path_to_read": [ + 913 + ], + "source": "Y65", + "source_path_to_read": [ + 169, + 1018 + ], + "transport_event": 1179 + }, + { + "bank": "D29", + "event": 1294, + "frame": [ + 137, + 69, + 40, + 21, + 2 + ], + "kind": "zero", + "next_event": 1296, + "path_to_read": [ + 913, + 1179 + ], + "source": "Y64", + "source_path_to_read": [ + 168, + 1019 + ], + "transport_event": null + }, + { + "bank": "D29", + "event": 1296, + "frame": [ + 137, + 69, + 40, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1453, + "path_to_read": [ + 913, + 1179 + ], + "source": "Y63", + "source_path_to_read": [ + 167, + 1020, + 1138 + ], + "transport_event": 1298 + }, + { + "bank": "D29", + "event": 1453, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "zero", + "next_event": 1455, + "path_to_read": [ + 913, + 1179, + 1298 + ], + "source": "Y70", + "source_path_to_read": [ + 174, + 1013 + ], + "transport_event": null + }, + { + "bank": "D29", + "event": 1455, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "zero", + "next_event": 1457, + "path_to_read": [ + 913, + 1179, + 1298 + ], + "source": "Y69", + "source_path_to_read": [ + 173, + 1014, + 1250 + ], + "transport_event": null + }, + { + "bank": "D29", + "event": 1457, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "zero", + "next_event": 1459, + "path_to_read": [ + 913, + 1179, + 1298 + ], + "source": "Y68", + "source_path_to_read": [ + 172, + 1015, + 1147, + 1252 + ], + "transport_event": null + }, + { + "bank": "D29", + "event": 1459, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "terminal", + "next_event": null, + "path_to_read": [ + 913, + 1179, + 1298 + ], + "source": "Y66", + "source_path_to_read": [ + 170, + 1017, + 1103, + 1149, + 1254 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1087, + "frame": [ + 85, + 56, + 2 + ], + "kind": "rank_one", + "next_event": 1162, + "path_to_read": [ + 915 + ], + "source": "Y103", + "source_path_to_read": [ + 207, + 980 + ], + "transport_event": 1089 + }, + { + "bank": "D28", + "event": 1162, + "frame": [ + 64, + 45, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1271, + "path_to_read": [ + 915, + 1089 + ], + "source": "Y31", + "source_path_to_read": [ + 135, + 1052, + 1106 + ], + "transport_event": 1164 + }, + { + "bank": "D28", + "event": 1271, + "frame": [ + 64, + 40, + 16, + 5, + 2 + ], + "kind": "rank_one", + "next_event": 1421, + "path_to_read": [ + 915, + 1089, + 1164 + ], + "source": "Y22", + "source_path_to_read": [ + 126, + 1061 + ], + "transport_event": 1273 + }, + { + "bank": "D28", + "event": 1421, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "zero", + "next_event": 1423, + "path_to_read": [ + 915, + 1089, + 1164, + 1273 + ], + "source": "Y29", + "source_path_to_read": [ + 133, + 1054, + 1267 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1423, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "zero", + "next_event": 1425, + "path_to_read": [ + 915, + 1089, + 1164, + 1273 + ], + "source": "Y28", + "source_path_to_read": [ + 132, + 1055, + 1169, + 1269 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1425, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "kind": "rank_one", + "next_event": 1633, + "path_to_read": [ + 915, + 1089, + 1164, + 1273 + ], + "source": "Y23", + "source_path_to_read": [ + 127, + 1060 + ], + "transport_event": 1427 + }, + { + "bank": "D28", + "event": 1633, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1635, + "path_to_read": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "source": "Y78", + "source_path_to_read": [ + 182, + 1005, + 1141, + 1257, + 1406 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1635, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1637, + "path_to_read": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "source": "Y75", + "source_path_to_read": [ + 179, + 1008, + 1235, + 1408 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1637, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1639, + "path_to_read": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "source": "Y74", + "source_path_to_read": [ + 178, + 1009 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1639, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1641, + "path_to_read": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "source": "Y73", + "source_path_to_read": [ + 177, + 1010, + 1410 + ], + "transport_event": null + }, + { + "bank": "D28", + "event": 1641, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "terminal", + "next_event": null, + "path_to_read": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "source": "Y72", + "source_path_to_read": [ + 176, + 1011, + 1259, + 1412 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1157, + "frame": [ + 360, + 136, + 21, + 2 + ], + "kind": "zero", + "next_event": 1159, + "path_to_read": [ + 917 + ], + "source": "Y98", + "source_path_to_read": [ + 202, + 985 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1159, + "frame": [ + 360, + 136, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1281, + "path_to_read": [ + 917 + ], + "source": "Y97", + "source_path_to_read": [ + 201, + 986, + 1085 + ], + "transport_event": 1161 + }, + { + "bank": "D27", + "event": 1281, + "frame": [ + 260, + 136, + 108, + 21, + 2 + ], + "kind": "zero", + "next_event": 1283, + "path_to_read": [ + 917, + 1161 + ], + "source": "Y79", + "source_path_to_read": [ + 183, + 1004 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1283, + "frame": [ + 260, + 136, + 108, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1446, + "path_to_read": [ + 917, + 1161 + ], + "source": "Y71", + "source_path_to_read": [ + 175, + 1012, + 1172 + ], + "transport_event": 1285 + }, + { + "bank": "D27", + "event": 1446, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "kind": "zero", + "next_event": 1448, + "path_to_read": [ + 917, + 1161, + 1285 + ], + "source": "Y84", + "source_path_to_read": [ + 188, + 999 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1448, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "kind": "zero", + "next_event": 1450, + "path_to_read": [ + 917, + 1161, + 1285 + ], + "source": "Y77", + "source_path_to_read": [ + 181, + 1006, + 1287 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1450, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "kind": "rank_one", + "next_event": 1614, + "path_to_read": [ + 917, + 1161, + 1285 + ], + "source": "Y25", + "source_path_to_read": [ + 129, + 1058, + 1166, + 1289 + ], + "transport_event": 1452 + }, + { + "bank": "D27", + "event": 1614, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1616, + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y92", + "source_path_to_read": [ + 196, + 991, + 1275, + 1436 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1616, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1618, + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y88", + "source_path_to_read": [ + 192, + 995, + 1292, + 1438 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1618, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1620, + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y87", + "source_path_to_read": [ + 191, + 996, + 1440 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1620, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1622, + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y83", + "source_path_to_read": [ + 187, + 1000 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1622, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1624, + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y76", + "source_path_to_read": [ + 180, + 1007, + 1429 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1624, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1626, + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y67", + "source_path_to_read": [ + 171, + 1016, + 1109, + 1175, + 1277, + 1442 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1626, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1628, + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y32", + "source_path_to_read": [ + 136, + 1051, + 1155, + 1279, + 1444 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1628, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "zero", + "next_event": 1630, + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y30", + "source_path_to_read": [ + 134, + 1053, + 1152, + 1262, + 1431 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1630, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "kind": "rank_one", + "next_event": 1817, + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y24", + "source_path_to_read": [ + 128, + 1059, + 1264, + 1433 + ], + "transport_event": 1632 + }, + { + "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 + }, + { + "bank": "D27", + "event": 1819, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1821, + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y90", + "source_path_to_read": [ + 194, + 993, + 1100, + 1135, + 1240, + 1399, + 1600 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1821, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1823, + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y89", + "source_path_to_read": [ + 193, + 994, + 1144, + 1245, + 1415, + 1602 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1823, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1825, + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y86", + "source_path_to_read": [ + 190, + 997, + 1242, + 1401, + 1604 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1825, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1827, + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y85", + "source_path_to_read": [ + 189, + 998, + 1247, + 1417, + 1606 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1827, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1829, + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y82", + "source_path_to_read": [ + 186, + 1001, + 1403, + 1608 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1829, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "zero", + "next_event": 1831, + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y81", + "source_path_to_read": [ + 185, + 1002, + 1610 + ], + "transport_event": null + }, + { + "bank": "D27", + "event": 1831, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "kind": "terminal", + "next_event": null, + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y80", + "source_path_to_read": [ + 184, + 1003, + 1419, + 1612 + ], + "transport_event": null + } + ], + "groups": { + "D27": [ + { + "bank": "D27", + "event": 1157, + "frame": [ + 360, + 136, + 21, + 2 + ], + "path_to_read": [ + 917 + ], + "source": "Y98", + "source_path_to_read": [ + 202, + 985 + ] + }, + { + "bank": "D27", + "event": 1159, + "frame": [ + 360, + 136, + 21, + 2 + ], + "path_to_read": [ + 917 + ], + "source": "Y97", + "source_path_to_read": [ + 201, + 986, + 1085 + ] + }, + { + "bank": "D27", + "event": 1281, + "frame": [ + 260, + 136, + 108, + 21, + 2 + ], + "path_to_read": [ + 917, + 1161 + ], + "source": "Y79", + "source_path_to_read": [ + 183, + 1004 + ] + }, + { + "bank": "D27", + "event": 1283, + "frame": [ + 260, + 136, + 108, + 21, + 2 + ], + "path_to_read": [ + 917, + 1161 + ], + "source": "Y71", + "source_path_to_read": [ + 175, + 1012, + 1172 + ] + }, + { + "bank": "D27", + "event": 1446, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "path_to_read": [ + 917, + 1161, + 1285 + ], + "source": "Y84", + "source_path_to_read": [ + 188, + 999 + ] + }, + { + "bank": "D27", + "event": 1448, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "path_to_read": [ + 917, + 1161, + 1285 + ], + "source": "Y77", + "source_path_to_read": [ + 181, + 1006, + 1287 + ] + }, + { + "bank": "D27", + "event": 1450, + "frame": [ + 260, + 136, + 65, + 45, + 21, + 2 + ], + "path_to_read": [ + 917, + 1161, + 1285 + ], + "source": "Y25", + "source_path_to_read": [ + 129, + 1058, + 1166, + 1289 + ] + }, + { + "bank": "D27", + "event": 1614, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y92", + "source_path_to_read": [ + 196, + 991, + 1275, + 1436 + ] + }, + { + "bank": "D27", + "event": 1616, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y88", + "source_path_to_read": [ + 192, + 995, + 1292, + 1438 + ] + }, + { + "bank": "D27", + "event": 1618, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y87", + "source_path_to_read": [ + 191, + 996, + 1440 + ] + }, + { + "bank": "D27", + "event": 1620, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y83", + "source_path_to_read": [ + 187, + 1000 + ] + }, + { + "bank": "D27", + "event": 1622, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y76", + "source_path_to_read": [ + 180, + 1007, + 1429 + ] + }, + { + "bank": "D27", + "event": 1624, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y67", + "source_path_to_read": [ + 171, + 1016, + 1109, + 1175, + 1277, + 1442 + ] + }, + { + "bank": "D27", + "event": 1626, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y32", + "source_path_to_read": [ + 136, + 1051, + 1155, + 1279, + 1444 + ] + }, + { + "bank": "D27", + "event": 1628, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y30", + "source_path_to_read": [ + 134, + 1053, + 1152, + 1262, + 1431 + ] + }, + { + "bank": "D27", + "event": 1630, + "frame": [ + 260, + 136, + 64, + 44, + 20, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452 + ], + "source": "Y24", + "source_path_to_read": [ + 128, + 1059, + 1264, + 1433 + ] + }, + { + "bank": "D27", + "event": 1817, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y91", + "source_path_to_read": [ + 195, + 992, + 1133, + 1238, + 1397, + 1598 + ] + }, + { + "bank": "D27", + "event": 1819, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y90", + "source_path_to_read": [ + 194, + 993, + 1100, + 1135, + 1240, + 1399, + 1600 + ] + }, + { + "bank": "D27", + "event": 1821, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y89", + "source_path_to_read": [ + 193, + 994, + 1144, + 1245, + 1415, + 1602 + ] + }, + { + "bank": "D27", + "event": 1823, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y86", + "source_path_to_read": [ + 190, + 997, + 1242, + 1401, + 1604 + ] + }, + { + "bank": "D27", + "event": 1825, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y85", + "source_path_to_read": [ + 189, + 998, + 1247, + 1417, + 1606 + ] + }, + { + "bank": "D27", + "event": 1827, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y82", + "source_path_to_read": [ + 186, + 1001, + 1403, + 1608 + ] + }, + { + "bank": "D27", + "event": 1829, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y81", + "source_path_to_read": [ + 185, + 1002, + 1610 + ] + }, + { + "bank": "D27", + "event": 1831, + "frame": [ + 256, + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 917, + 1161, + 1285, + 1452, + 1632 + ], + "source": "Y80", + "source_path_to_read": [ + 184, + 1003, + 1419, + 1612 + ] + } + ], + "D28": [ + { + "bank": "D28", + "event": 1087, + "frame": [ + 85, + 56, + 2 + ], + "path_to_read": [ + 915 + ], + "source": "Y103", + "source_path_to_read": [ + 207, + 980 + ] + }, + { + "bank": "D28", + "event": 1162, + "frame": [ + 64, + 45, + 21, + 2 + ], + "path_to_read": [ + 915, + 1089 + ], + "source": "Y31", + "source_path_to_read": [ + 135, + 1052, + 1106 + ] + }, + { + "bank": "D28", + "event": 1271, + "frame": [ + 64, + 40, + 16, + 5, + 2 + ], + "path_to_read": [ + 915, + 1089, + 1164 + ], + "source": "Y22", + "source_path_to_read": [ + 126, + 1061 + ] + }, + { + "bank": "D28", + "event": 1421, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "path_to_read": [ + 915, + 1089, + 1164, + 1273 + ], + "source": "Y29", + "source_path_to_read": [ + 133, + 1054, + 1267 + ] + }, + { + "bank": "D28", + "event": 1423, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "path_to_read": [ + 915, + 1089, + 1164, + 1273 + ], + "source": "Y28", + "source_path_to_read": [ + 132, + 1055, + 1169, + 1269 + ] + }, + { + "bank": "D28", + "event": 1425, + "frame": [ + 136, + 64, + 40, + 16, + 5, + 2 + ], + "path_to_read": [ + 915, + 1089, + 1164, + 1273 + ], + "source": "Y23", + "source_path_to_read": [ + 127, + 1060 + ] + }, + { + "bank": "D28", + "event": 1633, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "source": "Y78", + "source_path_to_read": [ + 182, + 1005, + 1141, + 1257, + 1406 + ] + }, + { + "bank": "D28", + "event": 1635, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "source": "Y75", + "source_path_to_read": [ + 179, + 1008, + 1235, + 1408 + ] + }, + { + "bank": "D28", + "event": 1637, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "source": "Y74", + "source_path_to_read": [ + 178, + 1009 + ] + }, + { + "bank": "D28", + "event": 1639, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "source": "Y73", + "source_path_to_read": [ + 177, + 1010, + 1410 + ] + }, + { + "bank": "D28", + "event": 1641, + "frame": [ + 136, + 64, + 40, + 16, + 4, + 2, + 1 + ], + "path_to_read": [ + 915, + 1089, + 1164, + 1273, + 1427 + ], + "source": "Y72", + "source_path_to_read": [ + 176, + 1011, + 1259, + 1412 + ] + } + ], + "D29": [ + { + "bank": "D29", + "event": 1177, + "frame": [ + 204, + 40, + 21, + 2 + ], + "path_to_read": [ + 913 + ], + "source": "Y65", + "source_path_to_read": [ + 169, + 1018 + ] + }, + { + "bank": "D29", + "event": 1294, + "frame": [ + 137, + 69, + 40, + 21, + 2 + ], + "path_to_read": [ + 913, + 1179 + ], + "source": "Y64", + "source_path_to_read": [ + 168, + 1019 + ] + }, + { + "bank": "D29", + "event": 1296, + "frame": [ + 137, + 69, + 40, + 21, + 2 + ], + "path_to_read": [ + 913, + 1179 + ], + "source": "Y63", + "source_path_to_read": [ + 167, + 1020, + 1138 + ] + }, + { + "bank": "D29", + "event": 1453, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "path_to_read": [ + 913, + 1179, + 1298 + ], + "source": "Y70", + "source_path_to_read": [ + 174, + 1013 + ] + }, + { + "bank": "D29", + "event": 1455, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "path_to_read": [ + 913, + 1179, + 1298 + ], + "source": "Y69", + "source_path_to_read": [ + 173, + 1014, + 1250 + ] + }, + { + "bank": "D29", + "event": 1457, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "path_to_read": [ + 913, + 1179, + 1298 + ], + "source": "Y68", + "source_path_to_read": [ + 172, + 1015, + 1147, + 1252 + ] + }, + { + "bank": "D29", + "event": 1459, + "frame": [ + 137, + 64, + 40, + 16, + 5, + 2 + ], + "path_to_read": [ + 913, + 1179, + 1298 + ], + "source": "Y66", + "source_path_to_read": [ + 170, + 1017, + 1103, + 1149, + 1254 + ] + } + ], + "D30": [ + { + "bank": "D30", + "event": 1093, + "frame": [ + 80, + 61, + 2 + ], + "path_to_read": [ + 911 + ], + "source": "Y93", + "source_path_to_read": [ + 197, + 990 + ] + }, + { + "bank": "D30", + "event": 1126, + "frame": [ + 272, + 80, + 61, + 2 + ], + "path_to_read": [ + 911, + 1095 + ], + "source": "Y94", + "source_path_to_read": [ + 198, + 989 + ] + }, + { + "bank": "D30", + "event": 1226, + "frame": [ + 272, + 157, + 80, + 61, + 2 + ], + "path_to_read": [ + 911, + 1095, + 1128 + ], + "source": "Y96", + "source_path_to_read": [ + 200, + 987, + 1121 + ] + }, + { + "bank": "D30", + "event": 1228, + "frame": [ + 272, + 157, + 80, + 61, + 2 + ], + "path_to_read": [ + 911, + 1095, + 1128 + ], + "source": "Y95", + "source_path_to_read": [ + 199, + 988 + ] + }, + { + "bank": "D30", + "event": 1389, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "path_to_read": [ + 911, + 1095, + 1128, + 1230 + ], + "source": "Y102", + "source_path_to_read": [ + 206, + 981, + 1124, + 1222 + ] + }, + { + "bank": "D30", + "event": 1391, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "path_to_read": [ + 911, + 1095, + 1128, + 1230 + ], + "source": "Y101", + "source_path_to_read": [ + 205, + 982, + 1224 + ] + }, + { + "bank": "D30", + "event": 1393, + "frame": [ + 272, + 152, + 80, + 56, + 5, + 2 + ], + "path_to_read": [ + 911, + 1095, + 1128, + 1230 + ], + "source": "Y100", + "source_path_to_read": [ + 204, + 983 + ] + } + ], + "D31": [ + { + "bank": "D31", + "event": 1090, + "frame": [ + 157, + 56, + 2 + ], + "path_to_read": [ + 909 + ], + "source": "Y27", + "source_path_to_read": [ + 131, + 1056 + ] + }, + { + "bank": "D31", + "event": 1129, + "frame": [ + 152, + 56, + 5, + 2 + ], + "path_to_read": [ + 909, + 1092 + ], + "source": "Y26", + "source_path_to_read": [ + 130, + 1057, + 1097 + ] + }, + { + "bank": "D31", + "event": 1231, + "frame": [ + 320, + 152, + 56, + 5, + 2 + ], + "path_to_read": [ + 909, + 1092, + 1131 + ], + "source": "Y99", + "source_path_to_read": [ + 203, + 984 + ] + } + ] + }, + "native_count": 200, + "native_rank_mass": 354, + "q_reads": [ + [ + 908, + "D31" + ], + [ + 910, + "D30" + ], + [ + 912, + "D29" + ], + [ + 914, + "D28" + ], + [ + 916, + "D27" + ] + ], + "selected": [ + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 908, + 909, + 910, + 911, + 912, + 913, + 914, + 915, + 916, + 917, + 972, + 980, + 981, + 982, + 983, + 984, + 985, + 986, + 987, + 988, + 989, + 990, + 991, + 992, + 993, + 994, + 995, + 996, + 997, + 998, + 999, + 1000, + 1001, + 1002, + 1003, + 1004, + 1005, + 1006, + 1007, + 1008, + 1009, + 1010, + 1011, + 1012, + 1013, + 1014, + 1015, + 1016, + 1017, + 1018, + 1019, + 1020, + 1051, + 1052, + 1053, + 1054, + 1055, + 1056, + 1057, + 1058, + 1059, + 1060, + 1061, + 1085, + 1087, + 1089, + 1090, + 1092, + 1093, + 1095, + 1097, + 1100, + 1103, + 1106, + 1109, + 1121, + 1124, + 1126, + 1128, + 1129, + 1131, + 1133, + 1135, + 1138, + 1141, + 1144, + 1147, + 1149, + 1152, + 1155, + 1157, + 1159, + 1161, + 1162, + 1164, + 1166, + 1169, + 1172, + 1175, + 1177, + 1179, + 1222, + 1224, + 1226, + 1228, + 1230, + 1231, + 1233, + 1235, + 1238, + 1240, + 1242, + 1245, + 1247, + 1250, + 1252, + 1254, + 1257, + 1259, + 1262, + 1264, + 1267, + 1269, + 1271, + 1273, + 1275, + 1277, + 1279, + 1281, + 1283, + 1285, + 1287, + 1289, + 1292, + 1294, + 1296, + 1298, + 1389, + 1391, + 1393, + 1395, + 1397, + 1399, + 1401, + 1403, + 1406, + 1408, + 1410, + 1412, + 1415, + 1417, + 1419, + 1421, + 1423, + 1425, + 1427, + 1429, + 1431, + 1433, + 1436, + 1438, + 1440, + 1442, + 1444, + 1446, + 1448, + 1450, + 1452, + 1453, + 1455, + 1457, + 1459, + 1461, + 1598, + 1600, + 1602, + 1604, + 1606, + 1608, + 1610, + 1612, + 1614, + 1616, + 1618, + 1620, + 1622, + 1624, + 1626, + 1628, + 1630, + 1632, + 1633, + 1635, + 1637, + 1639, + 1641, + 1643, + 1817, + 1819, + 1821, + 1823, + 1825, + 1827, + 1829, + 1831 + ] + } +} diff --git a/research/p104-stagewise-entrance/SOURCES.json b/research/p104-stagewise-entrance/SOURCES.json new file mode 100644 index 0000000000..a3a94a03d1 --- /dev/null +++ b/research/p104-stagewise-entrance/SOURCES.json @@ -0,0 +1,313 @@ +{ + "schema_version": 1, + "base_commit": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "files": [ + { + "path": "AGENTS.md", + "usage": "provenance", + "bytes": 5580, + "sha256": "eb25d8ec495b80190a4b1a634710819bb74f0fae88d5203285c2b75b6f147347", + "git_blob": "aea5573d1b65cef7d9e08ced46d869e75da8145b", + "purpose": "Entry guidance / selected context at the frozen canonical base; no selected-frontier change." + }, + { + "path": "autoresearch.md", + "usage": "provenance", + "bytes": 5298, + "sha256": "8c98d179208c34a8c6768931e13f3bbeaa1cb63d59c660799ffde05c40935d9b", + "git_blob": "e5445702e6bb589f55f252f7e7468cc7db394ca7", + "purpose": "Entry guidance / selected context at the frozen canonical base; no selected-frontier change." + }, + { + "path": "CONTRIBUTING.md", + "usage": "provenance", + "bytes": 7143, + "sha256": "8a49fe97e2ad088a2b2e0c5b222aaab08752783b1f9c1260790d7dd13011d215", + "git_blob": "fe54f23f19b082a9f8df3da9b2e205f7e230acf3", + "purpose": "Entry guidance / selected context at the frozen canonical base; no selected-frontier change." + }, + { + "path": "docs/research/current-priorities.md", + "usage": "provenance", + "bytes": 11358, + "sha256": "c95e09baa997b48ba00a26ea29168e782b17392d28184ecb7a17eea5472dd77c", + "git_blob": "231a089623bf11a70a434f5a57b0bf0a2ad4c317", + "purpose": "Entry guidance / selected context at the frozen canonical base; no selected-frontier change." + }, + { + "path": "docs/research/research-family-status.md", + "usage": "provenance", + "bytes": 14284, + "sha256": "9b98ab42364e90588e90410fd2773f9bc4bf5050f514101bed0a0246881b5b7e", + "git_blob": "9b7d65650d8fcd6247a758936b24426b40e40efa", + "purpose": "Entry guidance / selected context at the frozen canonical base; no selected-frontier change." + }, + { + "path": "docs/research/agent-procedure.md", + "usage": "provenance", + "bytes": 27753, + "sha256": "b2dd2f64e5746fce6289422351f2e3d1eb224f7db09aeb72f4d6626263190aa1", + "git_blob": "cfb399a5d0b0fcde1ba63adf99c1a6e54cc911b6", + "purpose": "Entry guidance / selected context at the frozen canonical base; no selected-frontier change." + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "bytes": 58553, + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "purpose": "Entry guidance / selected context at the frozen canonical base; no selected-frontier change." + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "bytes": 10725, + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "purpose": "Entry guidance / selected context at the frozen canonical base; no selected-frontier change." + }, + { + "path": "research/p104-rounded-collector/inputs/WORD.json", + "usage": "input", + "bytes": 288482, + "sha256": "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50", + "git_blob": "93acaabc0a523789ef2f1b06f6eeeefed5551397", + "purpose": "Exact scientific input: ywz65 PR2586 word/native archive, retained by Arham Tahir PR2665." + }, + { + "path": "research/p104-rounded-collector/inputs/NATIVE.json.gz", + "usage": "input", + "bytes": 49610, + "sha256": "ab91c78835c3e10cf3b2cb8a5d4e0b7cfc3df1ae5a811298d27842f2193e1e3d", + "git_blob": "04f2877aa5444948b7ae37efd267745af82cb34d", + "purpose": "Exact scientific input: ywz65 PR2586 word/native archive, retained by Arham Tahir PR2665." + }, + { + "path": "LICENSE", + "usage": "input", + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "purpose": "Retained licence/source attribution and predecessor scope; not an executable mathematical dependency." + }, + { + "path": "NOTICE", + "usage": "input", + "bytes": 24973, + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "git_blob": "59d8e0cf3102e15bd11db430838365531e2d7f18", + "purpose": "Retained licence/source attribution and predecessor scope; not an executable mathematical dependency." + }, + { + "path": "upstream/LICENSE", + "usage": "input", + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "purpose": "Retained licence/source attribution and predecessor scope; not an executable mathematical dependency." + }, + { + "path": "research/p104-rounded-collector/PREDECESSORS.json", + "usage": "input", + "bytes": 894, + "sha256": "89f17ce76729101536cfc0be02ad153451c6606ebcfd3a1d6588226a83c88c64", + "git_blob": "944b9920686d1f3e23268191fcc652c66d246105", + "purpose": "Retained licence/source attribution and predecessor scope; not an executable mathematical dependency." + }, + { + "path": "research/p104-rounded-collector/README.md", + "usage": "input", + "bytes": 8807, + "sha256": "a77514952eda13fac047c5a4daba92d6c01d3e83bb1b41da4b87211bec6c37c9", + "git_blob": "95288f6821cc4983df25f1f18aaacfc49f4f6299", + "purpose": "Retained licence/source attribution and predecessor scope; not an executable mathematical dependency." + } + ], + "retained_sources": [ + { + "path": "inputs/pr3382_model.py", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_pull_request": 3382, + "origin_commit": "2834523b1cd4ea83ba7a043e2e2f5f3332cf9909", + "origin_path": "research/p104-clifford-exactness/model.py", + "bytes": 17085, + "sha256": "74c83367887dd885137b222155c86389fe0be9f1293a6f0e5fdb51d71f435fdd", + "git_blob": "4dd24a2627db8239d062afc7888a39bf5cd0f478", + "usage": "input", + "role": "Authenticated inherited Gaussian/Newton implementation; reused code is not an independent new checker.", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/2834523b1cd4ea83ba7a043e2e2f5f3332cf9909/research/p104-clifford-exactness/model.py" + }, + { + "path": "inputs/PR3382_PROOF.md", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_pull_request": 3382, + "origin_commit": "2834523b1cd4ea83ba7a043e2e2f5f3332cf9909", + "origin_path": "research/p104-clifford-exactness/PROOF.md", + "bytes": 21243, + "sha256": "1ca8c0e7e78f0f39de6cff7accc68ccd3901bfb50759bf7a2e2896bcf63bf081", + "git_blob": "10b3202c788b5b03188eed91181441dfd793ff7f", + "usage": "provenance", + "role": "Inherited B9 automorphisms and ideal-pair integrality iff literal signed-floor exactness.", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/2834523b1cd4ea83ba7a043e2e2f5f3332cf9909/research/p104-clifford-exactness/PROOF.md" + }, + { + "path": "inputs/PR3426_PROOF.md", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_pull_request": 3426, + "origin_commit": "ce2221dddab6efd3027c09269765dd7eb45f2877", + "origin_path": "research/p104-correlated-entrance/PROOF.md", + "bytes": 7498, + "sha256": "892df1e84bfe8858e45b3bda45d76154a28b5f17e8f1789169d6e112ff0164d1", + "git_blob": "c7007ae86f5efe1785a55335d49737856f326ca5", + "usage": "provenance", + "role": "Predecessor ideal five-congruence theorem and literal Gaussian-multiple cancellation family; new work concerns actual stagewise admission.", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/ce2221dddab6efd3027c09269765dd7eb45f2877/research/p104-correlated-entrance/PROOF.md" + }, + { + "path": "inputs/PR3416_PROOF.md", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_pull_request": 3416, + "origin_commit": "f1112560883a5e81b1a29c37c81a79a20be31fe3", + "origin_path": "research/p104-native-covariance/PROOF.md", + "bytes": 5914, + "sha256": "0dc1c35158902299fc8748c8baf89205483562f041e9050580e6579c331ebeb5", + "git_blob": "276f61cb64d253f6d43e1ec7e8230df551ad02cd", + "usage": "provenance", + "role": "Inherited complete native covariance with exact phase, retained unchanged for the normalised-source proof.", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/f1112560883a5e81b1a29c37c81a79a20be31fe3/research/p104-native-covariance/PROOF.md" + } + ], + "retained_source_policy": "The four package-local predecessor files are retained byte-for-byte and authenticated before mathematical execution and again before successful exit. Their source origins and exact hashes are recorded separately from the generic base pins, so a clean checkout needs no unmerged predecessor object. The publication retains them in its own ancestry. Source equality is provenance, not external mathematical review.", + "context_sources": [ + { + "path": "research/p104-consumer-budget-audit/README.md", + "usage": "provenance", + "bytes": 15737, + "sha256": "13694215d0c1a245b392f7155e8395b9c4bad9c5db3558833c784d9449616417", + "git_blob": "7317fa775e5942e66237b9053aa5e0ed8dc6b1a3", + "purpose": "Context only: credited unchanged five-forward/four-dual coverage stop; not rerun or assigned a zero physical bill." + }, + { + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_pull_request": 3449, + "origin_commit": "5cb2ff187a27de1cbd1a37933f7228b35b15702b", + "origin_path": "research/p104-correlated-exact-module/PROOF.md", + "origin_git_blob": "2107b3996def6786e3d767a4b7011ae16f8e6b38", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/5cb2ff187a27de1cbd1a37933f7228b35b15702b/research/p104-correlated-exact-module/PROOF.md", + "usage": "concurrent context only; read at presubmission, no executable import or theorem dependency", + "purpose": "Independently developed sharp two-source rank-one calibration, matching the local280 index; explicitly distinct from this general58-bank domain and encoder.", + "origin_sha256": "66ed7dbf4748eb590b1e8fe4c41ef924c1c45461c66d9de4cf00771a2a403ea0" + } + ], + "mathematical_dependencies": [ + { + "source": "PR3382", + "statement": "B9 definition/encoder, actual affine quadratic Gaussian wrapper and C-stage automorphisms, exact literal floor criterion.", + "status": "Inherited written theorem; its reused model is not an independent checker." + }, + { + "source": "PR3416", + "statement": "For each actual PR2586 native occurrence, the full ideal recipe equals Delta_new Delta_old^-1, including global phase.", + "status": "Inherited finite theorem. Actual recipe/source bindings and two separately constructed finite traces are checked here; complete1245-record covariance is not recertified." + }, + { + "source": "PR3426", + "statement": "On the58 initialB9 dependency domain, final ideal cut admission is exactly five disjointY sums in4B9.", + "status": "Predecessor theorem credited; its proof explicitly does not establish arbitrary literal correlated execution." + } + ], + "scope_boundary": { + "actual_object": "257-event backward producer cone before zero-based cut2025,58 initialbanks,52 initialY and6 dirtyD/Q;9bits/512 Gaussian components.", + "distinction": "The complete2,025-event prefix has1,768 additional events. Cone-exactness does not establish those external arithmetic or recipient histories.", + "new_module": "Chronological partial-sum stagewise literal admission; its lattice index is a domain descriptor, not an operation, storage or physical cost saving.", + "remaining_costs": "Any actual encoder/caller must state owned/borrowed state, logical target, all copies, divisions, wrappers, widths, source restoration, downstream consumption and recursive charges. Unknown costs remain unknown.", + "selected_result": "Unchanged; no complete supplier or kappa claim. The inherited unchanged-profile stop remains." + }, + "coordination_context": { + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2750#discussioncomment-19009685", + "distinct_live_claims": [ + { + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2750#discussioncomment-19009569", + "author": "Hiroki Kumazaki / kumagi", + "scope": "675 external recipient closure, additional admissions, terminal map and widths; excluded from this investigation." + }, + { + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2750#discussioncomment-19009655", + "author": "Nick Petalas / petalas", + "scope": "Whole-word tensor-depth lift; root observed explicit distinction from the coordinated stagewise scope. No independent complete Discussion-corpus scan is claimed here." + } + ], + "cache_coverage": "Entry overlap:358 unique openPR title/body/head records across four complete REST pages; no generic Discussion corpus in coordination helper cache. Root independently checked fresh2750 DOM." + }, + "credit": [ + { + "author": "Nick Petalas / petalas", + "pull_request": 3449, + "head": "5cb2ff187a27de1cbd1a37933f7228b35b15702b", + "contribution": "Concurrent sharp two-source calibration of the rank-one interval module; no priority or dependency claim." + }, + { + "author": "Nick Petalas / petalas", + "pull_request": 3426, + "head": "ce2221dddab6efd3027c09269765dd7eb45f2877", + "contribution": "Correlated ideal producer classification, actual paired cancellation, explicit literal-stage admission handoff." + }, + { + "author": "Nick Petalas / petalas", + "pull_request": 3416, + "head": "f1112560883a5e81b1a29c37c81a79a20be31fe3", + "contribution": "All native chart identities and phase certificate; mathematical dependence retained as stated." + }, + { + "author": "Nick Petalas / petalas", + "pull_request": 3406, + "head": "18a054fd585ab4b2010770ec83cba0c9f28184e3", + "contribution": "Different whole-word independent product-domain theorem; not repeated here." + }, + { + "author": "Clear1nsight with substantial OpenAI assistance", + "pull_request": 3423, + "head": "15d28c4de37dc47ea07cd7173c8b318fca7a4d75", + "contribution": "Actual58-bank producer cone, stronger52-source prefix invariant, reachable weak-input witness and bounded consumer/cost contracts." + }, + { + "author": "Clear1nsight with substantial OpenAI assistance", + "pull_request": 3382, + "head": "2834523b1cd4ea83ba7a043e2e2f5f3332cf9909", + "contribution": "Gaussian Newton application, all-rank exactness and codec/intertwiner boundaries; model and proof reused unchanged." + }, + { + "author": "ywz65", + "pull_request": 2586, + "head": "7953c9a8f788a8de5cf2ced63d9a61b67c22c6f1", + "contribution": "Actual word and native archive; original source and physical inverse-transpose credit." + }, + { + "author": "Arham Tahir", + "pull_request": 2665, + "contribution": "Retained rounded-collector scientific inputs and source binding." + }, + { + "author": "Tekalign / tekuuu", + "pull_request": 3025, + "head": "a544ef068a46f4de3bc47d1d02149cbdc3ba547f", + "contribution": "Signed-floor pair and literal wrapper/cleanup conventions; PR3218 separately supplies Pauli-plus-anchor criterion." + }, + { + "author": "Ross Richardson", + "pull_request": 3068, + "head": "7d2c519a1fdcc6bf66f6f08757eed7c48762d3f2", + "contribution": "Neighboring period lattice and larger exactness-domain question." + }, + { + "author": "Jose Manuel / jmbarrancoml and Vasek / flyingviper", + "pull_request": 2744, + "head": "0166260409f55a56e7fefa48d859f7dd5b42b300", + "contribution": "Inherited conditional599/584 unchanged-consumer coverage stop, with all original assumptions." + }, + { + "author": "Retained P104 geometry, native, compiler, precision and repository contributors", + "contribution": "Full predecessor notices remain; no new lattice family or formal/full multiplication verification is claimed." + } + ] +} diff --git a/research/p104-stagewise-entrance/TASK.json b/research/p104-stagewise-entrance/TASK.json new file mode 100644 index 0000000000..138112d6ad --- /dev/null +++ b/research/p104-stagewise-entrance/TASK.json @@ -0,0 +1,405 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 6, + "base_commit": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "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" + } + ] + }, + "author": "Clear1nsight, with substantial OpenAI assistance", + "ai_assistance": "Four concurrent OpenAI agents coordinate, derive, implement and independently cross-check. No independent human or formal proof review is claimed.", + "budget_minutes": null, + "budget_override": "The user removed the 60-minute limit and asked to continue resolving the proposed questions.", + "scope_status": "changed", + "actual_scope": "Classify the maximal correlated initial B9 domain on which the actual 257-event first-collector producer cone has integral fractional-ADD increments, every literal native pair agrees with its ideal complex-linear gate, and all six collector inputs at the cut lie in B9. Use chronological partial sums, finite Gaussian congruence lattices and constructive reversible coordinates.", + "scope_change_reason": "The continuing user task follows PR3426's released stagewise-integrality handoff. The 675-recipient scope was actively claimed at entry and is now released as complementary PR3446; it remains outside this cone theorem.", + "scope_key": "P104/PR2586/first-collector/PR3426/exact-stagewise-correlated-entrance/prefix-sum-lattices", + "selection": { + "explicit_assignment": true, + "card_seed": "296f10656b2cf98d8c4aa0075c432c47", + "catalogue_scope_key": "72dfbf0708467ad34793", + "method": "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget.", + "refined_method": "Prove and explicitly compute Gaussian interval lattices in chronological partial-sum coordinates; independently check exact-literal admission and separating controls.", + "canonical_thread": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2750", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2750#discussioncomment-19009685", + "claim_created_utc": "2026-10-18T02:10:00Z", + "claim_expiry_utc": "2026-10-18T04:10:00Z" + }, + "declared_milestone": "local module", + "bottleneck_link": "Characterises the additional stagewise conditions beyond the ideal correlated entrance and supplies an explicit reversible parameterisation, without re-pricing a stopped supplier.", + "outcome": "completed", + "stop_rule": "One source-bound admission classification or a precise separating counterexample. Bounded rank9/512 coordinates/257 events only. Stop after independently checked theorem, exact codec and explicit limitations; do not expand unchanged599/584 supplier.", + "optimistic_full_cost_budget": "No supplier gain claimed. Compute direct coordinate preparation costs where constructive; keep physical ownership, routing, precision, caller, complete external consumer and recursive tariffs unknown. The frozen unchanged-profile599/584 stop remains.", + "unresolved_costs": [ + "Physical preparation of the correlated domain from an actual caller", + "Owned and borrowed storage, routing, controller and numerical widths", + "Whole-prefix omitted branches and full external-recipient closure", + "Any changed fully paid recursive profile and coverage" + ], + "family_expansion_decision": "narrow: changed admission contract, one bounded source-bound theorem and constructive logical codec; no expansion of the unchanged stopped supplier", + "predecessor_authors": [ + "ywz65, PR2586 frozen word/native recipes", + "Arham Tahir, PR2665 retained inputs", + "Clear1nsight, PR3382 Newton lattice and PR3423 actual producer interfaces", + "Nick Petalas, PR3426 ideal correlated entrance and PR3416 native covariance", + "Tekalign, PR3025 signed-floor bijection and PR3218 phase-sensitive native checks", + "Ross Richardson, PR3068 exactness-domain question", + "Jose Manuel and Vasek W, inherited unchanged-profile cost stop", + "Nick Petalas, concurrent PR3449 sharp two-source rank-one calibration, read at submission without imported code or priority claim" + ], + "success_evidence": [ + "Exact maximal partial-sum lattice decomposition, with source-bound invariant factors and explicit encoder/decoder", + "Separate membership and literal-stage checks, passing and failing controls", + "Git-free deterministic bounded replay and source hashes" + ], + "entry_overlap": { + "open_pr_records": 358, + "page_counts": [ + 100, + 100, + 100, + 58 + ], + "complete_pr_pagination": true, + "checked_by_utc": "2026-10-18T01:59:48Z", + "discussion_threads": [ + 1163, + 1166, + 1167, + 2750 + ], + "discussion_pagination_complete": false, + "coverage": "Open PR title/body/head metadata only; rendered initial Discussion pages, sparse local corpus, no exhaustive novelty claim.", + "decision": "PR3426 stagewise admission handoff unclaimed in observed coverage; preserve Hiroki's675-port claim through03:50:14UTC.", + "port_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2750#discussioncomment-19009569", + "nearest_heads": [ + { + "number": 3382, + "title": "Construct a phase-compatible exactness domain for the literal P104 collector", + "head": "2834523b1cd4ea83ba7a043e2e2f5f3332cf9909", + "base": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "state": "open", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3382", + "author": "Clear1nsight", + "updated_at": "2026-10-18T00:02:56Z" + }, + { + "number": 3406, + "title": "Research: certify the sharp whole-word P104 Newton entrance", + "head": "18a054fd585ab4b2010770ec83cba0c9f28184e3", + "base": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "state": "open", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3406", + "author": "petalas", + "updated_at": "2026-10-18T00:52:54Z" + }, + { + "number": 3416, + "title": "Research: independently certify all P104 native chart identities", + "head": "f1112560883a5e81b1a29c37c81a79a20be31fe3", + "base": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "state": "open", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3416", + "author": "petalas", + "updated_at": "2026-10-18T01:14:03Z" + }, + { + "number": 3423, + "title": "Certify actual P104 Newton producer and consumer interfaces", + "head": "15d28c4de37dc47ea07cd7173c8b318fca7a4d75", + "base": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "state": "open", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3423", + "author": "Clear1nsight", + "updated_at": "2026-10-18T01:34:21Z" + }, + { + "number": 3426, + "title": "Research: prove the correlated P104 ideal entrance", + "head": "ce2221dddab6efd3027c09269765dd7eb45f2877", + "base": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "state": "open", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3426", + "author": "petalas", + "updated_at": "2026-10-18T01:30:46Z" + }, + { + "number": 3427, + "title": "P104: prove a rank-four source-preconditioning obstruction", + "head": "344774ba08a73fc3a85fdcb93fb319927bde3ea2", + "base": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "state": "open", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3427", + "author": "jmbarrancoml", + "updated_at": "2026-10-18T01:36:17Z" + } + ], + "fresh_distinct_tensor_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2750#discussioncomment-19009655" + }, + "checkpoints": [ + { + "checked_at_utc": "2026-10-18T01:56:11Z", + "canonical_main": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "guidance_hashes": { + "AGENTS.md": "eb25d8ec495b80190a4b1a634710819bb74f0fae88d5203285c2b75b6f147347", + "autoresearch.md": "8c98d179208c34a8c6768931e13f3bbeaa1cb63d59c660799ffde05c40935d9b", + "CONTRIBUTING.md": "8a49fe97e2ad088a2b2e0c5b222aaab08752783b1f9c1260790d7dd13011d215", + "docs/research/current-priorities.md": "c95e09baa997b48ba00a26ea29168e782b17392d28184ecb7a17eea5472dd77c", + "docs/research/research-family-status.md": "9b98ab42364e90588e90410fd2773f9bc4bf5050f514101bed0a0246881b5b7e", + "docs/research/agent-procedure.md": "b2dd2f64e5746fce6289422351f2e3d1eb224f7db09aeb72f4d6626263190aa1", + "docs/research/p104-live-support-map.md": "571bf5619059182809d4590e48f02a5cf81cf55a8a1700f10f4c57be45537211", + "docs/research/agent-task-catalog.json": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "certificates/selected-result.json": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "docs/research/pr-ledger.json": "648d472320a50eadde92886f1f53acb858baf200539ddf0dca17251ec7f4a409" + }, + "fetch": "Shell canonical git fetch failed to connect to browser-proxy:8889; GitHub MCP canonical main ref independently returned6f100d4 already present locally. No network settings changed.", + "decision": "Read current main guidance, preserve predecessor worktrees and frozen inputs, create isolated checkout at exact canonical main.", + "selected_unchanged": true + }, + { + "checked_at_utc": "2026-10-18T02:34:39+00:00", + "canonical_main": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "kind": "presubmission", + "guidance_changed": false, + "selected_unchanged": true, + "frozen_scientific_inputs_preserved": true, + "open_pr_coverage": { + "checked_utc": "2026-10-18 02:35:23 UTC", + "count": 368, + "page_counts": [ + 100, + 100, + 100, + 68 + ], + "complete_pagination": true, + "unique_count": 368, + "non_atomic": true, + "sort": "created descending", + "per_page": 100, + "endpoint_template": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/pulls?state=open&sort=created&direction=desc&per_page=100&page={page}", + "old_count": 358, + "added": [ + 3445, + 3446, + 3447, + 3448, + 3449, + 3450, + 3451, + 3452, + 3453, + 3454 + ], + "removed": [], + "existing_head_changes": [], + "existing_body_changes": [], + "other_changes": [ + { + "number": 3443, + "fields": [ + "updated_at" + ] + } + ] + }, + "feedback": { + "numbers": [ + 3423, + 3426, + 3416 + ], + "head_and_body_unchanged": true, + "state": "All three open", + "issue_comments": 0, + "submitted_reviews": 0, + "inline_review_comments": 0, + "coverage": "All nine REST collections requested with per_page=100 page=1; each returned an empty array, so those collections were completely observed. No Discussion or unpublished feedback implied." + }, + "new_overlap": [ + { + "pr": 3449, + "author": "Nick Petalas / petalas", + "head": "5cb2ff187a27de1cbd1a37933f7228b35b15702b", + "scope": "Sharp exact literal domain for the specific correlated Y27=y, Y26=-y family, arbitrary admitted dirty D/Q, in the same 257-event dependency slice.", + "mathematical_overlap": "Its right-wrapper exponent max(|S|,4+1_{0 in S}) is the same local rank-one profile used in the general classification; it establishes index 280 for that actual window.", + "distinct_delta_here": "General simultaneous 58-bank entrance, all 32 zero-transport and 15 rank-one partial-sum gaps plus five terminal modules, aggregate quotient/index 20424, and a constructive 52-bank encoder/inverse with an explicit arithmetic and width ledger.", + "decision": "Credit as concurrent narrow calibration. Do not claim priority or novelty of the one-window rank-one formula. No runtime import, copied executable or predecessor rerun is needed.", + "evidence": "Exact PR body and full proof read; visible Discussion 2750 comment19009711 explicitly distinguishes and credits our general claim.", + "proof_url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/5cb2ff187a27de1cbd1a37933f7228b35b15702b/research/p104-correlated-exact-module/PROOF.md", + "proof_sha256": "66ed7dbf4748eb590b1e8fe4c41ef924c1c45461c66d9de4cf00771a2a403ea0", + "proof_git_blob": "2107b3996def6786e3d767a4b7011ae16f8e6b38" + }, + { + "pr": 3446, + "author": "Hiroki Kumazaki / kumagi", + "head": "886222c1d3e2c2d878b263dc8d165ef03d5bac7f", + "scope": "Actual outgoing-port recipient closure: 4027 events, 265 independent input banks, product admission and terminal map; 696 omitted outgoing ADD effects remain.", + "decision": "Completed complementary recipient-history handoff. Our result remains restricted to the 257-event producer cone and does not supersede or reopen that closure.", + "evidence": "Exact PR body read; visible Discussion 2750 comment19009569 marked DONE/released." + }, + { + "pr": 3448, + "author": "Nick Petalas / petalas", + "head": "97e20b899db9e1ba9cfc8d3010ada1c75236ec1a", + "scope": "Independent product Newton admission for the unchanged whole word at every positive payload depth.", + "decision": "Complementary all-depth independent-input theorem. It does not classify the present correlated stagewise cone or supply the codec.", + "evidence": "Exact PR body read; visible Discussion 2750 comment19009655 marked DONE/released." + } + ], + "discussion_refresh": { + "threads": [ + 2750, + 1166 + ], + "full_corpus_pagination": false, + "checked_through_utc": "2026-10-18T02:43:11.725656+00:00", + "observed_released_scopes": [ + 3446, + 3448, + 3449 + ], + "hub_later_posts": [ + 3460, + 3461 + ], + "limits": "Rendered thread DOM only; the helper has no complete Discussion corpus.", + "hub_dom_sha256": "d050bafb107096f5d6c834b82d18fdae343e268e62e8434b56f3c942c835af1c" + }, + "decision": { + "action": "CONTINUE within already claimed NARROW admission scope", + "reason": "The full queue and targeted source review reveal concurrent narrow and complementary results, with no observed competing general 58-bank classification or encoder. This is a scoped overlap conclusion, not a global novelty certificate.", + "family_gate": "Unchanged supplier family remains stopped; retain the conditional 599/584 profile/coverage stop. This package does not assert a favorable paid caller, full prefix admission, complete consumer, new kappa, or selected-frontier change.", + "publication_obligation": "Credit PR3449 concurrently in README/PROOF/SOURCES context; preserve exact source pins and the owned-bank codec/physical-cost limitations." + }, + "fetch": "Shell canonical git fetch remained proxy-blocked; GitHub MCP ref returned the exact unchanged canonical commit already retained locally. No network settings or frozen inputs changed.", + "canonical_main_reconfirmed_by_utc": "2026-10-18T02:45:40Z" + } + ], + "evidence": "PROOF.md establishes necessity and sufficiency, all local profiles and the actual-path reversible codec. RECEIPT.json is rebuilt by primary, independently written literal, and independent source-cost implementations. Both registered Python modes, metadata/pins, and three separate CLI rejection controls pass; exact evidence and limits are recorded in verification.", + "open_questions": [ + { + "question": "Which actual caller can use the coefficient-to-source encoder with a proved input/output intertwiner and return the prepared banks for its inverse?", + "why_it_matters": "A parameterisation changes the numerical source values. An actual algorithm must consume that meaning and restore the required values, frames and ownership before cleanup.", + "first_step": "Name one source-bound caller and logical output, specify borrowed and owned roles, and compose its entry/return equations with this explicit encoder. Price all copies, control, routes, widths, cleanup and displaced work.", + "blocked_by": "No such paid caller or compatible returned-source contract is supplied by this cone theorem." + }, + { + "question": "Which additional literal constraints are required by that caller on the omitted original-prefix reads and external effects?", + "why_it_matters": "The257-event dependency cone leaves1768 prefix events outside its arithmetic claim; compatible states must also satisfy whichever of those histories the actual caller uses.", + "first_step": "Using a specified caller, intersect this explicit partial-sum module with its additional authenticated read/stage conditions. Coordinate with the published PR3446 recipient closure and PR3449 noncone-read handoff.", + "blocked_by": "The required whole execution and ownership boundary has not been fixed. General rounded trajectories are not classified here." + }, + { + "question": "Can a named changed supplier profile or coverage law afford the complete preparation, caller, return and consumer bill?", + "why_it_matters": "The larger admission set does not alter the unchanged-profile599/584 obstruction or remove native children.", + "first_step": "Declare the changed hypothesis and every known or unknown cost, then apply a fully charged optimistic moment screen before a supplier construction round.", + "blocked_by": "No changed favourable complete profile, physical tariff or all-size transfer is provided." + } + ], + "verification_review": { + "mathematical_and_cost_notes": "Independent agent read-only review found no mathematical or arithmetic error; scope and native-path width wording clarified.", + "joint_verifier": "Separate agent read-only review of raw-source execution and independent cost integration found no concrete remaining correctness or rejection gap.", + "independence_limit": "All four agents use OpenAI assistance. No independent human or formal-kernel proof acceptance claimed." + }, + "verification": { + "completed_by_utc": "2026-10-18T02:45:40Z", + "python": "3.12.14", + "registered_normal": "PASS_EXACT_STAGEWISE_ENTRANCE", + "registered_optimised": "PASS_EXACT_STAGEWISE_ENTRANCE", + "package_metadata": "PASS_PACKAGE_METADATA_AND_PINS", + "registered_package": "PASS_REGISTERED_RESEARCH_PACKAGE", + "receipt_bytes": 322939, + "receipt_sha256": "91b4f644189bacdd19952e360d55d3738a915e50cf98001baf7f47fda54bd561", + "receipt_scientific_sha256": "f2ec5be0707ab21f9f7fae68ebb91e862c8ee8eff094fc2e62b37af39b9a0f49", + "cli_rejection_checks": { + "status": "PASS_THREE_CLI_REJECTIONS", + "python": "3.12.14", + "controls": [ + { + "control": "missing_source", + "exit_code": 1, + "stderr": "FAIL_STAGEWISE_ENTRANCE: regular file required: WORD.json" + }, + { + "control": "corrupt_source", + "exit_code": 1, + "stderr": "FAIL_STAGEWISE_ENTRANCE: runtime/provenance source mismatch: research/p104-rounded-collector/inputs/WORD.json" + }, + { + "control": "boolean_receipt", + "exit_code": 1, + "stderr": "FAIL_STAGEWISE_ENTRANCE: typed receipt mismatch at receipt.profiles.local.zero.exponent_histogram.4" + } + ], + "source_and_receipt_paths": "Separate disposable Git-free copy; original package untouched" + }, + "coverage_limits": [ + "Normal and optimised registered commands cover this package, not historical predecessor suites.", + "Dense cross-implementation agreement uses full-array hashes; each evaluator independently checks all six complete cut formulae.", + "No independent human review or formal proof-kernel acceptance.", + "Commit-byte and Git-free publication checks are reported in the public PR after the tested files are committed." + ] + } +} diff --git a/research/p104-stagewise-entrance/VERIFY.json b/research/p104-stagewise-entrance/VERIFY.json new file mode 100644 index 0000000000..458be97302 --- /dev/null +++ b/research/p104-stagewise-entrance/VERIFY.json @@ -0,0 +1,38 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-rounded-collector/inputs/WORD.json", + "research/p104-rounded-collector/inputs/NATIVE.json.gz", + "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": 180, + "checks": "Authenticate the frozen scientific and retained sources; reconstruct every producer gap; compare explicit profiles with a separate basis-threshold check; check the actual-path reversible dense codec and literal cone, ideal/nonexact controls, direct logical ledger, typed deterministic receipt and fail-closed source/receipt controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Repeat all registered mathematical, source and rejection checks with optimised Python; explicit validation remains enabled and the scientific receipt is unchanged." + } + ] +} diff --git a/research/p104-stagewise-entrance/admission.py b/research/p104-stagewise-entrance/admission.py new file mode 100644 index 0000000000..c035cc9f95 --- /dev/null +++ b/research/p104-stagewise-entrance/admission.py @@ -0,0 +1,102 @@ +"""Constructive coordinates for the source-bound exact producer entrance. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +This is a parameterisation of new source values, not a repair of a caller's +existing values or a claim about any omitted prefix/recipient arithmetic. +""" + + +def encode_sources(structure, plans, model, source, classifier, parameters): + source.require(type(parameters) is list and len(parameters) == 52, + "52 independent partial-sum coefficient banks") + partials = [] + for gap, coefficients in zip(structure["gaps"], parameters): + value = classifier.encode_profile(coefficients, gap["kind"]) + if gap["kind"] == "rank_one": + plan = plans[gap["transport_event"]] + value = source.apply_wrapper(value, plan["right"], model, inverse=True) + if gap["kind"] != "terminal": + value = source.apply_path(value, gap["path_to_read"], plans, model, inverse=True) + partials.append(value) + initial_y = {} + offset = 0 + for bank in source.D_BANKS: + rows = structure["groups"][bank] + count = len(rows) + values = classifier.prefix_difference(partials[offset:offset + count]) + initial_y.update((row["source"], value) for row, value in zip(rows, values)) + offset += count + source.require(offset == 52 and set(initial_y) == set(source.YS), "complete source encoder") + return initial_y + + +def decode_sources(structure, plans, model, source, classifier, initial_y): + source.require(set(initial_y) == set(source.YS), "exact52 source roles") + source.require(all(model.member(values) for values in initial_y.values()), "initial source B domain") + partials = [] + for bank in source.D_BANKS: + rows = structure["groups"][bank] + partials.extend(classifier.prefix_sum([initial_y[row["source"]] for row in rows])) + parameters = [] + for gap, value in zip(structure["gaps"], partials): + if gap["kind"] != "terminal": + value = source.apply_path(value, gap["path_to_read"], plans, model) + if gap["kind"] == "rank_one": + value = source.apply_wrapper(value, plans[gap["transport_event"]]["right"], model) + parameters.append(classifier.decode_profile(value, gap["kind"])) + return parameters + + +def dense_fixture(structure, plans, model, source, classifier): + parameters = [source.coefficient_fixture(slot) for slot in range(52)] + initial = encode_sources(structure, plans, model, source, classifier, parameters) + for slot, name in enumerate(source.TARGETS, start=52): + initial[name] = model.encode(source.coefficient_fixture(slot)) + recovered = decode_sources(structure, plans, model, source, classifier, + {name: initial[name] for name in source.YS}) + source.require(recovered == parameters, "all52 actual-path source codec inverses") + return initial + + +def expected_cut(initial, structure, plans, model, source): + """PR3426's inherited ideal rows, checked against the literal dense trace.""" + outputs = {} + for bank in source.D_BANKS: + total = [(0, 0)] * source.SIZE + for row in structure["groups"][bank]: + total = [model.add(a, b) for a, b in zip(total, initial[row["source"]])] + source.require(all(x % 4 == 0 for value in total for x in value), "terminal quarter integral") + normalised = [model.add(a, (b[0] // 4, b[1] // 4)) + for a, b in zip(initial[bank], total)] + outputs[bank] = source.apply_path(normalised, structure["cut_paths"][bank], plans, model) + q = initial["Q7"][:] + for bank in source.D_BANKS: + q = [model.sub(a, b) for a, b in zip(q, initial[bank])] + outputs["Q7"] = source.apply_path(q, structure["cut_paths"]["Q7"], plans, model) + return outputs + + +def control_initials(structure, plans, model, source): + first = min((gap for gap in structure["gaps"] if gap["kind"] == "rank_one"), + key=lambda gap: gap["event"]) + rows = structure["groups"][first["bank"]] + position = next(i for i, row in enumerate(rows) if row["event"] == first["event"]) + following = rows[position + 1]["source"] + output = {} + for kind in ("quarter", "native"): + value = [(1, 0)] * source.SIZE if kind == "quarter" else [ + (-4, 0) if k & 1 else (0, 0) for k in range(source.SIZE)] + if kind == "native": + value = source.apply_wrapper(value, plans[first["transport_event"]]["right"], + model, inverse=True) + value = source.apply_path(value, first["path_to_read"], plans, model, inverse=True) + initial = {name: [(0, 0)] * source.SIZE for name in structure["dependencies"]} + initial[first["source"]] = value + initial[following] = [(-a, -b) for a, b in value] + source.require(all(model.member(v) for v in initial.values()), "control initial B domain") + output[kind] = initial + paired = {name: [(0, 0)] * source.SIZE for name in structure["dependencies"]} + paired["Y27"][0] = (64, 0) + paired["Y26"][0] = (-64, 0) + output["paired64"] = paired + return output diff --git a/research/p104-stagewise-entrance/classifier.py b/research/p104-stagewise-entrance/classifier.py new file mode 100644 index 0000000000..6a299ce9b9 --- /dev/null +++ b/research/p104-stagewise-entrance/classifier.py @@ -0,0 +1,229 @@ +"""Explicit Gaussian profiles for the pinned producer's partial-sum gaps. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. + +This module implements only the diagonal profiles and the reversible change of +bank coordinates. It neither reads the source word nor supplies a native path. +The source-bound caller is responsible for authenticating each gap and applying +its actual frame pullback. The finite reference uses at most nine address bits; +PROOF.md gives the algebraic statements at arbitrary rank. +""" + +from math import comb + + +MAX_RANK = 9 +KINDS = ("zero", "rank_one", "terminal") + + +class ClassifierError(ValueError): + """Malformed data or a violated finite-reference contract.""" + + +class OutsideProfile(ClassifierError): + """A Gaussian division required by the profile is unavailable.""" + + +def require(condition, message): + if not condition: + raise ClassifierError(message) + + +def _rank(rank): + require(type(rank) is int and 0 <= rank <= MAX_RANK, + "rank must be an integer in 0..9") + return rank + + +def _array(values, rank=None): + require(type(values) is list and values, + "Gaussian array must be a nonempty list") + size = len(values) + require(size <= 1 << MAX_RANK and size & (size - 1) == 0, + "Gaussian array length must be a power of two at most 512") + actual = size.bit_length() - 1 + if rank is not None: + require(_rank(rank) == actual, "array rank mismatch") + for value in values: + require(type(value) is tuple and len(value) == 2, + "Gaussian value must be a tuple of two integers") + require(all(type(component) is int for component in value), + "Gaussian components must be integers, not Boolean values") + return actual + + +def _add(a, b): + return a[0] + b[0], a[1] + b[1] + + +def _sub(a, b): + return a[0] - b[0], a[1] - b[1] + + +def _times_pi(a): + return a[0] - a[1], a[0] + a[1] + + +def _divide_pi(a): + real, imag = a + if (real + imag) % 2: + raise OutsideProfile("required division by 1+i is not Gaussian integral") + return (real + imag) // 2, (imag - real) // 2 + + +def _pi_l1(exponent): + """Sum of absolute real/imaginary parts of (1+i)**exponent.""" + return 1 << ((exponent + 1) // 2) + + +def profile(kind, rank=9): + """Return a canonical diagonal and its algebraic/abstract gate invoice. + + ``zero`` describes B_r intersect 4 Z[i]^(2**r). + ``rank_one`` describes q and C_0 q both in 4 Z[i]^(2**r). + ``terminal`` describes 4 B_r, encoded using +4, not pi**4 = -4. + + Index exponents are logarithms to base two of Gaussian-lattice indices. + They are not a physical storage, operation, or supplier-cost lower bound. + Counts describe one in-place arithmetic schedule, not Python allocations. + """ + _rank(rank) + require(type(kind) is str and kind in KINDS, "unknown gap kind") + require(kind != "rank_one" or rank >= 1, + "rank-one profile needs address bit zero") + size = 1 << rank + if kind == "zero": + exponents = [max(4 - mask.bit_count(), 0) for mask in range(size)] + gain = sum(comb(rank, degree) * _pi_l1(max(4, degree)) + for degree in range(rank + 1)) + elif kind == "rank_one": + exponents = [max(4 - (mask & ~1).bit_count(), 0) + for mask in range(size)] + gain = sum(comb(rank - 1, degree) + * (_pi_l1(max(4, degree)) + _pi_l1(max(4, degree) + 1)) + for degree in range(rank)) + else: + exponents = [4] * size + gain = 4 * sum(comb(rank, degree) * _pi_l1(degree) + for degree in range(rank + 1)) + pairs = rank * (size // 2) + diagonal_pi_steps = sum(exponents) if kind != "terminal" else 0 + return { + "kind": kind, + "rank": rank, + "dimension": size, + "exponents": exponents, + "exponent_histogram": {str(k): exponents.count(k) for k in range(5)}, + "pi_index_exponent": sum(exponents), + "coefficient_to_value_component_gain": gain, + "encode_schedule": { + "gaussian_additions": pairs, + "gaussian_pi_multiplications": pairs + diagonal_pi_steps, + "gaussian_doublings": 2 * size if kind == "terminal" else 0, + }, + "decode_schedule": { + "gaussian_subtractions": pairs, + "exact_gaussian_pi_divisions": pairs + diagonal_pi_steps, + "exact_gaussian_halvings": 2 * size if kind == "terminal" else 0, + }, + "source_path_cost_included": False, + } + + +def _encode_newton(coefficients): + rank = _array(coefficients) + values = coefficients[:] + for bit in range(rank): + step = 1 << bit + for address in range(len(values)): + if not address & step: + other = address | step + values[other] = _add(values[address], _times_pi(values[other])) + return values + + +def _decode_newton(values): + rank = _array(values) + coefficients = values[:] + for bit in reversed(range(rank)): + step = 1 << bit + for address in range(len(coefficients)): + if not address & step: + other = address | step + coefficients[other] = _divide_pi( + _sub(coefficients[other], coefficients[address])) + return coefficients + + +def encode_profile(coefficients, kind): + """Encode arbitrary Gaussian coefficients into the named local profile. + + No actual frame pullback is performed here. Terminal convention is +4 E c. + Inputs are never mutated. Python integers are exact and have no hidden + fixed-width wraparound; the proof states explicit finite-width obligations. + """ + rank = _array(coefficients) + data = profile(kind, rank) + if kind == "terminal": + return [(4 * a, 4 * b) for a, b in _encode_newton(coefficients)] + scaled = coefficients[:] + for address, exponent in enumerate(data["exponents"]): + for _ in range(exponent): + scaled[address] = _times_pi(scaled[address]) + return _encode_newton(scaled) + + +def decode_profile(values, kind): + """Invert the local profile, raising OutsideProfile off its image. + + Signed division is exact: a nonzero remainder rejects before // is used. + The output consists of the arbitrary Gaussian coefficient coordinates, + which are a different contract from the prepared native-domain array. + """ + rank = _array(values) + data = profile(kind, rank) + coefficients = _decode_newton(values) + if kind == "terminal": + result = [] + for real, imag in coefficients: + if real % 4 or imag % 4: + raise OutsideProfile("terminal Newton coefficient is not divisible by 4") + result.append((real // 4, imag // 4)) + return result + for address, exponent in enumerate(data["exponents"]): + for _ in range(exponent): + coefficients[address] = _divide_pi(coefficients[address]) + return coefficients + + +def _banks(banks): + require(type(banks) is list and banks, + "bank sequence must be a nonempty list") + rank = _array(banks[0]) + for bank in banks[1:]: + _array(bank, rank) + return rank + + +def prefix_difference(partials): + """Recover chronological Y sources from their independent partial sums. + + For m banks this uses m-1 field subtractions. The separate in-place + schedule runs indices m-1 down to 1 so the earlier partial sum survives + until its last use. This functional implementation does not mutate inputs. + """ + _banks(partials) + return [partials[0][:]] + [ + [_sub(current, previous) for current, previous in zip(partials[j], partials[j - 1])] + for j in range(1, len(partials)) + ] + + +def prefix_sum(sources): + """Invert prefix_difference using m-1 chronological field additions.""" + _banks(sources) + partials = [sources[0][:]] + for source in sources[1:]: + partials.append([_add(previous, value) + for previous, value in zip(partials[-1], source)]) + return partials diff --git a/research/p104-stagewise-entrance/costs.py b/research/p104-stagewise-entrance/costs.py new file mode 100644 index 0000000000..57a0216a3b --- /dev/null +++ b/research/p104-stagewise-entrance/costs.py @@ -0,0 +1,104 @@ +"""Constructive logical invoice for the explicit 52-bank admission codec. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +Counts price the stated arithmetic schedule, not a physical or recursive tariff. +The arbitrary six dirty D/Q banks already satisfy their separate B9 contract. +""" + +from collections import Counter + + +def permutation_cycles(plan): + permutation = [target for target, _ in plan] + if sorted(permutation) != list(range(len(plan))): + raise ValueError("wrapper permutation must be bijective") + seen, count = set(), 0 + for start in range(len(plan)): + if start in seen: + continue + count += 1 + at = start + while at not in seen: + seen.add(at) + at = permutation[at] + return count + + +def path_inventory(structure, plans): + events, wrappers, extras = [], [], [] + for gap in structure["gaps"]: + if gap["kind"] == "terminal": + continue + for event in gap["path_to_read"]: + events.append(event) + wrappers.extend((plans[event]["left"], plans[event]["right"])) + if gap["kind"] == "rank_one": + extra = gap["transport_event"] + extras.append(extra) + wrappers.append(plans[extra]["right"]) + phases = Counter((-phase) % 4 for plan in wrappers for _, phase in plan) + cycles = [permutation_cycles(plan) for plan in wrappers] + return { + "native_event_occurrences": events, "native_occurrence_count": len(events), + "native_rank_mass": sum(plans[e]["rank"] for e in events), + "extra_right_wrapper_events": extras, "wrapper_count": len(wrappers), + "wrapper_cycles": cycles, "wrapper_cycle_sum": sum(cycles), + "gaussian_payload_swaps": sum(len(plan) - count for plan, count in zip(wrappers, cycles)), + "inverse_wrapper_phase_histogram": {str(k): phases[k] for k in range(4)}, + "wrapper_phase_positions": sum(len(plan) for plan in wrappers), + "swap_contract": "Direct Gaussian payload SWAP gates on owned words, n-cycles per permutation; different from the n+cycles clean-scratch implementation.", + } + + +def invoice(structure, plans, classifier): + inventory = path_inventory(structure, plans) + profiles = [classifier.profile(gap["kind"]) for gap in structure["gaps"]] + adds = sum(p["encode_schedule"]["gaussian_additions"] for p in profiles) + pi_steps = sum(p["encode_schedule"]["gaussian_pi_multiplications"] for p in profiles) + doublings = sum(p["encode_schedule"]["gaussian_doublings"] for p in profiles) + differences = (52 - 5) * 512 + native_pairs = inventory["native_rank_mass"] * 256 + forward_adds = 2 * (adds + pi_steps + doublings + differences) + 8 * native_pairs + reverse_adds = forward_adds - 2 * doublings + native_halves = 4 * native_pairs + phases = inventory["inverse_wrapper_phase_histogram"] + phase_turns = phases["1"] + phases["3"] + negations = phase_turns + 2 * phases["2"] + native_pairs + swap_adds = 6 * inventory["gaussian_payload_swaps"] + 3 * (phase_turns + native_pairs) + return { + "kind": "constructive_logical_upper_bound_not_physical_supplier_invoice", + "owned_coefficient_banks": 52, "gaussian_payload_words": 52 * 512, + "separate_already_admitted_dirty_banks": 6, "newton_additions": adds, + "gaussian_pi_steps": pi_steps, "terminal_gaussian_doublings": doublings, + "group_field_differences": 47, "gaussian_differences": differences, + "native_pairs_per_direction": native_pairs, "native_quarter_turns": native_pairs, + "path_inventory": inventory, + "forward": {"real_add_subtracts_before_swap_phase_lowering": forward_adds, + "real_floor_halves": native_halves, + "real_add_subtracts_with_swaps_and_negations": forward_adds + swap_adds + negations}, + "reverse": {"real_add_subtracts_before_swap_phase_lowering": reverse_adds, + "real_halves": native_halves + 2 * pi_steps + 2 * doublings, + "real_add_subtracts_with_swaps_and_negations": reverse_adds + swap_adds + negations}, + "optional_lowering": {"gaussian_swap_real_adds": 6, "real_component_swap_adds": 3, + "unary_negations_as_zero_minus_value": negations, + "extra_real_adds_for_swaps": swap_adds, + "real_swap_schedule": ["x <- x+y", "y <- x-y", "x <- x-y"], + "scope": "Exact unbounded component arithmetic permits source-minus-target overwrite and unary zero-minus-value. This is not automatically the repository strict target-ADD tariff. Fixed-width overflow and physical bit costs remain obligations."}, + "width_bounds": {"coefficient_component_limit": "H", + "nonterminal_profile_component_gain": 3828, + "unitary_path_component_gain": 122496, + "terminal_component_gain": 13452, + "prepared_source_component_gain": 244992, + "encoder_work_component_gain": 612480, + "decoder_input_component_limit": "J", + "decoder_work_component_gain": 98304}, + "borrowed_source_copy_option": {"owned_zero_banks": 52, "copy_field_adds": 52, + "cleanup_field_subtracts": 52, + "precondition": "Prepared banks are returned unchanged in their entrance frame before inversion and cleanup; this cone theorem does not prove that return."}, + "unpriced": ["An actual caller and its changed logical input/output interpretation", + "Physical word ownership, control, layout and routing", + "Bit complexity and fixed-width gate implementation", + "Omitted prefix branches and compatible complete external consumer", + "Recursive child/coverage costs and all-size transfer"], + "inherited_unchanged_profile_stop": "599/584 > 1; no changed supplier profile is proposed", + } diff --git a/research/p104-stagewise-entrance/independent.py b/research/p104-stagewise-entrance/independent.py new file mode 100644 index 0000000000..4fd0ef137b --- /dev/null +++ b/research/p104-stagewise-entrance/independent.py @@ -0,0 +1,606 @@ +"""Independent source and literal-arithmetic checks for the 257-event cone. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +No predecessor or primary executable is imported. This bounded checker uses +actual Y-source paths as its empty-to-read maps; the primary construction uses +D paths. Their identification inherits the separately pinned native covariance +theorem. Numerical execution below is the dependency cone, not the whole prefix. +""" + +import argparse +import gzip +import hashlib +import io +import json +from collections import Counter +from pathlib import Path + + +WORD_SHA256 = "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50" +NATIVE_SHA256 = "ab91c78835c3e10cf3b2cb8a5d4e0b7cfc3df1ae5a811298d27842f2193e1e3d" +SIZE = 512 +RANK = 9 +CUT = 2025 +ZERO = (0, 0) +BANKS = ("D31", "D30", "D29", "D28", "D27") +DIRTY = (*BANKS, "Q7") +PI = ((1, 0), (1, 1), (0, 2), (-2, 2), (-4, 0)) + + +class IndependentError(ValueError): + """A source, arithmetic, or finite-reference contract failed.""" + + +class ArithmeticFailure(IndependentError): + """The first ideal stage that has no exact Gaussian realization.""" + + def __init__(self, record): + super().__init__(record["kind"]) + self.record = record + + +def need(condition, message): + if not condition: + raise IndependentError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) + + +def digest(value): + return hashlib.sha256(canonical(value).encode()).hexdigest() + + +def unique_object(items): + out = {} + for key, value in items: + need(key not in out, "duplicate JSON key") + out[key] = value + return out + + +def json_load(data): + def forbidden(value): + raise IndependentError("noninteger JSON number: " + value) + return json.loads(data, object_pairs_hook=unique_object, + parse_float=forbidden, parse_constant=forbidden) + + +def authenticated(path, expected): + path = Path(path) + need(path.is_file() and not path.is_symlink(), "regular scientific source required") + need(path.stat().st_size <= 1048576, "scientific source capacity") + data = path.read_bytes() + need(hashlib.sha256(data).hexdigest() == expected, "scientific source SHA256 mismatch") + return data + + +def source_inputs(word_path, native_path): + word = json_load(authenticated(word_path, WORD_SHA256)) + compressed = authenticated(native_path, NATIVE_SHA256) + with gzip.GzipFile(fileobj=io.BytesIO(compressed)) as handle: + raw = handle.read(8388609) + need(len(raw) <= 8388608, "decompressed native source capacity") + native = json_load(raw) + need(len(word["program"]) == 5398, "literal word event count") + need(len(word["initial_frames"]) == 358, "literal initial role count") + need(len(native["transports"]) == 1245, "native recipe count") + bound = bind_native(word, native) + check_frames(word) + return word, bound + + +def bind_native(word, native): + bound = {} + for record in native["transports"]: + recipe = record["recipe"] + need(type(recipe["rank"]) is int and 1 <= recipe["rank"] <= RANK, + "positive bounded native rank") + for event in record["events"]: + need(type(event) is int and 0 <= event < len(word["program"]), "native event") + need(event not in bound, "duplicate native occurrence") + literal = word["program"][event] + need(literal[0] == "transport", "native occurrence opcode") + need(literal[2:] == [record["old"], record["new"], recipe["rank"]], + "native occurrence/frame/rank binding") + bound[event] = recipe + actual = {i for i, e in enumerate(word["program"]) if e[0] == "transport"} + need(set(bound) == actual and len(bound) == 2070, "complete occurrence binding") + return bound + + +def check_frames(word): + frames = {role: tuple(frame) for role, frame in word["initial_frames"].items()} + for event in word["program"]: + op, target = event[:2] + if op == "transport": + need(frames[target] == tuple(event[2]), "chronological native old frame") + frames[target] = tuple(event[3]) + elif op == "add": + need(frames[target] == frames[event[2]] == tuple(event[4]), "common ADD frame") + elif op == "sign": + need(event[2] == "-1" and frames[target] == tuple(event[3]), "signed frame") + elif op == "zero": + need(target not in frames, "private role already live") + frames[target] = tuple(event[2]) + else: + need(op == "erase" and frames[target] == tuple(event[2]), "private erase frame") + del frames[target] + need(frames == {r: tuple(f) for r, f in word["final_frames"].items()}, "terminal frames") + + +def extract_cone(word): + live, selected = set(DIRTY), [] + for index in range(CUT - 1, -1, -1): + event = word["program"][index] + if event[1] not in live: + continue + need(event[0] in ("transport", "add"), "unexpected producer cone operation") + selected.append(index) + if event[0] == "add": + live.add(event[2]) + selected.reverse() + need(len(selected) == 257 and len(live) == 58, "producer dependency cone") + need(all(word["initial_frames"][role] == [] for role in live), "empty producer inputs") + groups = extract_groups(word, selected) + slots = extract_slots(word, selected, groups) + return selected, live, groups, slots + + +def extract_groups(word, cone): + groups = [] + for bank in BANKS: + reads = [] + for index in cone: + event = word["program"][index] + if event[0] == "add" and event[1] == bank: + need(str(event[3]) == "1/4" and event[2].startswith("Y"), "producer quarter") + reads.append({"source": event[2], "event": index}) + groups.append({"bank": bank, "reads": reads}) + names = [read["source"] for group in groups for read in group["reads"]] + need(len(names) == len(set(names)) == 52, "disjoint Y source groups") + need([len(g["reads"]) for g in groups] == [3, 7, 7, 11, 24], "source group lengths") + return groups + + +def path_to_source_read(word, cone, source, read): + path = [] + for index in cone: + if index >= read: + break + event = word["program"][index] + if event[1] == source: + need(event[0] == "transport", "Y source has a nontransport producer") + path.append(index) + return path + + +def extract_slots(word, cone, groups): + slots = [] + for group in groups: + reads = group["reads"] + for offset, read in enumerate(reads): + following = reads[offset + 1]["event"] if offset + 1 < len(reads) else None + transports = [] if following is None else [i for i in cone + if read["event"] < i < following and word["program"][i][0] == "transport" + and word["program"][i][1] == group["bank"]] + need(len(transports) <= 1, "at most one intervening native occurrence") + if transports: + need(word["program"][transports[0]][4] == 1, "rank-one interval") + kind = "terminal" if following is None else ("rank_one" if transports else "zero") + slots.append({"bank": group["bank"], **read, "next_event": following, + "kind": kind, "transport_event": transports[0] if transports else None, + "source_path": path_to_source_read(word, cone, read["source"], read["event"]), + "frame": word["program"][read["event"]][4]}) + need(Counter(s["kind"] for s in slots) == {"zero": 32, "rank_one": 15, "terminal": 5}, + "source interval census") + return slots + + +def add(left, right): + return left[0] + right[0], left[1] + right[1] + + +def sub(left, right): + return left[0] - right[0], left[1] - right[1] + + +def multiply(left, right): + return left[0] * right[0] - left[1] * right[1], left[0] * right[1] + left[1] * right[0] + + +def rotate(value, phase): + real, imag = value + return ((real, imag), (-imag, real), (-real, -imag), (imag, -real))[phase % 4] + + +def encode(coefficients): + need(len(coefficients) == SIZE, "rank-nine coefficients") + out = list(coefficients) + for bit in range(RANK): + step = 1 << bit + for address in range(SIZE): + if not address & step: + out[address | step] = add(out[address], multiply(PI[1], out[address | step])) + return out + + +def decode(values): + need(len(values) == SIZE, "rank-nine values") + out = list(values) + for bit in reversed(range(RANK)): + step = 1 << bit + for address in range(SIZE): + if not address & step: + real, imag = sub(out[address | step], out[address]) + need((real + imag) % 2 == 0, "outside Gaussian Newton lattice") + out[address | step] = ((real + imag) // 2, (imag - real) // 2) + return out + + +def belongs(values): + try: + decode(values) + except IndependentError: + return False + return True + + +def literal_pair(a, b, inverse=False): + real, imag = sub(a, b) + center = add(b, (real // 2, imag // 2)) + turned = (imag, -real) if inverse else (-imag, real) + second = sub(center, (turned[0] // 2, turned[1] // 2)) + return add(second, turned), second + + +def ideal_pair(a, b, inverse=False): + sign = -1 if inverse else 1 + real, imag = sub(a, b) + total_real, total_imag = add(a, b) + nums = ((total_real - sign * imag, total_imag + sign * real), + (total_real + sign * imag, total_imag - sign * real)) + if any(component % 2 for pair in nums for component in pair): + return None, nums + return tuple((real // 2, imag // 2) for real, imag in nums), nums + + +def stage(values, bit, inverse=False, event=None): + out = list(values) + step = 1 << bit + for address in range(SIZE): + if address & step: + continue + other = address | step + literal = literal_pair(out[address], out[other], inverse) + ideal, nums = ideal_pair(out[address], out[other], inverse) + if ideal is None: + raise ArithmeticFailure({"kind": "nonintegral_native_pair", "event": event, + "bit": bit, "address": address, "numerators": nums, + "inputs": [out[address], out[other]], "literal": literal}) + need(literal == ideal, "literal/ideal pair disagreement on integral ideal input") + out[address], out[other] = literal + return out + + +def wrapper_plan(record): + rows, linear, quadratic = (record[k] for k in ("matrix_rows", "linear_Z4", "quadratic_rows")) + need(len(rows) == len(linear) == len(quadratic) == RANK, "wrapper shape") + permutation, phases = [], [] + for address in range(SIZE): + target = sum(((address & row).bit_count() % 2) << bit for bit, row in enumerate(rows)) + permutation.append(target ^ record["offset"]) + phase = record["phase"] + for bit in range(RANK): + if address & (1 << bit): + phase += linear[bit] + for other in range(bit + 1, RANK): + if address & (1 << other) and quadratic[bit] & (1 << other): + phase += 2 + phases.append(phase % 4) + need(set(permutation) == set(range(SIZE)), "bijective monomial wrapper") + return tuple(permutation), tuple(phases) + + +def wrapper(values, plan, inverse=False): + permutation, phases = plan + out = [ZERO] * SIZE + for source, target in enumerate(permutation): + if inverse: + out[source] = rotate(values[target], -phases[source]) + else: + out[target] = rotate(values[source], phases[source]) + return out + + +class Native: + """Independent bounded monomial tables and direct Gaussian arithmetic.""" + + def __init__(self, bound): + self.bound = bound + self.plans = {} + + def plan(self, record): + key = canonical(record) + if key not in self.plans: + need(len(self.plans) < 2500, "monomial table capacity") + self.plans[key] = wrapper_plan(record) + return self.plans[key] + + def apply(self, values, event, inverse=False): + recipe = self.bound[event] + if not any(value != ZERO for value in values): + return list(values) + first, last = ("left", "right") if inverse else ("right", "left") + out = wrapper(values, self.plan(recipe[first]), inverse) + bits = reversed(range(recipe["rank"])) if inverse else range(recipe["rank"]) + for bit in bits: + out = stage(out, bit, inverse, event) + return wrapper(out, self.plan(recipe[last]), inverse) + + def path(self, values, events, inverse=False): + out = list(values) + for event in reversed(events) if inverse else events: + out = self.apply(out, event, inverse) + return out + + +def exponent_profile(kind): + if kind == "terminal": + return [4] * SIZE + need(kind in ("zero", "rank_one"), "known interval profile") + return [max(4 - (mask & ~1 if kind == "rank_one" else mask).bit_count(), 0) + for mask in range(SIZE)] + + +def is_four_grid(values): + return all(real % 4 == 0 and imag % 4 == 0 for real, imag in values) + + +def core_admits(values, kind): + if not is_four_grid(values): + return False + return kind == "zero" or is_four_grid(stage(values, 0)) + + +def independent_profiles(): + result = {} + for kind in ("zero", "rank_one"): + observed, sharp = [], 0 + for mask in range(SIZE): + power = (1, 0) + for _ in range(mask.bit_count()): + power = multiply(power, PI[1]) + for exponent in range(5): + value = multiply(power, PI[exponent]) + column = [value if address & mask == mask else ZERO for address in range(SIZE)] + if core_admits(column, kind): + observed.append(exponent) + sharp += exponent > 0 + break + else: + raise IndependentError("four-B core generator rejected") + need(observed == exponent_profile(kind), "derived minimal diagonal profile") + result[kind] = {"exponents": observed, "counts": dict(Counter(observed)), + "index_log2": sum(observed), "minimal_basis_checks": SIZE, + "strict_preceding_exponent_rejections": sharp} + need(result["zero"]["index_log2"] == 187, "zero-gap index") + need(result["rank_one"]["index_log2"] == 280, "rank-one-gap index") + result["terminal"] = {"counts": {4: SIZE}, "index_log2": 2048} + profile = Counter({0: 0}) + for kind, multiplicity in (("zero", 32), ("rank_one", 15), ("terminal", 5)): + for exponent, count in result[kind]["counts"].items(): + profile[exponent] += multiplicity * count + need(sum(profile.values()) == 52 * SIZE, "whole-module Gaussian rank") + result["whole"] = {"counts": dict(profile), "index_log2": sum(e * n for e, n in profile.items())} + need(result["whole"]["index_log2"] == 20424, "whole-module exact index") + return result + + +def fixture_coefficients(slot): + return [(((37 * slot + 17 * k + 3 * k.bit_count()) % 11) - 5, + ((19 * slot + 29 * k + 5 * k.bit_count()) % 13) - 6) for k in range(SIZE)] + + +def partial_sum_fixture(slot, index, native): + coefficients = fixture_coefficients(index) + if slot["kind"] == "terminal": + return [(4 * real, 4 * imag) for real, imag in encode(coefficients)] + values = encode([multiply(PI[exponent], value) for exponent, value in + zip(exponent_profile(slot["kind"]), coefficients, strict=True)]) + if slot["kind"] == "rank_one": + record = native.bound[slot["transport_event"]]["right"] + values = wrapper(values, native.plan(record), inverse=True) + return native.path(values, slot["source_path"], inverse=True) + + +def generated_initial(slots, native): + initial, partials = {}, {} + previous = [ZERO] * SIZE + bank = None + for index, slot in enumerate(slots): + if bank != slot["bank"]: + previous, bank = [ZERO] * SIZE, slot["bank"] + partial = partial_sum_fixture(slot, index, native) + need(belongs(partial), "constructed partial sum outside initial B") + initial[slot["source"]] = [sub(new, old) for new, old in zip(partial, previous, strict=True)] + partials[slot["event"]] = partial + previous = partial + for offset, role in enumerate(DIRTY, 52): + initial[role] = encode(fixture_coefficients(offset)) + need(len(initial) == 58 and all(belongs(v) for v in initial.values()), "generated B inputs") + return initial, partials + + +def read_exact_quarter(values, event, source): + for address, value in enumerate(values): + if value[0] % 4 or value[1] % 4: + raise ArithmeticFailure({"kind": "nonintegral_quarter", "event": event, + "source": source, "address": address, "value": value}) + return [(real // 4, imag // 4) for real, imag in values] + + +def replay_cone(initial, word, cone, native): + states = {role: list(values) for role, values in initial.items()} + counts = Counter() + active, first_non_b = [], None + for index in cone: + event = word["program"][index] + op, target = event[:2] + if op == "transport": + counts["native_occurrences"] += 1 + if any(z != ZERO for z in states[target]): + active.append(index) + counts["literal_pair_comparisons"] += native.bound[index]["rank"] * (SIZE // 2) + states[target] = native.apply(states[target], index) + else: + source, coefficient = event[2:4] + counts["additions"] += 1 + if str(coefficient) == "1/4": + increment = read_exact_quarter(states[source], index, source) + counts["quarter_reads"] += 1 + else: + need(coefficient == -1, "initial D-to-Q subtraction") + increment = [(-real, -imag) for real, imag in states[source]] + states[target] = [add(a, b) for a, b in zip(states[target], increment, strict=True)] + if first_non_b is None and not belongs(states[target]): + first_non_b = {"event": index, "bank": target} + cut = {role: states[role] for role in DIRTY} + need(all(belongs(values) for values in cut.values()), "six final-cut B outputs") + return {"initial_sha256": digest(initial), "cut_sha256": digest(cut), + "cut_bank_sha256": {role: digest(values) for role, values in cut.items()}, + "counts": dict(counts), "active_native_events": active, + "first_non_B": first_non_b}, cut + + +def expected_cut(initial, groups, word, cone, native): + result = {} + for group in groups: + total = [ZERO] * SIZE + for read in group["reads"]: + total = [add(a, b) for a, b in zip(total, initial[read["source"]], strict=True)] + quarter = read_exact_quarter(total, None, "complete initial source group") + bank = group["bank"] + value = [add(a, b) for a, b in zip(initial[bank], quarter, strict=True)] + path = [i for i in cone if word["program"][i][:2] == ["transport", bank]] + result[bank] = native.path(value, path) + value = list(initial["Q7"]) + for bank in BANKS: + value = [sub(a, b) for a, b in zip(value, initial[bank], strict=True)] + path = [i for i in cone if word["program"][i][:2] == ["transport", "Q7"]] + result["Q7"] = native.path(value, path) + return result + + +def validate_partial_fixture(partials, slots, native): + for slot in slots: + partial = partials[slot["event"]] + if slot["kind"] == "terminal": + need(all(r % 4 == 0 and i % 4 == 0 for r, i in decode(partial)), "terminal 4B sum") + continue + physical = native.path(partial, slot["source_path"]) + need(is_four_grid(physical), "post-read partial sum grid") + if slot["kind"] == "rank_one": + record = native.bound[slot["transport_event"]] + at_pair = wrapper(physical, native.plan(record["right"])) + need(is_four_grid(at_pair), "right wrapper preserves four grid") + need(is_four_grid(stage(at_pair, 0)), "complete intervening C stage four grid") + return {"checked_partial_sums": len(slots), "actual_source_paths": True} + + +def zero_initial(roles): + return {role: [ZERO] * SIZE for role in roles} + + +def ideal_cancellation_control(slots, native, roles, kind): + slot = min((s for s in slots if s["kind"] == "rank_one"), key=lambda s: s["event"]) + following = next(s for s in slots if s["event"] == slot["next_event"]) + if kind == "quarter": + physical = [(1, 0)] * SIZE + else: + need(kind == "pair", "control kind") + physical = [(-4, 0) if address & 1 else ZERO for address in range(SIZE)] + need(belongs(physical) and is_four_grid(physical), "valid rank-one sharp core witness") + record = native.bound[slot["transport_event"]]["right"] + physical = wrapper(physical, native.plan(record), inverse=True) + first = native.path(physical, slot["source_path"], inverse=True) + initial = zero_initial(roles) + initial[slot["source"]] = first + initial[following["source"]] = [(-real, -imag) for real, imag in first] + need(all(belongs(v) for v in initial.values()), "control initial B admission") + for bank in BANKS: + total = [ZERO] * SIZE + for item in slots: + if item["bank"] == bank: + total = [add(a, b) for a, b in zip(total, initial[item["source"]], strict=True)] + need(all(value == ZERO for value in total), "control ideal final group cancellation") + return initial, slot, following + + +def rejected_control(initial, word, cone, native, expected_kind, expected_event): + try: + replay_cone(initial, word, cone, native) + except ArithmeticFailure as error: + need(error.record["kind"] == expected_kind and error.record["event"] == expected_event, + "control failed at the wrong boundary") + return {"initial_sha256": digest(initial), "first_failure": error.record, + "initial_B": True, "ideal_group_sums_zero": True} + raise IndependentError("nonexact control accepted") + + +def controls(word, cone, roles, slots, native): + quarter, gap, _ = ideal_cancellation_control(slots, native, roles, "quarter") + pair, pair_gap, _ = ideal_cancellation_control(slots, native, roles, "pair") + need(gap["event"] == 1087 and pair_gap["transport_event"] == 1089, "earliest actual interval") + first = rejected_control(quarter, word, cone, native, "nonintegral_quarter", 1087) + second = rejected_control(pair, word, cone, native, "nonintegral_native_pair", 1089) + initial = zero_initial(roles) + initial["Y27"][0], initial["Y26"][0] = (64, 0), (-64, 0) + need(all(belongs(v) for v in initial.values()), "retained paired initial B") + paired, cut = replay_cone(initial, word, cone, native) + need(all(z == ZERO for values in cut.values() for z in values), "paired literal zero cut") + need(paired["first_non_B"] == {"event": 1090, "bank": "D31"}, "retained strict separation") + return {"first_quarter": first, "post_native": second, "known_paired64": paired} + + +def verify_independent(word_path, native_path): + word, bound = source_inputs(word_path, native_path) + cone, roles, groups, slots = extract_cone(word) + native = Native(bound) + profiles = independent_profiles() + initial, partials = generated_initial(slots, native) + validation = validate_partial_fixture(partials, slots, native) + fixture, cut = replay_cone(initial, word, cone, native) + need(cut == expected_cut(initial, groups, word, cone, native), "actual six-bank ideal cut formula") + fixture["full_array_cut_formula_checks"] = len(DIRTY) + need(fixture["counts"]["native_occurrences"] == 200, "generated native occurrence count") + need(fixture["counts"]["quarter_reads"] == 52, "generated quarter count") + return {"status": "PASS_INDEPENDENT_STAGEWISE_ENTRANCE", + "inputs": {"WORD.json": WORD_SHA256, "NATIVE.json.gz": NATIVE_SHA256}, + "scope": "257-event dependency cone; full-word frame binding is structural only", + "cone": {"events": cone, "events_sha256": digest(cone), "count": len(cone), + "initial_count": len(roles), "initial_roles": sorted(roles), + "native_rank_sum": sum(bound[i]["rank"] for i in cone if i in bound)}, + "groups": groups, "slots": slots, "profiles": profiles, + "generated_fixture": {**fixture, **validation}, + "controls": controls(word, cone, roles, slots, native)} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repo", type=Path, default=Path(__file__).resolve().parents[2]) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + inputs = args.repo / "research/p104-rounded-collector/inputs" + result = verify_independent(inputs / "WORD.json", inputs / "NATIVE.json.gz") + rendered = canonical(result) + "\n" + if args.output: + with args.output.open("x", encoding="utf-8") as handle: + handle.write(rendered) + else: + print(rendered, end="") + + +if __name__ == "__main__": + main() diff --git a/research/p104-stagewise-entrance/independent_cost.py b/research/p104-stagewise-entrance/independent_cost.py new file mode 100644 index 0000000000..b30c87bdaa --- /dev/null +++ b/research/p104-stagewise-entrance/independent_cost.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +"""Independent source-only inventory; imports no package or predecessor code. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +""" +import argparse +from collections import Counter +import gzip +import hashlib +import json +from math import comb +from pathlib import Path + + +WORD_SHA = "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50" +NATIVE_SHA = "ab91c78835c3e10cf3b2cb8a5d4e0b7cfc3df1ae5a811298d27842f2193e1e3d" + + +def require(test, label): + if not test: + raise ValueError(label) + + +def cycle_count(wrapper): + rows, offset = wrapper["matrix_rows"], wrapper["offset"] + require(len(rows) == 9 and type(offset) is int and 0 <= offset < 512, + "invalid affine dimensions") + require(all(type(r) is int and 0 <= r < 512 for r in rows), "invalid row") + permutation = [offset ^ sum(((row & x).bit_count() % 2) << j + for j, row in enumerate(rows)) for x in range(512)] + require(len(set(permutation)) == 512, "nonbijective wrapper") + marked = set() + sizes = [] + for x in range(512): + if x in marked: + continue + y, size = x, 0 + while y not in marked: + marked.add(y) + size += 1 + y = permutation[y] + require(y == x, "permutation orbit did not close") + sizes.append(size) + require(sum(sizes) == 512, "orbit partition") + return len(sizes), Counter(sizes) + + +def inverse_phase_counts(wrapper): + require(type(wrapper["phase"]) is int, "phase type") + require(len(wrapper["linear_Z4"]) == len(wrapper["quadratic_rows"]) == 9, + "phase dimensions") + counts = Counter() + for address in range(512): + phase = wrapper["phase"] + for bit in range(9): + if address & (1 << bit): + phase += wrapper["linear_Z4"][bit] + upper = wrapper["quadratic_rows"][bit] & ~((1 << (bit + 1)) - 1) + phase += 2 * (upper & address).bit_count() + # The inverse phase at the permuted address is the negative original + # phase. Bijectivity preserves its histogram over all 512 inputs. + counts[-phase % 4] += 1 + return {str(k): counts[k] for k in range(4)} + + +def audit(root): + inputs = Path(root) / "research/p104-rounded-collector/inputs" + wb, nb = (inputs / "WORD.json").read_bytes(), (inputs / "NATIVE.json.gz").read_bytes() + require(hashlib.sha256(wb).hexdigest() == WORD_SHA, "WORD source hash") + require(hashlib.sha256(nb).hexdigest() == NATIVE_SHA, "NATIVE source hash") + word = json.loads(wb) + program = word["program"] + archive = json.loads(gzip.decompress(nb))["transports"] + by_event = {} + for index, record in enumerate(archive): + for event in record["events"]: + require(event not in by_event, "duplicate native occurrence") + by_event[event] = (index, record) + cut = next(i for i, event in enumerate(program) + if event[0] == "zero" and event[1] == "C") + require(cut == 2025, "first collector cut") + donors = [event[2] for event in program[cut + 1:cut + 6]] + require(donors == ["D31", "D30", "D29", "D28", "D27"], "collector donor order") + occurrences, wrappers, gaps, groups = [], [], [], [] + + def add_wrapper(event, side, purpose, group, position): + index, record = by_event[event] + count, sizes = cycle_count(record["recipe"][side]) + wrappers.append({"event": event, "record": index, "side": side, + "purpose": purpose, "group": group, "position": position, + "cycles": count, "swaps": 512 - count, + "inverse_phase_counts": inverse_phase_counts(record["recipe"][side]), + "cycle_lengths": {str(k): sizes[k] for k in sorted(sizes)}}) + + for donor in donors: + require(word["initial_frames"][donor] == [], "donor not initially empty frame") + reads = [(i, event) for i, event in enumerate(program[:cut]) + if event[0] == "add" and event[1] == donor] + require(all(event[2].startswith("Y") and event[3] == "1/4" + for _, event in reads), "unexpected donor write") + require(len({event[2] for _, event in reads}) == len(reads), "reused group source") + groups.append({"donor": donor, "source_reads": [[i, e[2]] for i, e in reads]}) + for position, (read_event, read) in enumerate(reads[:-1]): + next_event = reads[position + 1][0] + history = [i for i, e in enumerate(program[:read_event]) + if e[0] == "transport" and e[1] == donor] + interval = [i for i in range(read_event + 1, next_event) + if program[i][0] == "transport" and program[i][1] == donor] + require(len(interval) <= 1, "unclassified multi-transport interval") + frame = [] + for i in history: + event = program[i] + require(event[2] == frame, "broken donor frame path") + _, record = by_event[i] + require(record["old"] == event[2] and record["new"] == event[3] + and record["recipe"]["rank"] == event[4], "native binding") + frame = event[3] + require(frame == read[4], "path does not end at quarter frame") + rank = 0 + if interval: + i = interval[0] + event = program[i] + _, record = by_event[i] + require(event[2] == frame and event[3] == reads[position + 1][1][4], + "rank-one interval endpoints") + require(record["old"] == event[2] and record["new"] == event[3] + and record["recipe"]["rank"] == event[4] == 1, + "rank-one interval native binding") + rank = 1 + add_wrapper(i, "right", "inverse extra right wrapper", donor, position) + else: + require(frame == reads[position + 1][1][4], "zero interval endpoints") + gaps.append({"donor": donor, "position": position, "read_event": read_event, + "next_event": next_event, "gap_rank": rank, + "donor_path": history, "gap_transport": interval}) + for i in reversed(history): + event = program[i] + occurrences.append({"event": i, "rank": event[4], + "group": donor, "position": position}) + # Inverse of left*C*right executes left^-1, reversed C^-1, right^-1. + add_wrapper(i, "left", "inverse donor path", donor, position) + add_wrapper(i, "right", "inverse donor path", donor, position) + + profile_hist = Counter() + gap_hist = Counter(g["gap_rank"] for g in gaps) + for mask in range(512): + profile_hist[max(4 - mask.bit_count(), 0)] += gap_hist[0] + profile_hist[max(4 - (mask & ~1).bit_count(), 0)] += gap_hist[1] + profile_hist[4] += len(groups) + exponent = sum(k * count for k, count in profile_hist.items()) + rank_mass = sum(e["rank"] for e in occurrences) + pairs = rank_mass * 256 + newton_pairs = 52 * 9 * 256 + diagonal_pi_steps = exponent - len(groups) * 512 * 4 + gaussian_terminal_doublings = len(groups) * 512 * 2 + add_real = 8 * pairs + 4 * newton_pairs + 2 * diagonal_pi_steps + 2 * 47 * 512 + phases = {str(k): sum(w["inverse_phase_counts"][str(k)] for w in wrappers) for k in range(4)} + total_swaps = sum(w["swaps"] for w in wrappers) + quarter_rotations = phases["1"] + phases["3"] + pairs + pi_l1 = lambda exponent: 1 << ((exponent + 1) // 2) + gains = {"zero": sum(comb(9, d) * pi_l1(max(4, d)) for d in range(10)), + "rank_one": sum(comb(8, d) * (pi_l1(max(4, d)) + + pi_l1(max(4, d) + 1)) for d in range(9)), + "terminal": 4 * sum(comb(9, d) * pi_l1(d) for d in range(10))} + result = { + "status": "PASS", "method": "Independent direct JSON/gzip source scan; no package imports", + "source_hashes": {"WORD.json": WORD_SHA, "NATIVE.json.gz": NATIVE_SHA}, + "cut": cut, "groups": groups, "gaps": gaps, + "gap_counts": {str(k): gap_hist[k] for k in sorted(gap_hist)}, + "inverse_donor_native_occurrences": len(occurrences), "rank_mass": rank_mass, + "inverse_donor_occurrence_rows": occurrences, "pair_applications": pairs, + "wrapper_occurrences": len(wrappers), "wrapper_cycles": sum(w["cycles"] for w in wrappers), + "wrapper_swaps": sum(w["swaps"] for w in wrappers), + "wrapper_groups": {kind: {"occurrences": sum(w["purpose"] == kind for w in wrappers), + "cycles": sum(w["cycles"] for w in wrappers if w["purpose"] == kind), + "swaps": sum(w["swaps"] for w in wrappers if w["purpose"] == kind)} + for kind in ("inverse donor path", "inverse extra right wrapper")}, + "wrapper_rows": wrappers, "wrapper_phase_applications": 512 * len(wrappers), + "encoder_inverse_wrapper_phase_histogram": phases, + "decoder_forward_wrapper_phase_histogram": {str(k): phases[str(-k % 4)] for k in range(4)}, + "quotient_exponent_histogram": {str(k): profile_hist[k] for k in sorted(profile_hist)}, + "index_log2": exponent, "ideal_index_log2": 5 * 512 * 4, + "strong_4B52_index_log2": 52 * 512 * 4, + "encode": {"newton_tensor_pairs": newton_pairs, + "extra_diagonal_pi_multiplications": diagonal_pi_steps, + "terminal_gaussian_doublings": gaussian_terminal_doublings, + "bank_differences": 47, + "real_add_sub_excluding_doublings": add_real, + "real_doublings": 2 * gaussian_terminal_doublings, + "real_add_sub_if_doubling_is_add": add_real + 2 * gaussian_terminal_doublings, + "native_real_floor_halvings": 4 * pairs}, + "optional_fully_lowered_real_arithmetic": { + "gaussian_swap_real_adds": 6 * total_swaps, + "phase_and_native_quarter_turn_component_swaps": quarter_rotations, + "component_swap_real_adds": 3 * quarter_rotations, + "explicit_real_negations": 2 * phases["2"] + quarter_rotations, + "encode_real_add_sub_excluding_doublings": add_real + 6 * total_swaps + 3 * quarter_rotations, + "encode_real_add_sub_including_doublings": add_real + 6 * total_swaps + 3 * quarter_rotations + + 2 * gaussian_terminal_doublings, + "model": "Gaussian payload SWAP=6 real add/sub; real-component SWAP=3 add/sub; each +/-i has one negation, each -1 two; no extra clean swap ancilla; source-minus-target overwrite is permitted, so this is not the strict target-ADD tariff."}, + "decode": {"real_add_sub": add_real, + "native_real_floor_halvings": 4 * pairs, + "codec_exact_real_halvings": 2 * (newton_pairs + diagonal_pi_steps) + + 2 * gaussian_terminal_doublings, + "bank_sums": 47}, + "height": {"coefficient_to_local_value_row_gains": gains, + "inverse_path_payload_factor": 32 * max(gains["zero"], gains["rank_one"]), + "bank_difference_factor": 64 * max(gains["zero"], gains["rank_one"]), + "terminal_difference_factor": gains["terminal"] + + 32 * max(gains["zero"], gains["rank_one"]), + "pair_work_factor": 160 * max(gains["zero"], gains["rank_one"])}, + "limits": ["Mutable in-place coefficient banks; functional Python allocation is not priced.", + "Swaps and Gaussian phase applications remain separately listed primitives.", + "Counts do not price an arbitrary caller, borrowed copies, all physical routing/control or recursive bill.", + "A codec inverse is proved only on its image; this does not admit an intervening consumer.", + "Preparation arithmetic does not prove all omitted original-prefix events exact."]} + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[2]) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + result = audit(args.root) + if args.output: + with args.output.open("x", encoding="utf-8") as handle: + handle.write(json.dumps(result, sort_keys=True, indent=2) + "\n") + print(json.dumps({key: result[key] for key in + ("status", "index_log2", "rank_mass", "wrapper_swaps", "encode", "decode")}, + sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-stagewise-entrance/source.py b/research/p104-stagewise-entrance/source.py new file mode 100644 index 0000000000..2e6a5116db --- /dev/null +++ b/research/p104-stagewise-entrance/source.py @@ -0,0 +1,269 @@ +"""Authenticated structure and exact execution of the first P104 producer cone. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +The frozen word, native recipes and Gaussian model retain their named authors. +Only the selected dependency cone is executed, not the omitted prefix events. +""" + +import gzip +import hashlib +import json +from collections import Counter +from fractions import Fraction +from pathlib import Path +from types import ModuleType + + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +SIZE = 512 +CUT = 2025 +D_BANKS = ("D31", "D30", "D29", "D28", "D27") +TARGETS = D_BANKS + ("Q7",) +YS = tuple("Y" + str(j) for j in list(range(22, 33)) + list(range(63, 104))) +SOURCE_HASHES = { + "word": "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50", + "native": "ab91c78835c3e10cf3b2cb8a5d4e0b7cfc3df1ae5a811298d27842f2193e1e3d", + "model": "74c83367887dd885137b222155c86389fe0be9f1293a6f0e5fdb51d71f435fdd", +} + + +class SourceError(ValueError): + """A source binding, execution or finite-domain condition failed.""" + + +def require(condition, message): + if not condition: + raise SourceError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def read_pinned(path, label): + path = Path(path) + require(path.is_file() and not path.is_symlink(), "regular input required: " + label) + with path.open("rb") as handle: + data = handle.read(32 * 1024 * 1024 + 1) + require(len(data) <= 32 * 1024 * 1024, "bounded source size") + require(hashlib.sha256(data).hexdigest() == SOURCE_HASHES[label], + "source digest mismatch: " + label) + return data + + +def load_inputs(root=ROOT): + root = Path(root) + word = json.loads(read_pinned(root / "research/p104-rounded-collector/inputs/WORD.json", "word")) + raw_native = read_pinned(root / "research/p104-rounded-collector/inputs/NATIVE.json.gz", "native") + native = json.loads(gzip.decompress(raw_native)) + model_path = PACKAGE / "inputs/pr3382_model.py" + model_bytes = read_pinned(model_path, "model") + model = ModuleType("p104_pinned_newton_model") + exec(compile(model_bytes, str(model_path), "exec"), model.__dict__) + return word, native, model + + +def occurrence_map(native): + result = {} + for item in native["transports"]: + for event in item["events"]: + require(type(event) is int and event not in result, "unique native occurrence") + result[event] = item + require(len(native["transports"]) == 1245 and len(result) == 2070, + "frozen native archive dimensions") + return result + + +def structure(word, native): + program = word["program"] + require(len(program) == 5398, "frozen word length") + needed = set(TARGETS) + selected = [] + for event in reversed(range(CUT)): + record = program[event] + if record[1] in needed: + require(record[0] in ("transport", "add"), "producer opcode") + selected.append(event) + if record[0] == "add": + needed.add(record[2]) + selected.reverse() + require(needed == set(TARGETS) | set(YS), "exact initial dependencies") + require(len(selected) == 257, "exact producer event count") + require(Counter(program[e][0] for e in selected) == {"transport": 200, "add": 57}, + "producer event profile") + require(all(word["initial_frames"][name] == [] for name in needed), "empty initial frames") + occurrences = occurrence_map(native) + frames = {name: [] for name in needed} + paths = {name: [] for name in needed} + groups = {name: [] for name in D_BANKS} + q_reads = [] + rank_mass = 0 + for event in selected: + record = program[event] + opcode, bank = record[:2] + if opcode == "transport": + old, new, rank = record[2:] + item = occurrences[event] + require((item["old"], item["new"], item["recipe"]["rank"]) == + (old, new, rank), "native old/new/rank binding") + require(frames[bank] == old, "actual transport frame chronology") + frames[bank] = new[:] + paths[bank].append(event) + rank_mass += rank + else: + source, coefficient, frame = record[2:] + require(frames[bank] == frames[source] == frame, "common ADD frame") + coefficient = Fraction(str(coefficient)) + if bank == "Q7": + require(source in D_BANKS and coefficient == -1 and not groups[source], + "Q reads only initial dirty D before quarters") + q_reads.append([event, source]) + else: + require(bank in D_BANKS and source in YS and coefficient == Fraction(1, 4), + "positive quarter into D") + groups[bank].append({ + "bank": bank, "source": source, "event": event, + "frame": frames[bank][:], "path_to_read": paths[bank][:], + "source_path_to_read": paths[source][:], + }) + require(rank_mass == 354, "producer native rank mass") + require(sorted(source for _, source in q_reads) == sorted(D_BANKS), "five dirty Q reads") + require([len(groups[d]) for d in D_BANKS] == [3, 7, 7, 11, 24], "source group sizes") + require(sorted(g["source"] for rows in groups.values() for g in rows) == sorted(YS), + "disjoint source groups exhaust52 Y") + gaps = [] + for bank in D_BANKS: + rows = groups[bank] + for index, row in enumerate(rows): + gap = dict(row) + if index + 1 == len(rows): + gap.update(kind="terminal", next_event=None, transport_event=None) + else: + next_event = rows[index + 1]["event"] + between = [e for e in selected if row["event"] < e < next_event + and program[e][1] == bank] + require(all(program[e][0] == "transport" for e in between), "pure read gap") + require(len(between) <= 1, "at most one native in each nonterminal gap") + if between: + require(program[between[0]][4] == 1, "one rank-one native per nonempty gap") + gap.update(kind="rank_one" if between else "zero", next_event=next_event, + transport_event=between[0] if between else None) + gaps.append(gap) + require(Counter(g["kind"] for g in gaps) == {"zero": 32, "rank_one": 15, "terminal": 5}, + "complete interval profile") + return { + "selected": selected, "dependencies": sorted(needed), "groups": groups, "gaps": gaps, + "q_reads": q_reads, "cut_frames": {name: frames[name] for name in TARGETS}, + "cut_paths": {name: paths[name] for name in TARGETS}, + "native_count": 200, "native_rank_mass": rank_mass, + } + + +def native_plans(word, native, selected, model): + occurrences = occurrence_map(native) + plans = {} + for event in selected: + record = word["program"][event] + if record[0] != "transport": + continue + item = occurrences[event] + require((item["old"], item["new"], item["recipe"]["rank"]) == + (record[2], record[3], record[4]), "recipe binding") + recipe = item["recipe"] + plans[event] = {"rank": recipe["rank"], + "left": model.wrapper_plan(recipe["left"]), + "right": model.wrapper_plan(recipe["right"])} + return plans + + +def apply_wrapper(values, plan, model, inverse=False): + require(len(values) == len(plan) == SIZE, "wrapper dimensions") + out = [(0, 0)] * SIZE + for source, (target, phase) in enumerate(plan): + if inverse: + out[source] = model.rot(values[target], -phase) + else: + out[target] = model.rot(values[source], phase) + return out + + +def apply_native(values, event, plans, model, inverse=False, literal=False): + plan = plans[event] + out = apply_wrapper(values, plan["left" if inverse else "right"], model, inverse) + bits = range(plan["rank"] - 1, -1, -1) if inverse else range(plan["rank"]) + for bit in bits: + out = model.stage(out, bit, inverse=inverse, literal=literal) + return apply_wrapper(out, plan["right" if inverse else "left"], model, inverse) + + +def apply_path(values, path, plans, model, inverse=False): + out = values[:] + for event in reversed(path) if inverse else path: + out = apply_native(out, event, plans, model, inverse=inverse) + return out + + +def trace_cone(word, structure_record, plans, model, initial): + require(set(initial) == set(structure_record["dependencies"]), "initial execution roles") + require(all(model.member(value) for value in initial.values()), "initial execution B domain") + state = {name: values[:] for name, values in initial.items()} + pairs = 0 + max_component = max(abs(x) for values in state.values() for value in values for x in value) + first_non_b = None + for event in structure_record["selected"]: + record = word["program"][event] + opcode, bank = record[:2] + if opcode == "transport": + plan = plans[event] + out = apply_wrapper(state[bank], plan["right"], model) + for bit in range(plan["rank"]): + step = 1 << bit + for address in range(SIZE): + if address & step: + continue + other = address | step + a, b = out[address], out[other] + numerators = model.ideal_pair_numerators(a, b) + if any(x % 2 for value in numerators for x in value): + return {"ok": False, "failure": {"event": event, "bank": bank, + "kind": "nonintegral_ideal_pair", "bit": bit, + "address": address, "inputs": [a, b], + "twice_ideal": numerators}, "pairs_checked": pairs} + ideal = tuple((a // 2, b // 2) for a, b in numerators) + actual = model.lift_pair(a, b) + require(actual == ideal, "signed-floor versus ideal pair equality") + out[address], out[other] = actual + pairs += 1 + state[bank] = apply_wrapper(out, plan["left"], model) + else: + source, coefficient = record[2:4] + factor = Fraction(str(coefficient)) + p, q = factor.numerator, factor.denominator + values = state[source] + bad = next(((j, component, x) for j, value in enumerate(values) + for component, x in enumerate(value) if p * x % q), None) + if bad is not None: + return {"ok": False, "failure": {"event": event, "bank": bank, + "source": source, "kind": "nonintegral_fractional_add", + "coordinate": bad[0], "component": bad[1], "value": bad[2], + "numerator": p, "denominator": q}, "pairs_checked": pairs} + state[bank] = [model.add(a, (p * b[0] // q, p * b[1] // q)) + for a, b in zip(state[bank], values)] + max_component = max(max_component, *(abs(x) for value in state[bank] for x in value)) + if first_non_b is None and not model.member(state[bank]): + first_non_b = {"event": event, "bank": bank} + cut = {name: state[name] for name in TARGETS} + return {"ok": True, "pairs_checked": pairs, "first_non_b": first_non_b, + "max_state_component": max_component, "cut_sha256": digest(cut), + "cut_in_b": {name: model.member(value) for name, value in cut.items()}, "cut": cut} + + +def coefficient_fixture(slot): + require(type(slot) is int and 0 <= slot < 58, "fixture slot") + return [(((37 * slot + 17 * k + 3 * k.bit_count()) % 11) - 5, + ((19 * slot + 29 * k + 5 * k.bit_count()) % 13) - 6) for k in range(SIZE)] diff --git a/research/p104-stagewise-entrance/verify.py b/research/p104-stagewise-entrance/verify.py new file mode 100644 index 0000000000..ac78d4d95b --- /dev/null +++ b/research/p104-stagewise-entrance/verify.py @@ -0,0 +1,289 @@ +#!/usr/bin/env python3 +"""Bounded, Git-free replay of the exact correlated producer entrance. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +The independent evaluator imports neither this implementation nor a predecessor. +""" + +import argparse +import hashlib +import json +from pathlib import Path +import tempfile +from types import ModuleType + + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False).encode() + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def json_bytes(data): + def object_pairs(items): + result = {} + for key, value in items: + require(key not in result, "duplicate JSON key") + result[key] = value + return result + def forbidden(value): + raise ValueError("noninteger JSON number: " + value) + return json.loads(data, object_pairs_hook=object_pairs, + parse_float=forbidden, parse_constant=forbidden) + + +def read_file(path, limit=4 * 1024 * 1024): + path = Path(path) + require(path.is_file() and not path.is_symlink(), "regular file required: " + path.name) + with path.open("rb") as handle: + data = handle.read(limit + 1) + require(len(data) <= limit, "file capacity: " + path.name) + return data + + +def module(name): + path = PACKAGE / (name + ".py") + captured = read_file(path) + result = ModuleType("p104_stagewise_" + name) + result.__file__ = str(path) + exec(compile(captured, str(path), "exec"), result.__dict__) + return result, hashlib.sha256(captured).hexdigest() + + +def authenticate_sources(root): + sources = json_bytes(read_file(PACKAGE / "SOURCES.json")) + checks = [(root / row["path"], row) for row in sources["files"] if row["usage"] == "input"] + checks += [(PACKAGE / row["path"], row) for row in sources["retained_sources"]] + result = {} + for path, row in checks: + data = read_file(path) + actual = hashlib.sha256(data).hexdigest() + require(actual == row["sha256"] and len(data) == row["bytes"], + "runtime/provenance source mismatch: " + row["path"]) + result[row["path"]] = actual + return result + + +def typed_equal(actual, expected, path="receipt"): + require(type(actual) is type(expected), "typed receipt mismatch at " + path) + if type(expected) is dict: + require(set(actual) == set(expected), "receipt key mismatch at " + path) + for key in expected: + typed_equal(actual[key], expected[key], path + "." + key) + elif type(expected) is list: + require(len(actual) == len(expected), "receipt length mismatch at " + path) + for index, (left, right) in enumerate(zip(actual, expected)): + typed_equal(left, right, path + "[" + str(index) + "]") + else: + require(actual == expected, "receipt value mismatch at " + path) + + +def profile_comparison(classifier, independent_result): + profiles = {kind: classifier.profile(kind) for kind in ("zero", "rank_one", "terminal")} + aggregate = {str(k): 0 for k in range(5)} + for kind, count in (("zero", 32), ("rank_one", 15), ("terminal", 5)): + primary, other = profiles[kind], independent_result["profiles"][kind] + require(primary["pi_index_exponent"] == other["index_log2"], "independent local index") + if kind != "terminal": + require(primary["exponents"] == other["exponents"], "independent local profile") + for exponent, multiplicity in primary["exponent_histogram"].items(): + aggregate[exponent] += count * multiplicity + require(aggregate == {str(k): v for k, v in independent_result["profiles"]["whole"]["counts"].items()}, + "independent full Gaussian quotient") + total = sum(int(k) * v for k, v in aggregate.items()) + require(total == 20424, "exact total index") + return {"local": profiles, "whole_exponent_histogram": aggregate, + "whole_index_log2": total, "ideal_final_only_index_log2": 10240, + "additional_stagewise_index_log2": total - 10240, + "strong_independent_4B_index_log2": 52 * 512 * 4} + + +def structure_comparison(structure, other): + require(structure["selected"] == other["cone"]["events"], "independent exact event slice") + require(structure["dependencies"] == other["cone"]["initial_roles"], "independent initial roles") + keys = ("bank", "source", "event", "next_event", "kind", "transport_event", "frame") + require(len(structure["gaps"]) == len(other["slots"]) == 52, "exact partial-sum slots") + for left, right in zip(structure["gaps"], other["slots"]): + require(all(left[k] == right[k] for k in keys), "independent gap boundary") + require(left["source_path_to_read"] == right["source_path"], "independent source path") + + +def dense_check(word, structure, plans, model, source, classifier, admission, other): + initial = admission.dense_fixture(structure, plans, model, source, classifier) + trace = source.trace_cone(word, structure, plans, model, initial) + require(trace["ok"] and all(trace["cut_in_b"].values()), "dense exact literal admitted cut") + expected = admission.expected_cut(initial, structure, plans, model, source) + require(trace["cut"] == expected, "all six full-array cut equations") + independent = other["generated_fixture"] + require(digest(initial) == independent["initial_sha256"], "independent Y-path/D-path construction") + require(trace["cut_sha256"] == independent["cut_sha256"], "independent full dense cut") + require(trace["pairs_checked"] == independent["counts"]["literal_pair_comparisons"] == 90624, + "all native pairs active in dense fixture") + require(trace["first_non_b"] == independent["first_non_B"], "independent non-B stage") + return {"initial_sha256": digest(initial), "initial_bank_sha256": {k: digest(v) for k, v in initial.items()}, + **{k: v for k, v in trace.items() if k != "cut"}, + "full_array_cut_equations_checked": 6, "actual_path_codec_roundtrips": 52} + + +def control_check(word, structure, plans, model, source, classifier, admission, other): + result = {} + for name, initial in admission.control_initials(structure, plans, model, source).items(): + for rows in structure["groups"].values(): + total = [(0, 0)] * 512 + for row in rows: + total = [model.add(a, b) for a, b in zip(total, initial[row["source"]])] + require(all(v == (0, 0) for v in total), "control ideal group sum zero") + admitted = True + try: + admission.decode_sources(structure, plans, model, source, classifier, + {y: initial[y] for y in source.YS}) + except classifier.OutsideProfile: + admitted = False + trace = source.trace_cone(word, structure, plans, model, initial) + require(admitted == trace["ok"] == (name == "paired64"), "control exact admission decision") + key = {"quarter": "first_quarter", "native": "post_native", "paired64": "known_paired64"}[name] + independent = other["controls"][key] + require(digest(initial) == independent["initial_sha256"], "independent control source construction") + if name == "paired64": + require(trace["cut_sha256"] == independent["cut_sha256"], "paired literal endpoint") + require(all(z == (0, 0) for v in trace["cut"].values() for z in v), "paired zero cut") + else: + require(trace["failure"]["event"] == independent["first_failure"]["event"], + "independent first failure") + expected = {"quarter": ("nonintegral_fractional_add", "nonintegral_quarter"), + "native": ("nonintegral_ideal_pair", "nonintegral_native_pair")}[name] + require((trace["failure"]["kind"], independent["first_failure"]["kind"]) == expected, + "independent failure kind") + result[name] = {"initial_sha256": digest(initial), "ideal_group_sums_zero": True, + "profile_admitted": admitted, **{k: v for k, v in trace.items() if k != "cut"}} + return result + + +def rejection_checks(source, classifier, result): + checks = [] + for raw in (b'{"x":1,"x":2}', b'{"x":NaN}', b'{"x":1.0}'): + try: + json_bytes(raw) + except ValueError: + checks.append("strict_json") + else: + raise ValueError("malformed JSON accepted") + wrong = json_bytes(canonical(result)) + wrong["profiles"]["local"]["zero"]["exponent_histogram"]["4"] = True + try: + typed_equal(wrong, result) + except ValueError: + checks.append("boolean_is_not_integer_one") + else: + raise ValueError("Boolean receipt accepted") + for kind in ("zero", "rank_one", "terminal"): + try: + classifier.decode_profile([(1, 0)] * 512, kind) + except classifier.OutsideProfile: + checks.append("outside_" + kind) + else: + raise ValueError("nondivisible profile accepted") + with tempfile.TemporaryDirectory(prefix="p104-stagewise-source-reject-") as temporary: + path = Path(temporary) / "WORD.json" + path.write_bytes(b'{"not":"the frozen word"}\n') + try: + source.read_pinned(path, "word") + except source.SourceError: + checks.append("corrupt_scientific_source") + else: + raise ValueError("corrupt source accepted") + return checks + + +def cost_comparison(primary, other): + require(other["status"] == "PASS", "independent cost status") + inventory = primary["path_inventory"] + for ours, theirs in (("native_occurrence_count", "inverse_donor_native_occurrences"), + ("native_rank_mass", "rank_mass"), ("wrapper_count", "wrapper_occurrences"), + ("wrapper_cycle_sum", "wrapper_cycles"), ("gaussian_payload_swaps", "wrapper_swaps")): + require(inventory[ours] == other[theirs], "independent cost inventory: " + ours) + require(inventory["inverse_wrapper_phase_histogram"] == other["encoder_inverse_wrapper_phase_histogram"], + "independent actual phase histogram") + require(primary["forward"]["real_add_subtracts_before_swap_phase_lowering"] + == other["encode"]["real_add_sub_if_doubling_is_add"], "independent forward arithmetic") + require(primary["reverse"]["real_add_subtracts_before_swap_phase_lowering"] + == other["decode"]["real_add_sub"], "independent inverse arithmetic") + require(primary["reverse"]["real_halves"] == other["decode"]["native_real_floor_halvings"] + + other["decode"]["codec_exact_real_halvings"], "independent exact/floor halves") + lowered = other["optional_fully_lowered_real_arithmetic"] + require(primary["forward"]["real_add_subtracts_with_swaps_and_negations"] == + lowered["encode_real_add_sub_including_doublings"] + lowered["explicit_real_negations"], + "independent optional component-arithmetic lowering") + require(primary["width_bounds"]["encoder_work_component_gain"] == other["height"]["pair_work_factor"], + "independent conservative encoder width") + + +def build(root=ROOT): + root = Path(root) + before = authenticate_sources(root) + names = ("source", "classifier", "admission", "costs", "independent", "independent_cost") + loaded = [module(name) for name in names] + source, classifier, admission, costs, independent, independent_cost = [item[0] for item in loaded] + code_hashes = {name + ".py": item[1] for name, item in zip(names, loaded)} + code_hashes["verify.py"] = hashlib.sha256(read_file(PACKAGE / "verify.py")).hexdigest() + word, native, model = source.load_inputs(root) + structure = source.structure(word, native) + plans = source.native_plans(word, native, structure["selected"], model) + scientific = root / "research/p104-rounded-collector/inputs" + other = independent.verify_independent(scientific / "WORD.json", scientific / "NATIVE.json.gz") + require(other["status"] == "PASS_INDEPENDENT_STAGEWISE_ENTRANCE", "independent success status") + structure_comparison(structure, other) + profiles = profile_comparison(classifier, other) + invoice = costs.invoice(structure, plans, classifier) + cost_audit = independent_cost.audit(root) + cost_comparison(invoice, cost_audit) + result = {"schema_version": 1, "result": "PASS_EXACT_STAGEWISE_ENTRANCE", + "scope": "Exact literal-equals-ideal257-event producer cone and six admitted outputs, not arbitrary rounded paths or the whole prefix", + "source_sha256": before, "implementation_sha256": code_hashes, + "structure": structure, "profiles": profiles, + "dense_fixture": dense_check(word, structure, plans, model, source, classifier, admission, other), + "controls": control_check(word, structure, plans, model, source, classifier, admission, other), + "logical_codec_invoice": invoice, "independent_cost": cost_audit, + "independent": other} + result = json_bytes(canonical(result)) + result["rejection_checks"] = rejection_checks(source, classifier, result) + require(authenticate_sources(root) == before, "source inputs changed during replay") + require({name: hashlib.sha256(read_file(PACKAGE / name)).hexdigest() for name in code_hashes} + == code_hashes, "executed source files changed during replay") + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--root", type=Path, default=ROOT) + mode = parser.add_mutually_exclusive_group() + mode.add_argument("--receipt", type=Path, default=PACKAGE / "RECEIPT.json") + mode.add_argument("--write-receipt", type=Path) + args = parser.parse_args() + try: + result = build(args.root) + if args.write_receipt: + with args.write_receipt.open("xb") as handle: + handle.write(json.dumps(result, sort_keys=True, indent=2).encode() + b"\n") + else: + typed_equal(json_bytes(read_file(args.receipt)), result) + print(json.dumps({"result": result["result"], "gaussian_index_log2": 20424, + "literal_pairs": 90624, "dense_cut_sha256": result["dense_fixture"]["cut_sha256"], + "receipt_scientific_sha256": digest(result)}, sort_keys=True)) + except (OSError, ValueError, KeyError, TypeError) as error: + parser.exit(1, "FAIL_STAGEWISE_ENTRANCE: " + str(error) + "\n") + + +if __name__ == "__main__": + main()