From 803f3593e8f00ed8591d5ff6fc69ce2a036a3293 Mon Sep 17 00:00:00 2001 From: commdata2338 <199849969+commdata2338@users.noreply.github.com> Date: Sat, 17 Oct 2026 13:47:18 -0500 Subject: [PATCH] Research: exact scratch capacity and a complete linear tape bill for PR #2915's ordered high-field ADD Answers the ordered-ADD component of PR #2982's single-cube handoff for the unchanged PR #2915 kernels.added and its pooled stream.add_pass. For odd Q>=3, canonical positive B,M,S and c in {-4,-2,-1,1,2,4}, with V=BQMQS: exactly 10+[S>1] additional scratch roles suffice and are attained in every call, sharpening PR #2809's conservative 32-role lexical allowance; six additional numerical words suffice and one fixture attains six (PR #2810's add_pass bound composed with the actual coefficient callback); and the complete local physical read/write/ unit-move bill, including encoded arithmetic and pool acquisitions, is at most 4096V, or 4102V with returned-output disposal. The exact non-arithmetic invoice extends PR #2877's and PR #2473's countdown and payload bills, zero case included, with pool acquisitions, the one-bit-suffix path and the marginal lifecycles. It matches the unchanged source on 109 complete packets (37,241 payload bits), and one fewer scratch role or numerical slot rejects at the real allocators. Route setup, B1 swaps, machine steps, physical backing and whole-stage stock remain open; no supplier, selected-frontier or kappa change is claimed. Adds research/high-add-scratch-invoice/ only. Submitted by @commdata2338 with substantial AI assistance (OpenAI Codex research and implementation; packaged with Claude Code). Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01X86sCSXdoDd61SDFfC1PKG --- research/high-add-scratch-invoice/PROOF.md | 311 + research/high-add-scratch-invoice/README.md | 115 + research/high-add-scratch-invoice/RESULT.json | 6449 +++++++++++++++++ .../high-add-scratch-invoice/SOURCES.json | 156 + research/high-add-scratch-invoice/TASK.json | 156 + research/high-add-scratch-invoice/VERIFY.json | 55 + research/high-add-scratch-invoice/invoice.py | 53 + research/high-add-scratch-invoice/runtime.py | 197 + .../high-add-scratch-invoice/test_verify.py | 125 + research/high-add-scratch-invoice/verify.py | 200 + 10 files changed, 7817 insertions(+) create mode 100644 research/high-add-scratch-invoice/PROOF.md create mode 100644 research/high-add-scratch-invoice/README.md create mode 100644 research/high-add-scratch-invoice/RESULT.json create mode 100644 research/high-add-scratch-invoice/SOURCES.json create mode 100644 research/high-add-scratch-invoice/TASK.json create mode 100644 research/high-add-scratch-invoice/VERIFY.json create mode 100644 research/high-add-scratch-invoice/invoice.py create mode 100644 research/high-add-scratch-invoice/runtime.py create mode 100644 research/high-add-scratch-invoice/test_verify.py create mode 100644 research/high-add-scratch-invoice/verify.py diff --git a/research/high-add-scratch-invoice/PROOF.md b/research/high-add-scratch-invoice/PROOF.md new file mode 100644 index 0000000000..5b1c722971 --- /dev/null +++ b/research/high-add-scratch-invoice/PROOF.md @@ -0,0 +1,311 @@ +# Ordered high-field ADD: local reserve and physical I/O + +This is a source-level cost and lifetime proof for the **unchanged** +`kernels.added` in Jose Manuel/jmbarrancoml's PR2915, including its actual +PR2809 `ScratchPool.install` specialization and retained `stream.add_pass`. +It answers the ordered-ADD part of Nick Petalas's PR2982 handoff. It does not +complete that handoff's single-cube setup, sign/translation composition or B1 +swaps, and it does not derive a whole bootstrap-stage stock coefficient. + +## Domain and boundary + +Let Q >= 3 be odd, B,M,S >= 1 be integers, and c belong to +{-4,-2,-1,1,2,4}. Here M is the middle spectator multiplicity, **not** the +modulus. Set + +``` +b = bit_length(Q)+1, +l_X = bit_length(X), +V = B Q M Q S. +``` + +The source contains one complete Boolean packet ordered as (prefix,x,middle,y, +suffix). Its action is y -> y+c*x mod Q. B,M,S arrive as canonical Count +encodings; the three marginal copies have exactly one extra high zero. +The initialized Ring has modulus Q, its one word, and the minimal b-digit +template. All borrowed heads begin at their origins. Distinct payload, +numerical and count roles obey the retained ownership contract; any already +occupied pool roles and numerical slots remain charged to the caller. +The source and contexts are read-only, and the output is a distinct owned +dense V-bit stream with its head restored. Dirty entry roles are preserved. + +Count physical Tape reads, writes and unit moves once, including operations +through PhysicalWord and Lease aliases. One acquisition costs the pool's +actual blank read. Finite-control selection, initial marker/template +provisioning, installation/compilation and permanent inventories are outside +this local I/O currency. These are not machine-step constants. Counted +initialization is the allocation and initialization **inside** `added`, not +the enclosing high-bank setup. Successful return is the boundary; arbitrary +interrupted-macro recovery is not claimed. + +For each fixed prefix, x and middle coordinate, the first traversal splits +the Q suffix blocks after Q-offset, with offset=c*x mod Q. The second +traversal writes the trailing offset blocks followed by the leading blocks. +This rotates their y address by offset, preserving each suffix block's bit +order. Both traversals use the same prefix/x/middle nesting, so no spectator +coordinate moves. Only head movements touch the borrowed input and Counts; +their rewinds restore the entry heads. + +The numerical margin suffices: residues are below Q<2^(b-1), a modular sum +is below 2Q<2^b, and Q-offset is between 1 and Q. The fixed literal is at +most four and fits b>=3 digits. Binary division keeps remainder below Q +before each shift. These inequalities discharge the arithmetic width checks; +the reserve proof below discharges the local allocation checks. + +## Scratch and numerical capacity + +The three marginal Counts persist throughout the call. `add_pass` then owns +left, right and output. Inside either traversal the maximum live chain is: + +| Roles | Count | +|---|---:| +| Marginal Counts | 3 | +| Left, right, output payloads | 3 | +| Outer, source-coordinate and middle countdowns | 3 | +| Split-block countdown | 1 | +| Suffix-bit countdown, when S > 1 | 1 | + +`copy_blocks` closes its block/bit countdowns before returning. Each middle, +source-coordinate and outer countdown closes before its next instance. +Marginal construction allocates one stream per result, with no hidden +stream temporary. Word arithmetic uses the separate numerical bank. +Consequently exactly **10+[S>1] free scratch roles** suffice, independent of +Q,B,M and the coefficient. This is a bound on every allocation prefix, so it +excludes a first scratch-capacity failure when other source conditions hold. + +The leading split has Q-offset > 0 at every x. Hence the nested block +countdown, and for S>1 its bit countdown, really occur while all earlier +listed roles remain allocated. Thus the bound is attained in every call in +this domain, not merely in the saved examples. All scratch leases except +the one output close before return. Clearing that output releases the last +new lease; entry leases survive. + +At numerical coefficient preparation, the literal, division scan, quotient, +remainder and new shifted/subtracted remainder need at most five new slots. +The old remainder is freed before the subtraction result is allocated. +After preparation only the coefficient persists. Each outer iteration adds x. +`Ring.multiply` needs at most four further slots: scan, old accumulator, +new addition total and its conditional modular-reduction output. They are +reused, not accumulated over the bit scan. The following leading-count +subtraction needs only offset and leading beside coefficient and x. +Thus **six free numerical slots above all entry residents** suffice at every +allocation prefix. This includes both pending and completed results. +Outside the coefficient callback this is Ross Richardson's PR2810 bound for +the same `stream.add_pass` source; the callback's at most five slots compose +with it by maximum, as PR2810 states. The +Q=3,c=-4,B=M=S=1 fixture attains six; one fewer rejects at the real allocator. +The input modulus and Ring.one, and any additional caller residents, are +entry resources, not part of those six. + +A useful occupied-content corollary, excluding LEFT markers and every entry +resource, is + +``` +additional occupied symbols <= 2V + 2(l_B+l_M+l_S) + 8b + 20. +``` + +Left+right together contain at most V bits and output at most V. The three +marginals occupy l_B+l_M+l_S+6 symbols, including RIGHT. The five possible +countdowns occupy at most (l_B+2)+(b+1)+(l_M+2)+(b+1)+(l_S+2). +Six new numerical words add 6(b+1). Omitting the absent suffix countdown +only improves this upper bound. A local inventory of eleven scratch and +six numerical roles adds seventeen LEFT markers. Previously retained blank +backing, permanent bank templates/markers and simultaneous caller categories +are separate: this occupied-content bound is not a backing-capacity theorem. + +## Exact non-arithmetic invoice + +Let C(n,l) be the complete pooled countdown cost, from construction on an +l-digit input through draining and disposal, where l >= max(1,bit_length(n)). +Arham Tahir's PR2877 countdown identity for this Counter, derived earlier by +ywz65's PR2473, plus the pool's one acquisition read, gives + +``` +C(n,l) = 15n + 14l - 5 popcount(n) + 37 + 4[n=0]. +``` + +PR2877 states both branches for every width d>=max(1,bit_length(n)): +15n+14d-5 popcount(n)+36 for n>0 and 14d+40 at zero. Each additional leading +zero costs six input-copy operations, two extra rewind operations and six +normalization operations. For n=0, direct constructor normalization followed +by clearing the two-symbol zero/RIGHT body gives 14l+41. As both +predecessors note, the positive formula is not valid at zero. + +An independent count makes the endpoint convention explicit. For n>0 and +t=bit_length(n), construction costs 10t+16+14(l-t), including acquisition. +Draining costs 15n-5 popcount(n)+4t+4: ordinary decrements with k trailing +zeros cost 5k+10; the t-1 nonfinal powers of two add four each; the final +one-to-zero decrement adds eight. Use sum_(a=1..n) v_2(a)=n-popcount(n). +Disposal of the canonical zero costs seventeen. At n=0 construction is +14l+24 and disposal is again seventeen. This rederives both branches from +the literal loops; PR2877 and PR2473 retain credit for them. + +For the marginal suffix, the literal `one_bit_suffix` probe costs + +``` +P(S) = 4 if S is even; 15 if S = 1 mod 4; 12 otherwise. +``` + +In particular P(1)=15, because this argument has a high-zero margin. It is +not the canonical one-digit suffix probe used in PR2982's wrapper. + +The complete lifecycle of a marginal copied from an l-digit canonical Count +costs 27l+63: construction/margin 18l+35 (including acquisition), +`positive_extent` 4l+11, and disposal 5l+17. These follow by counting literal +reads/writes/moves in `Natural`, with no decoding of runtime extents. + +Put + +``` +J(Q,b) = C(0,b)+C(Q,b)+2 sum_(n=1..Q-1) C(n,b). +``` + +The coefficient is a signed power of two and Q is odd, so multiplication by c +permutes the offsets 0,...,Q-1. The two split counts are offset and Q-offset. +Thus J accounts for every block countdown in one source-coordinate cycle, +including the zero block. This permutation argument is why the following +invoice is independent of c. Nonunit coefficients are outside this claim. + +Let N be the physical traffic inside the explicitly enumerated numerical +calls in the next section. Every other physical operation has exact total + +``` +W = sum_(X=B,M,S) (27l_X+63) + 23V+32 + + 2 C(B,l_B+1) + + 2B C(Q,b) + + 2BQ C(M,l_M+1) + + 2BM (J(Q,b) + 2Q P(S)) + + 2BMQ^2 [S>1] C(S,l_S+1). +T = W+N. +``` + +There are two traversals. Each copies V payload bits at five operations per +bit. The split-stream rewinds, source rewind, split-stream disposal, output +rewind, three extent probes and three payload acquisitions supply the +remaining 13V+32, for 23V+32 in all: PR2473's exact unpooled payload bill +23V+29 plus the three acquisitions. The counter rows then follow the actual nesting of outer, +source-coordinate, middle, split block and suffix bit. Counter costs include +reads of numerical input Words; these are **outside** N and are not counted +again as arithmetic. No retained alias meter is added to its physical tape. + +Exactly + +``` +8 + 2B + 2BQ + 4BMQ + 2BMQ^2[S>1] +``` + +leases are acquired. This includes the three marginals, three payloads and +both outer counters. Acquisition count differs from peak live inventory. + +For a uniform upper bound, C(n,l) <= 16n+16l+64, l_X <= X, and b <= Q. +The following contributions divided by V bound all terms of W: + +| Term | Upper bound / V | +|---|---:| +| Three marginal lifecycles | 30 | +| Payload, fixed probes and acquisitions | 239/9 | +| Outer countdowns | 224/9 | +| Source-coordinate countdowns | 320/9 | +| Middle countdowns | 224/3 | +| Split-block countdowns | 544/3 | +| Marginal suffix probes | 20 | +| Suffix-bit countdowns | 224 | + +For example C(X,l_X+1)<=32X+80<=112X; a split pair is at most +16Q+32b+128<=272Q/3. The table sums to **617**, so W<=617V<640V. +It permits the suffix countdown even when absent, and uses Q>=3, B,M,S>=1. + +## Numerical traffic is included + +All numerical word bodies have b digits. Heads stay between the origin and +RIGHT. A rewind costs at most 3b; `msb` at most 6b; a zero test at most 9b; +and erasure at most 10b, for b>=3. From the literal loops in the retained +`words.py`: + +| Operation | Physical I/O upper bound | +|---|---:| +| Arena.zero (copy initialized template) | 13b | +| Arena.copy | 28b | +| Literal of magnitude at most 4 | 19b | +| Unsigned.compare | 18b | +| Unsigned.add/subtract | 36b | +| Unsigned.shift_add_bit | 28b | +| Unsigned.divmod | 160b^2 | +| Ring.add/subtract | 100b | +| Ring.negate | 128b | +| Ring.multiply | 300b^2 | +| Fixed selected coefficient, including reduction/sign | 256b^2 | +| Increment in place | 10b | + +For clarity, these are deliberately rounded source bounds, not fitted timing +ratios. Arena.zero costs exactly 9b+12 on initialized roles, at most 13b. +Copy costs at most 27b+1. Add/subtract cost at most 35b+2. +In division there are b iterations, each costing at most 104b, and setup, +scan teardown and the final probes cost at most 94b+4. This is below 160b^2. +In multiplication the two modular additions per bit cost at most 200b, +their old-result frees at most 20b, and the three loop operations at most b +per iteration. Setup/teardown is at most 111b+2. Thus +221b^2+111b+2<300b^2. Zero/one shortcuts are cheaper. +The fixed coefficient costs at most 160b^2+177b<256b^2, including literal, +division, frees and optional negation. Every bound uses b>=3. + +The entire top-level arithmetic partition in `added` is: + +| Numerical call | Multiplicity | Per-call bound | +|---|---:|---:| +| fixed_coefficient | 2 | 256b^2 | +| coefficient/modulus comparison | 2 | 18b | +| allocate x=0 | 2B | 13b | +| multiply coefficient*x | 2BQ | 300b^2 | +| subtract Q-offset | 2BQ | 36b | +| free offset and leading | 2BQ | 20b | +| increment x | 2B(Q-1) | 10b | +| free x / coefficient | 2B+2 | 10b | + +Nested arithmetic calls belong to their enclosing row, not to another row. +These exhaust numerical work in this local routine. Their sum is + +``` +N <= 512b^2 + 56b + 26Bb + 600BQb^2 + 132BQb + <= 832 BQ b^2. +``` + +The second inequality follows by dividing by BQb^2 and using B>=1, Q>=3, +b>=3: the resulting upper bound is 7414/9 < 832. Also b^2<=4Q for every +odd Q>=3. For Q=3 check 9<=12. Otherwise L=bit_length(Q)>=3, and +(L+1)^2<=2^(L+1)<=4Q; the first inequality follows by induction from L=3. +Consequently N<=3328 BQ^2<=3328V, and + +``` +T <= (617+3328)V = 3945V < 4096V. +``` + +Consuming the already rewound output by clearing it adds exactly 5V+7. +Since V>=9, it adds less than 6V; the convenient disposed bound is 4102V. +No sharpness is claimed for these traffic constants. The scratch count is +sharp; the numerical upper bound is attained by a stated fixture. + +## Checking and remaining boundary + +The independently implemented invoice is compared with the complete actual +source on 109 full packets, including every Boolean basis column of the +nine-bit Q=3 packet. The other fixtures use deterministic payloads; they are +not a full GL64 Boolean-column census. Independent modular addressing checks +endpoints, and physical meters are compared both by raw method interception +and by the sum over unique physical tapes. Fifty-one zero/padded countdown +checks and thirty-six separate arithmetic checks through 82-bit words +exercise the delicate boundaries. The all-width result rests on the written +source proof, not extrapolation from those finite executions. + +Controls reject one fewer scratch role, one fewer numerical slot, a wrong +coefficient, an endpoint-preserving extra read, noncanonical borrowed-count +padding that changes only cost, omitted zero-block charges, corrupted source +pins and Boolean/integer receipt substitution. Failed-call fixtures are +explicitly cleaned by the harness; this does not prove source exception safety. + +The actual high route additionally needs encoded extent/high-bank setup, +sign and carry compositions, and its B1 swaps. In particular a reversed-field +ADD may use two swaps outside this kernel, and those charges do not disappear. +Combining local occupied-content bounds with backing capacity, fixed inventories, +native/recursive lifetimes, root stock and H2 remains open. This is not a new +supplier, a whole-stage reserve, a selected-frontier change or a formal theorem. diff --git a/research/high-add-scratch-invoice/README.md b/research/high-add-scratch-invoice/README.md new file mode 100644 index 0000000000..f3c6586f7c --- /dev/null +++ b/research/high-add-scratch-invoice/README.md @@ -0,0 +1,115 @@ +# Ordered high-field ADD: exact scratch and a complete linear tape bill + +For the unchanged PR2915 `kernels.added`, with odd high modulus Q>=3, +canonical positive extents B,M,S and coefficient in {-4,-2,-1,1,2,4}: + +- Exactly **10+[S>1] free scratch roles** suffice and are necessary. +- **Six additional numerical words**, above all entry residents, suffice; + one complete fixture attains six. +- With V=BQMQS, complete local physical reads/writes/unit moves are at most + **4096V**, including encoded coefficient arithmetic and pool acquisition. + Clearing the returned output gives the convenient bound **4102V**. + +[PROOF.md](PROOF.md) derives the all-parameter result and an exact +non-arithmetic invoice. It also gives an occupied-content bound, separating +borrowed state, markers and retained backing. An empty split still costs a +countdown, priced by the zero case of PR2877's countdown identity (four +operations beyond the positive formula). The output is separately owned; +borrowed source, counts and entry roles are preserved, and all other new +roles close. + +This answers the **ordered high ADD component** of Nick Petalas's +[PR2982 handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/2319#discussioncomment-18977416). +The claim is in [discussion #2319](https://github.com/CrocSwap/integer-mult-bounds/discussions/2319#discussioncomment-19001907). The contribution is a scoped proof and +independent source-bound audit, not a whole-stage stock coefficient or a new +kappa. Fixed-control machine steps, initial markers/templates, enclosing +high-bank setup, reversed-field B1 swaps and complete caller storage remain +separate charges. No source construction or selected record changes. + +## Reproduce + +From the repository root, with Python 3.12 and the standard library: + +```sh +python3 -I -B scripts/research_package.py --package research/high-add-scratch-invoice +``` + +Expected primary output: + +```text +PASS_HIGH_ADD_SCRATCH_INVOICE cases=109 payload_bits=37241 scratch=10,11 numerical_extra<=6 io<=4096V +``` + +The registered commands also run ten optimized behavioral control groups. +`--check-only` validates package metadata and source pins. Direct verification +is `python3 -I -B research/high-add-scratch-invoice/verify.py`; `--emit` prints +a fresh receipt without replacing the committed [RESULT.json](RESULT.json). + +The 109 complete packets include four occupied-pool cases and all nine +Boolean basis columns of one complete Q=3 packet. Their exact endpoints use +an independent modular address oracle. All source traffic is observed on raw +physical tapes and checked against unique physical-object meters; Word/Lease +alias meters are not added again. Fifty-one countdown fixtures include zero +and padded inputs. Thirty-six separate arithmetic checks reach 82-bit words +without materializing the corresponding huge packet. + +Meaningful controls cover insufficient stream/numerical capacity, wrong +coefficient, endpoint-preserving cost mutation, noncanonical input padding, +the zero-count correction, source corruption and typed receipt corruption. +These are local source checks and a written proof, not independent human, +formal-kernel, full selected GL64 payload, selected cold-replay or hosted-CI +verification. General failure cleanup is not established. + +## Sources and scope + +Scientific base: `463113d675af7410ac91d53a4fed51ec6494eb9a`, priority revision 6. +PR2915 author head: `fecc5a87574df441ddc3dad44f99fca9bd7fdd92`. +The loader authenticates the complete retained PR2899/PR2809/PR2753 source +archives before executing the original modules. Live transitive inputs are +declared in [SOURCES.json](SOURCES.json) and [VERIFY.json](VERIFY.json). +The selected-record compatibility adaptation on main is inherited and is +not described as byte-identical to the original author source. No retained +file or archive is rewritten. + +The `selected-stock-envelope` card is explicitly **changed** to this named +local reserve/time implication. Cutoff comparisons, the earlier conditional +8194/6748 coefficients, the lcm-wrapper fit and PR3113's m=73 source gap are +not repeated. [TASK.json](TASK.json) records the task, exact dependencies, +overlap, expansion decision and remaining obligations. + +## Open next questions + +1. Bind the **remaining single-cube setup and operations** to this invoice. + Start with `high_route.extents/execute`, preserving initialized-bank costs, + owned intermediate outputs and the two swaps on reversed ADDs. This closes + the next part of PR2982's tariff handoff; native B1 contracts and the other + kernels' complete bills remain dependencies. +2. Join the source-level role/content bounds to **physical backing and a caller + stock ledger**. Start at the same chronological cuts, retaining all entry + roles, marker/template provisioning and native inventories. Local occupied + content and exact I/O do not establish full caller capacity or a uniform + selected-stage reserve. No construction-family expansion is proposed here. + +## Credit + +Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. +OpenAI Codex (GPT-6 Astra) performed the derivation, implementation, checking +and writing; no independent human review is claimed. New work is Apache-2.0. + +Jose Manuel/jmbarrancoml supplied PR2915's actual kernels, PR2899's physical +arena, PR2809's scratch specialization and PR2157's factor words, with the +retained PR2753 logical caller by David Arias. Nick Petalas supplied PR2982's +prefix-wrapper tariff and released handoff, and PR2968's separate scaling/pool +invoice. Arham Tahir's PR2877 supplies the all-width countdown identity, +including its zero case; ywz65's PR2473 derived the same Counter bill, and +the unpooled ADD's exact payload bill, earlier. The invoice here adds pool +acquisitions, the one-bit-suffix path and the marginal lifecycles. Ross +Richardson's PR2810 proves the six-Word `stream.add_pass` bound outside +callbacks for the same `stream.py`; the six-slot statement here composes it +with the actual coefficient callback. Nick Petalas's PR2905 and PR2923 bound +the Counter and joint backing of the same ADD; the occupied-content corollary +is separate from them. The new content is the exact pooled scratch inventory, +the complete ordered-ADD invoice and the explicit 4096V bound. +The numerical arithmetic, ywz65's parking work, this account's PR2399 +substitution algebra and DreamingOfClouds' selected PR589 on eumemic's +PR555/source527 lineage keep their original attribution and notices. diff --git a/research/high-add-scratch-invoice/RESULT.json b/research/high-add-scratch-invoice/RESULT.json new file mode 100644 index 0000000000..778579ad3c --- /dev/null +++ b/research/high-add-scratch-invoice/RESULT.json @@ -0,0 +1,6449 @@ +{ + "basis_columns": 9, + "cases": 109, + "cases_detail": [ + { + "acquisitions": 28, + "arithmetic": 6174, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2470, + 1235 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": -4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 8857, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 4142, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2224, + 1112 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 774, + 155 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": -2, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 6825, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 5918, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 8601, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 3454, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1536, + 768 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 774, + 155 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 6137, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 5250, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1546, + 773 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 7933, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 3710, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1792, + 896 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 774, + 155 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": 4, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 6393, + "volume": 9 + }, + { + "acquisitions": 46, + "arithmetic": 6174, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2470, + 1235 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": -4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 4657, + "suffix": 2, + "traffic": 10831, + "volume": 18 + }, + { + "acquisitions": 46, + "arithmetic": 4142, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2224, + 1112 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 774, + 155 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": -2, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 4657, + "suffix": 2, + "traffic": 8799, + "volume": 18 + }, + { + "acquisitions": 46, + "arithmetic": 5918, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 4657, + "suffix": 2, + "traffic": 10575, + "volume": 18 + }, + { + "acquisitions": 46, + "arithmetic": 3454, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1536, + 768 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 774, + 155 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 4657, + "suffix": 2, + "traffic": 8111, + "volume": 18 + }, + { + "acquisitions": 46, + "arithmetic": 5250, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1546, + 773 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 4657, + "suffix": 2, + "traffic": 9907, + "volume": 18 + }, + { + "acquisitions": 46, + "arithmetic": 3710, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1792, + 896 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 774, + 155 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": null, + "before": 1, + "coefficient": 4, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 4657, + "suffix": 2, + "traffic": 8367, + "volume": 18 + }, + { + "acquisitions": 96, + "arithmetic": 9750, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2470, + 1235 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 5120, + 1007 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": -4, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 11706, + "suffix": 1, + "traffic": 21456, + "volume": 54 + }, + { + "acquisitions": 96, + "arithmetic": 5932, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2224, + 1112 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 1548, + 155 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 3, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 11706, + "suffix": 1, + "traffic": 17638, + "volume": 54 + }, + { + "acquisitions": 96, + "arithmetic": 9494, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 5120, + 1007 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": -1, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 11706, + "suffix": 1, + "traffic": 21200, + "volume": 54 + }, + { + "acquisitions": 96, + "arithmetic": 5244, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1536, + 768 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 1548, + 155 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": 1, + "middle": 3, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 11706, + "suffix": 1, + "traffic": 16950, + "volume": 54 + }, + { + "acquisitions": 96, + "arithmetic": 8826, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1546, + 773 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 5120, + 1007 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": 2, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 11706, + "suffix": 1, + "traffic": 20532, + "volume": 54 + }, + { + "acquisitions": 96, + "arithmetic": 5500, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1792, + 896 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 1548, + 155 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": 4, + "middle": 3, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 11706, + "suffix": 1, + "traffic": 17206, + "volume": 54 + }, + { + "acquisitions": 84, + "arithmetic": 9750, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2470, + 1235 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 5120, + 1007 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": -4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 9886, + "suffix": 3, + "traffic": 19636, + "volume": 54 + }, + { + "acquisitions": 84, + "arithmetic": 5932, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2224, + 1112 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 1548, + 155 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 9886, + "suffix": 3, + "traffic": 15818, + "volume": 54 + }, + { + "acquisitions": 84, + "arithmetic": 9494, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 5120, + 1007 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 9886, + "suffix": 3, + "traffic": 19380, + "volume": 54 + }, + { + "acquisitions": 84, + "arithmetic": 5244, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1536, + 768 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 1548, + 155 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 9886, + "suffix": 3, + "traffic": 15130, + "volume": 54 + }, + { + "acquisitions": 84, + "arithmetic": 8826, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1546, + 773 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 5120, + 1007 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 9886, + "suffix": 3, + "traffic": 18712, + "volume": 54 + }, + { + "acquisitions": 84, + "arithmetic": 5500, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 1792, + 896 + ], + "free": [ + 6, + 138, + 23 + ], + "free_many": [ + 12, + 552, + 46 + ], + "increment_in_place": [ + 8, + 92, + 14 + ], + "multiply": [ + 12, + 1548, + 155 + ], + "subtract_exact": [ + 12, + 1140, + 95 + ], + "zero": [ + 4, + 156, + 39 + ] + }, + "basis": null, + "before": 2, + "coefficient": 4, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 11, + "shell": 9886, + "suffix": 3, + "traffic": 15386, + "volume": 54 + }, + { + "acquisitions": 40, + "arithmetic": 6926, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3078, + 1539 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 1708, + 190 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": -4, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 4891, + "suffix": 1, + "traffic": 11817, + "volume": 25 + }, + { + "acquisitions": 40, + "arithmetic": 14756, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3068, + 1534 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 9548, + 1610 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": -2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 4891, + "suffix": 1, + "traffic": 19647, + "volume": 25 + }, + { + "acquisitions": 40, + "arithmetic": 15326, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3058, + 1529 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 10128, + 1755 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 4891, + "suffix": 1, + "traffic": 20217, + "volume": 25 + }, + { + "acquisitions": 40, + "arithmetic": 6074, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2226, + 1113 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 1708, + 190 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 4891, + "suffix": 1, + "traffic": 10965, + "volume": 25 + }, + { + "acquisitions": 40, + "arithmetic": 13634, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2236, + 1118 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 9258, + 1610 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 4891, + "suffix": 1, + "traffic": 18525, + "volume": 25 + }, + { + "acquisitions": 40, + "arithmetic": 14514, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2246, + 1123 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 10128, + 1755 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": 4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 4891, + "suffix": 1, + "traffic": 19405, + "volume": 25 + }, + { + "acquisitions": 90, + "arithmetic": 6926, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3078, + 1539 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 1708, + 190 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": -4, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 10473, + "suffix": 2, + "traffic": 17399, + "volume": 50 + }, + { + "acquisitions": 90, + "arithmetic": 14756, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3068, + 1534 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 9548, + 1610 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": -2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 10473, + "suffix": 2, + "traffic": 25229, + "volume": 50 + }, + { + "acquisitions": 90, + "arithmetic": 15326, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3058, + 1529 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 10128, + 1755 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 10473, + "suffix": 2, + "traffic": 25799, + "volume": 50 + }, + { + "acquisitions": 90, + "arithmetic": 6074, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2226, + 1113 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 1708, + 190 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 10473, + "suffix": 2, + "traffic": 16547, + "volume": 50 + }, + { + "acquisitions": 90, + "arithmetic": 13634, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2236, + 1118 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 9258, + 1610 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 10473, + "suffix": 2, + "traffic": 24107, + "volume": 50 + }, + { + "acquisitions": 90, + "arithmetic": 14514, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2246, + 1123 + ], + "free": [ + 4, + 112, + 28 + ], + "free_many": [ + 10, + 560, + 56 + ], + "increment_in_place": [ + 8, + 102, + 19 + ], + "multiply": [ + 10, + 10128, + 1755 + ], + "subtract_exact": [ + 10, + 1170, + 117 + ], + "zero": [ + 2, + 96, + 48 + ] + }, + "basis": null, + "before": 1, + "coefficient": 4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 10473, + "suffix": 2, + "traffic": 24987, + "volume": 50 + }, + { + "acquisitions": 152, + "arithmetic": 10618, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3078, + 1539 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 3416, + 190 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": -4, + "middle": 3, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 23714, + "suffix": 1, + "traffic": 34332, + "volume": 150 + }, + { + "acquisitions": 152, + "arithmetic": 26288, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3068, + 1534 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 19096, + 1610 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 23714, + "suffix": 1, + "traffic": 50002, + "volume": 150 + }, + { + "acquisitions": 152, + "arithmetic": 27438, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3058, + 1529 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 20256, + 1755 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": -1, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 23714, + "suffix": 1, + "traffic": 51152, + "volume": 150 + }, + { + "acquisitions": 152, + "arithmetic": 9766, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2226, + 1113 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 3416, + 190 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": 1, + "middle": 3, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 23714, + "suffix": 1, + "traffic": 33480, + "volume": 150 + }, + { + "acquisitions": 152, + "arithmetic": 24876, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2236, + 1118 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 18516, + 1610 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": 2, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 23714, + "suffix": 1, + "traffic": 48590, + "volume": 150 + }, + { + "acquisitions": 152, + "arithmetic": 26626, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2246, + 1123 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 20256, + 1755 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": 4, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 23714, + "suffix": 1, + "traffic": 50340, + "volume": 150 + }, + { + "acquisitions": 172, + "arithmetic": 10618, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3078, + 1539 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 3416, + 190 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": -4, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 23022, + "suffix": 3, + "traffic": 33640, + "volume": 150 + }, + { + "acquisitions": 172, + "arithmetic": 26288, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3068, + 1534 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 19096, + 1610 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 23022, + "suffix": 3, + "traffic": 49310, + "volume": 150 + }, + { + "acquisitions": 172, + "arithmetic": 27438, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3058, + 1529 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 20256, + 1755 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 23022, + "suffix": 3, + "traffic": 50460, + "volume": 150 + }, + { + "acquisitions": 172, + "arithmetic": 9766, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2226, + 1113 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 3416, + 190 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 23022, + "suffix": 3, + "traffic": 32788, + "volume": 150 + }, + { + "acquisitions": 172, + "arithmetic": 24876, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2236, + 1118 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 18516, + 1610 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 23022, + "suffix": 3, + "traffic": 47898, + "volume": 150 + }, + { + "acquisitions": 172, + "arithmetic": 26626, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 2246, + 1123 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 20256, + 1755 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": 4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 23022, + "suffix": 3, + "traffic": 49648, + "volume": 150 + }, + { + "acquisitions": 64, + "arithmetic": 38552, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4050, + 2025 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 30234, + 2523 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": -4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 10679, + "suffix": 1, + "traffic": 49231, + "volume": 81 + }, + { + "acquisitions": 64, + "arithmetic": 40262, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4040, + 2020 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 31954, + 2695 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": -2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 10679, + "suffix": 1, + "traffic": 50941, + "volume": 81 + }, + { + "acquisitions": 64, + "arithmetic": 41628, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4030, + 2015 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 33330, + 2867 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 10679, + "suffix": 1, + "traffic": 52307, + "volume": 81 + }, + { + "acquisitions": 64, + "arithmetic": 11134, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3044, + 1522 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 3822, + 225 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 10679, + "suffix": 1, + "traffic": 21813, + "volume": 81 + }, + { + "acquisitions": 64, + "arithmetic": 35836, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3054, + 1527 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 28514, + 2351 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 10679, + "suffix": 1, + "traffic": 46515, + "volume": 81 + }, + { + "acquisitions": 64, + "arithmetic": 37566, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3064, + 1532 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 30234, + 2523 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": 4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 10679, + "suffix": 1, + "traffic": 48245, + "volume": 81 + }, + { + "acquisitions": 226, + "arithmetic": 38552, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4050, + 2025 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 30234, + 2523 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": -4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 29021, + "suffix": 2, + "traffic": 67573, + "volume": 162 + }, + { + "acquisitions": 226, + "arithmetic": 40262, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4040, + 2020 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 31954, + 2695 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": -2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 29021, + "suffix": 2, + "traffic": 69283, + "volume": 162 + }, + { + "acquisitions": 226, + "arithmetic": 41628, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4030, + 2015 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 33330, + 2867 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 29021, + "suffix": 2, + "traffic": 70649, + "volume": 162 + }, + { + "acquisitions": 226, + "arithmetic": 11134, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3044, + 1522 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 3822, + 225 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 29021, + "suffix": 2, + "traffic": 40155, + "volume": 162 + }, + { + "acquisitions": 226, + "arithmetic": 35836, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3054, + 1527 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 28514, + 2351 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 29021, + "suffix": 2, + "traffic": 64857, + "volume": 162 + }, + { + "acquisitions": 226, + "arithmetic": 37566, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3064, + 1532 + ], + "free": [ + 4, + 132, + 33 + ], + "free_many": [ + 18, + 1188, + 66 + ], + "increment_in_place": [ + 16, + 214, + 24 + ], + "multiply": [ + 18, + 30234, + 2523 + ], + "subtract_exact": [ + 18, + 2502, + 139 + ], + "zero": [ + 2, + 114, + 57 + ] + }, + "basis": null, + "before": 1, + "coefficient": 4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 29021, + "suffix": 2, + "traffic": 66587, + "volume": 162 + }, + { + "acquisitions": 264, + "arithmetic": 72870, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4050, + 2025 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 60468, + 2523 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": -4, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 56074, + "suffix": 1, + "traffic": 128944, + "volume": 486 + }, + { + "acquisitions": 264, + "arithmetic": 76300, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4040, + 2020 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 63908, + 2695 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 56074, + "suffix": 1, + "traffic": 132374, + "volume": 486 + }, + { + "acquisitions": 264, + "arithmetic": 79042, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4030, + 2015 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 66660, + 2867 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": -1, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 56074, + "suffix": 1, + "traffic": 135116, + "volume": 486 + }, + { + "acquisitions": 264, + "arithmetic": 19040, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3044, + 1522 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 7644, + 225 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": 1, + "middle": 3, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 56074, + "suffix": 1, + "traffic": 75114, + "volume": 486 + }, + { + "acquisitions": 264, + "arithmetic": 68434, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3054, + 1527 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 57028, + 2351 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": 2, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 56074, + "suffix": 1, + "traffic": 124508, + "volume": 486 + }, + { + "acquisitions": 264, + "arithmetic": 71884, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3064, + 1532 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 60468, + 2523 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": 4, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 10, + "shell": 56074, + "suffix": 1, + "traffic": 127958, + "volume": 486 + }, + { + "acquisitions": 444, + "arithmetic": 72870, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4050, + 2025 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 60468, + 2523 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": -4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 65190, + "suffix": 3, + "traffic": 138060, + "volume": 486 + }, + { + "acquisitions": 444, + "arithmetic": 76300, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4040, + 2020 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 63908, + 2695 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 65190, + "suffix": 3, + "traffic": 141490, + "volume": 486 + }, + { + "acquisitions": 444, + "arithmetic": 79042, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 4030, + 2015 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 66660, + 2867 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 65190, + "suffix": 3, + "traffic": 144232, + "volume": 486 + }, + { + "acquisitions": 444, + "arithmetic": 19040, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3044, + 1522 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 7644, + 225 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 65190, + "suffix": 3, + "traffic": 84230, + "volume": 486 + }, + { + "acquisitions": 444, + "arithmetic": 68434, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3054, + 1527 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 57028, + 2351 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 65190, + "suffix": 3, + "traffic": 133624, + "volume": 486 + }, + { + "acquisitions": 444, + "arithmetic": 71884, + "arithmetic_intervals": { + "compare": [ + 2, + 118, + 59 + ], + "fixed_coefficient": [ + 2, + 3064, + 1532 + ], + "free": [ + 6, + 198, + 33 + ], + "free_many": [ + 36, + 2376, + 66 + ], + "increment_in_place": [ + 32, + 428, + 24 + ], + "multiply": [ + 36, + 60468, + 2523 + ], + "subtract_exact": [ + 36, + 5004, + 139 + ], + "zero": [ + 4, + 228, + 57 + ] + }, + "basis": null, + "before": 2, + "coefficient": 4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 9, + "scratch_peak": 11, + "shell": 65190, + "suffix": 3, + "traffic": 137074, + "volume": 486 + }, + { + "acquisitions": 112, + "arithmetic": 106080, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5150, + 2575 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 92014, + 3827 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": -4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 27627, + "suffix": 1, + "traffic": 133707, + "volume": 289 + }, + { + "acquisitions": 112, + "arithmetic": 109652, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5140, + 2570 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 95596, + 4026 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": -2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 27627, + "suffix": 1, + "traffic": 137279, + "volume": 289 + }, + { + "acquisitions": 112, + "arithmetic": 112826, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5130, + 2565 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 98780, + 4225 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 27627, + "suffix": 1, + "traffic": 140453, + "volume": 289 + }, + { + "acquisitions": 112, + "arithmetic": 21482, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 3990, + 1995 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 8576, + 260 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 27627, + "suffix": 1, + "traffic": 49109, + "volume": 289 + }, + { + "acquisitions": 112, + "arithmetic": 92990, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 4000, + 2000 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 80074, + 3230 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 27627, + "suffix": 1, + "traffic": 120617, + "volume": 289 + }, + { + "acquisitions": 112, + "arithmetic": 96582, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 4010, + 2005 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 83656, + 3429 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": 4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 27627, + "suffix": 1, + "traffic": 124209, + "volume": 289 + }, + { + "acquisitions": 690, + "arithmetic": 106080, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5150, + 2575 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 92014, + 3827 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": -4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 93665, + "suffix": 2, + "traffic": 199745, + "volume": 578 + }, + { + "acquisitions": 690, + "arithmetic": 109652, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5140, + 2570 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 95596, + 4026 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": -2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 93665, + "suffix": 2, + "traffic": 203317, + "volume": 578 + }, + { + "acquisitions": 690, + "arithmetic": 112826, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5130, + 2565 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 98780, + 4225 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 93665, + "suffix": 2, + "traffic": 206491, + "volume": 578 + }, + { + "acquisitions": 690, + "arithmetic": 21482, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 3990, + 1995 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 8576, + 260 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 93665, + "suffix": 2, + "traffic": 115147, + "volume": 578 + }, + { + "acquisitions": 690, + "arithmetic": 92990, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 4000, + 2000 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 80074, + 3230 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 93665, + "suffix": 2, + "traffic": 186655, + "volume": 578 + }, + { + "acquisitions": 690, + "arithmetic": 96582, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 4010, + 2005 + ], + "free": [ + 4, + 152, + 38 + ], + "free_many": [ + 34, + 2584, + 76 + ], + "increment_in_place": [ + 32, + 438, + 29 + ], + "multiply": [ + 34, + 83656, + 3429 + ], + "subtract_exact": [ + 34, + 5474, + 161 + ], + "zero": [ + 2, + 132, + 66 + ] + }, + "basis": null, + "before": 1, + "coefficient": 4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 93665, + "suffix": 2, + "traffic": 190247, + "volume": 578 + }, + { + "acquisitions": 488, + "arithmetic": 206798, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5150, + 2575 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 184028, + 3827 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": -4, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 153138, + "suffix": 1, + "traffic": 359936, + "volume": 1734 + }, + { + "acquisitions": 488, + "arithmetic": 213952, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5140, + 2570 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 191192, + 4026 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 153138, + "suffix": 1, + "traffic": 367090, + "volume": 1734 + }, + { + "acquisitions": 488, + "arithmetic": 220310, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5130, + 2565 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 197560, + 4225 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": -1, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 153138, + "suffix": 1, + "traffic": 373448, + "volume": 1734 + }, + { + "acquisitions": 488, + "arithmetic": 38762, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 3990, + 1995 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 17152, + 260 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": 1, + "middle": 3, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 153138, + "suffix": 1, + "traffic": 191900, + "volume": 1734 + }, + { + "acquisitions": 488, + "arithmetic": 181768, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 4000, + 2000 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 160148, + 3230 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": 2, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 153138, + "suffix": 1, + "traffic": 334906, + "volume": 1734 + }, + { + "acquisitions": 488, + "arithmetic": 188942, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 4010, + 2005 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 167312, + 3429 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": 4, + "middle": 3, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 10, + "shell": 153138, + "suffix": 1, + "traffic": 342080, + "volume": 1734 + }, + { + "acquisitions": 1372, + "arithmetic": 206798, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5150, + 2575 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 184028, + 3827 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": -4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 212878, + "suffix": 3, + "traffic": 419676, + "volume": 1734 + }, + { + "acquisitions": 1372, + "arithmetic": 213952, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5140, + 2570 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 191192, + 4026 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 212878, + "suffix": 3, + "traffic": 426830, + "volume": 1734 + }, + { + "acquisitions": 1372, + "arithmetic": 220310, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 5130, + 2565 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 197560, + 4225 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 212878, + "suffix": 3, + "traffic": 433188, + "volume": 1734 + }, + { + "acquisitions": 1372, + "arithmetic": 38762, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 3990, + 1995 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 17152, + 260 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": 1, + "middle": 1, + "numerical_extra": 5, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 212878, + "suffix": 3, + "traffic": 251640, + "volume": 1734 + }, + { + "acquisitions": 1372, + "arithmetic": 181768, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 4000, + 2000 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 160148, + 3230 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": 2, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 212878, + "suffix": 3, + "traffic": 394646, + "volume": 1734 + }, + { + "acquisitions": 1372, + "arithmetic": 188942, + "arithmetic_intervals": { + "compare": [ + 2, + 136, + 68 + ], + "fixed_coefficient": [ + 2, + 4010, + 2005 + ], + "free": [ + 6, + 228, + 38 + ], + "free_many": [ + 68, + 5168, + 76 + ], + "increment_in_place": [ + 64, + 876, + 29 + ], + "multiply": [ + 68, + 167312, + 3429 + ], + "subtract_exact": [ + 68, + 10948, + 161 + ], + "zero": [ + 4, + 264, + 66 + ] + }, + "basis": null, + "before": 2, + "coefficient": 4, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 17, + "scratch_peak": 11, + "shell": 212878, + "suffix": 3, + "traffic": 401820, + "volume": 1734 + }, + { + "acquisitions": 112, + "arithmetic": 26288, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3068, + 1534 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 19096, + 1610 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 2, + "numerical_extra": 6, + "occupied": 3, + "pooled_source": false, + "q": 5, + "scratch_peak": 10, + "shell": 16768, + "suffix": 1, + "traffic": 43056, + "volume": 100 + }, + { + "acquisitions": 112, + "arithmetic": 26288, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3068, + 1534 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 19096, + 1610 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 2, + "numerical_extra": 6, + "occupied": 3, + "pooled_source": true, + "q": 5, + "scratch_peak": 10, + "shell": 16768, + "suffix": 1, + "traffic": 43056, + "volume": 100 + }, + { + "acquisitions": 312, + "arithmetic": 26288, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3068, + 1534 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 19096, + 1610 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 2, + "numerical_extra": 6, + "occupied": 3, + "pooled_source": false, + "q": 5, + "scratch_peak": 11, + "shell": 43955, + "suffix": 3, + "traffic": 70243, + "volume": 300 + }, + { + "acquisitions": 312, + "arithmetic": 26288, + "arithmetic_intervals": { + "compare": [ + 2, + 100, + 50 + ], + "fixed_coefficient": [ + 2, + 3068, + 1534 + ], + "free": [ + 6, + 168, + 28 + ], + "free_many": [ + 20, + 1120, + 56 + ], + "increment_in_place": [ + 16, + 204, + 19 + ], + "multiply": [ + 20, + 19096, + 1610 + ], + "subtract_exact": [ + 20, + 2340, + 117 + ], + "zero": [ + 4, + 192, + 48 + ] + }, + "basis": null, + "before": 2, + "coefficient": -2, + "middle": 2, + "numerical_extra": 6, + "occupied": 3, + "pooled_source": true, + "q": 5, + "scratch_peak": 11, + "shell": 43955, + "suffix": 3, + "traffic": 70243, + "volume": 300 + }, + { + "acquisitions": 28, + "arithmetic": 5918, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": 0, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 8601, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 5918, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": 1, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 8601, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 5918, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": 2, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 8601, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 5918, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": 3, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 8601, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 5918, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": 4, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 8601, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 5918, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": 5, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 8601, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 5918, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": 6, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 8601, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 5918, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": 7, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 8601, + "volume": 9 + }, + { + "acquisitions": 28, + "arithmetic": 5918, + "arithmetic_intervals": { + "compare": [ + 2, + 82, + 41 + ], + "fixed_coefficient": [ + 2, + 2214, + 1107 + ], + "free": [ + 4, + 92, + 23 + ], + "free_many": [ + 6, + 276, + 46 + ], + "increment_in_place": [ + 4, + 46, + 14 + ], + "multiply": [ + 6, + 2560, + 1007 + ], + "subtract_exact": [ + 6, + 570, + 95 + ], + "zero": [ + 2, + 78, + 39 + ] + }, + "basis": 8, + "before": 1, + "coefficient": -1, + "middle": 1, + "numerical_extra": 6, + "occupied": 0, + "pooled_source": false, + "q": 3, + "scratch_peak": 10, + "shell": 2683, + "suffix": 1, + "traffic": 8601, + "volume": 9 + } + ], + "cases_sha256": "9f0fe7257cc2f18a7040e42c2cbf713535a389e8f0cfeaabbaaa38e3f4ffe79a", + "counter_cases": 51, + "disposed_io_coefficient": 4102, + "large_word_checks": 36, + "numerical_extra": 6, + "payload_bits": 37241, + "scratch_roles": [ + 10, + 11 + ], + "status": "PASS_HIGH_ADD_SCRATCH_INVOICE", + "uniform_io_coefficient": 4096 +} diff --git a/research/high-add-scratch-invoice/SOURCES.json b/research/high-add-scratch-invoice/SOURCES.json new file mode 100644 index 0000000000..56bc19e4e4 --- /dev/null +++ b/research/high-add-scratch-invoice/SOURCES.json @@ -0,0 +1,156 @@ +{ + "schema_version": 1, + "base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/bit2234-stock-threshold/README.md", + "usage": "input", + "git_blob": "ede0d322c477af91d4c2cc33db0fd10958f45eab", + "sha256": "1e050c9f963421d751d9208092f9a15321ed77810e03912df8eb5eb56bbb06e7" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "usage": "input", + "git_blob": "9eafb8776cbf78c72124f833534469ddfa5e98ec", + "sha256": "0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL.json", + "usage": "input", + "git_blob": "1f648db9e63e7bfcaa6d5b1dd9fa6503caac47d2", + "sha256": "8de008a7978d4b7189cbec2470443619149a2b7b2f0f862540eeee4b23d3a819" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "usage": "input", + "git_blob": "44006542202ca6037533a754f0bcd00549d7e088", + "sha256": "0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734" + }, + { + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "usage": "input", + "git_blob": "e293ddc557742637f9f679f083a1a282d87b1b13", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/high-route-prefix-cost/README.md", + "usage": "input", + "git_blob": "1d69cbf05f1a61d5d8480eccbf42005471d5916a", + "sha256": "c057d0752fefc5d1013fd9670bd055f7977e2f7f7ff4a7bde7e18e63bfb50f0b" + }, + { + "path": "research/high-scaling-scratch-traffic/README.md", + "usage": "input", + "git_blob": "0596dd86e2aa7f9281d981522509a7294bcf7a77", + "sha256": "5b9f2eab1606290b2a3f391d3da2d2538dcedddb3de71984e0f6b13b4fd624c0" + }, + { + "path": "research/idle-axis-hosting/PROOF.md", + "usage": "input", + "git_blob": "4468a00349b4f68dce103e785a8392099435e1d6", + "sha256": "cfe34bf0b64259661312dae22c3a23adc5bf6f6326951eee5c1488ccfc347542" + }, + { + "path": "research/physical-ordinary-interchange/physical_words.py", + "usage": "input", + "git_blob": "44b464714277786297c8ee7fd04470dc6394896d", + "sha256": "89ba40442297ec35368e426770f44852b39807ca426710ded2735678651bef61" + }, + { + "path": "research/pr589-five-helper-hosting/PROOF.md", + "usage": "input", + "git_blob": "bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647" + }, + { + "path": "research/pr589-five-helper-hosting/verify.py", + "usage": "input", + "git_blob": "dbc71f56bb4205ebe378ada1f9f4ea88630d1d39", + "sha256": "cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367" + }, + { + "path": "research/recursive-parking-boundary/README.md", + "usage": "input", + "git_blob": "251f335ebaccc11d69393ee7aeb5a2e84526d0bb", + "sha256": "491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18" + }, + { + "path": "research/selected-bit-fast-primitives/high_route.py", + "usage": "input", + "git_blob": "ec7481f890147be7763f4da729fd879a88a87e8e", + "sha256": "13d9c706e7bad2fa3b7d2a97d19b58f2c4efac06d2bb76b613b40069c38b1cd2" + }, + { + "path": "research/selected-bit-fast-primitives/inputs/pr2157.tar", + "usage": "input", + "git_blob": "9504807466071f56519f8663ccb532076a42a273", + "sha256": "db202c7b91b5b8b9340f96f870d54e275854f0b73839451c7c15bd7895ac3639" + }, + { + "path": "research/selected-bit-fast-primitives/inputs/pr2899.tar", + "usage": "input", + "git_blob": "e85ce82745879141e416ac6d9e3551ff959871aa", + "sha256": "fc4a2e07423835737c8fb3872664b16ff12aa4cf83b1e26e49878debef40c531" + }, + { + "path": "research/selected-bit-fast-primitives/kernels.py", + "usage": "input", + "git_blob": "de9fb08c35e92c8354ae622276866385fd07e3d2", + "sha256": "c4b91333817f7fcea44b1d32e01095cd71aeb673ed3608d2e25f4c06d56bb420" + }, + { + "path": "research/selected-bit-fast-primitives/stage_sources.py", + "usage": "input", + "git_blob": "27383dd1553672f9c82139f80b628b2a094628d8", + "sha256": "55c6631cce4f76e14b66b6195468c36b544e2374cc6c59702135c664bff10822" + }, + { + "path": "research/selected-bit-local-ring-sweeps/PROOF.md", + "usage": "input", + "git_blob": "4330de85dd9862ed15d84ab917887d249753df99", + "sha256": "846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7" + }, + { + "path": "research/selected-bit-physical-caller/scratch_pool.py", + "usage": "input", + "git_blob": "0f22807c65d1bca374b905538512bf8c43702070", + "sha256": "41f1eb93652b7174c3b02f95f70e1a9ce2e2aed0a729e725167c8f226e65d8db" + }, + { + "path": "research/selected-bit-recursive-closure/PROOF.md", + "usage": "input", + "git_blob": "6c410cab5713979214a45835091fbeb9ee9b8531", + "sha256": "74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344" + }, + { + "path": "upstream/build/sections/02-streams.tex", + "usage": "input", + "git_blob": "088fceea1867abc76271d7efe7532b779fee9039", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + } + ] +} diff --git a/research/high-add-scratch-invoice/TASK.json b/research/high-add-scratch-invoice/TASK.json new file mode 100644 index 0000000000..ba9c3f055a --- /dev/null +++ b/research/high-add-scratch-invoice/TASK.json @@ -0,0 +1,156 @@ +{ + "schema_version": 1, + "task_id": "selected-stock-envelope", + "priority_revision": 6, + "base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "original_card": { + "id": "selected-stock-envelope", + "question": "What explicit uniform stock envelope does the actual selected stopped producer supply at one bootstrap stage?", + "starting_points": [ + "research/selected-bootstrap-stock-audit/README.md", + "research/bootstrap-cutoff-time-space-split/README.md", + "certificates/selected-result.json", + "docs/research/community-efficient1000-review.md", + "research/stock-margin-chain/README.md" + ], + "methods": [ + "Derive a source-bound reserve recurrence at the actual selected atom widths, separating parent stock from completed inner borrowing.", + "Find an exact missing implication or counterexample to a proposed selected-stage stock envelope." + ], + "acceptance_gate": "Bind every coefficient and depth factor to the selected producer and state the width domain. Compare a proved envelope with the sufficient cutoff guard; a large numerical headroom or a historical m=120 coefficient is not a selected m=73 proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2972 stock-margin chain and the selected stock audit. The new source archive reports the remaining cutoff comparisons, but leaves every actual stock coefficient unresolved; it is not an independently validated reserve envelope.", + "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": "Choose one actual selected producer/stage and derive its parent reserve and depth coefficient from source. Check whether newer handoffs already cover that exact obligation. Stop with the missing implementation lemma if it cannot be bounded; do not rerun #2972 cutoff/headroom arithmetic as a new contribution.", + "bottleneck_link": "This reduces a concrete inherited implementation obligation without confusing unchanged kappa arithmetic with a completed theorem.", + "allowed_variations": [ + "One stage or one explicit reserve/depth implication.", + "An independently checked same-domain proof repair, retaining all remaining assumptions." + ], + "scope_change_triggers": [ + "Importing the historical 57604 or 252 allowance without a selected-producer binding.", + "Calling a conditional fit lemma a full outer-proof adoption.", + "Replacing an actual selected stock coefficient with cutoff comparisons or a conditional fit inequality." + ], + "overlap_terms": [ + "selected stock", + "stock envelope", + "bootstrap cutoff", + "1956", + "1965", + "1990", + "2972", + "stock-margin-chain", + "actual_stock_coefficient" + ], + "existing_checks": [ + { + "scope": "Retained stock audit identifies missing actual selected-stage coefficients; later cutoff-chain arithmetic does not supply them.", + "evidence": "docs/research/research-family-status.md#revision-6-handoffs-source-archives-awaiting-independent-validation", + "remaining": "Derive one actual reserve/depth coefficient from the selected producer.", + "status": "reviewed", + "source_commit": "836b19bfa309ceafbc8ee32a15e8c4b10dde7e11", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Derive the exact free scratch inventory and complete local physical tape invoice of unchanged PR2915 kernels.added / pooled stream.add_pass, including encoded arithmetic, zero splits, marginal construction and cleanup.", + "scope_change_reason": "The whole-stage selected-stock card is narrowed to the ordered high ADD component expressly left open by PR2982. Conditional 8194/6748 coefficients, lcm-wrapper fits, cutoff arithmetic and PR3113 source gaps are already covered; the enclosing NODE/MERGE boundary has an active distinct claim. This result does not supply a whole-stage coefficient.", + "bottleneck_link": "An actual selected high-route reserve and H2 ledger needs this reached local operation. Ten or eleven scratch roles, six extra numerical words and a complete linear physical-I/O bound remove one implementation cost obligation; route setup, B1 swaps, physical backing and whole-stage composition remain separate.", + "budget_minutes": 60, + "stop_rule": "Stop after the source-bound ordered-ADD reserve/invoice and meaningful controls. If a numerical, constructor or disposal term cannot be bounded, report the missing term instead of claiming a complete local tariff. Do not expand the construction family or search for a scalar lowering.", + "outcome": "completed", + "evidence": "PROOF.md derives 10+[S>1] free scratch roles, six free numerical slots and T<=4096V (<=4102V including output disposal) for odd Q>=3 and canonical positive B,M,S with c in {-4,-2,-1,1,2,4}. RESULT.json binds 109 complete packets / 37241 payload bits, nine basis columns, 51 zero/padded countdown checks and 36 arithmetic checks through 82-bit words. Ten optimized control groups test capacity, endpoint/cost separation, source integrity and typed receipts.", + "author": "commdata2338", + "ai_assistance": "Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. OpenAI Codex (GPT-6 Astra) performed the derivation, implementation, checking and writing. No independent human review is claimed.", + "open_questions": [ + { + "question": "Can the remaining single-cube setup and operation charges be composed with this ordered-ADD invoice?", + "why_it_matters": "PR2982 only lifts an established single-cube tariff; complete encoded setup and the remaining operations are required before a complete local route bill.", + "first_step": "Audit unchanged high_route.extents/execute setup, then sum its initialized-bank and owned-output charges with sign/scaling and the two B1 swaps of each reversed-field ADD.", + "blocked_by": "Native B1 cost/refinement contracts and the separate sign/translation/setup ledgers remain obligations; this package does not discharge them." + }, + { + "question": "How do these local role/content bounds enter physical backing capacity and the actual caller stock ledger?", + "why_it_matters": "Occupied content and exact local traffic do not establish permanent backing allocation, simultaneous caller categories or uniform selected-stage stock.", + "first_step": "At the same chronological cuts, add entry residents, LEFT markers, templates, retained blank backing, native inventories and caller continuation resources without identifying them with occupied symbols.", + "blocked_by": "Actual backing/placement, native and recursive lifetimes, root stock and H2 composition remain open." + } + ], + "scope_key": "f5c32b23bcd01d2e356d", + "track": "adversarial-audit", + "selection": { + "method": "Handoff first, followed by specific-card retrieval; no random draw or reroll.", + "command": "python3 scripts/choose_research_task.py --task selected-stock-envelope --seed 00000000000000000000000000000000", + "handoff": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2319#discussioncomment-18977416", + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2319#discussioncomment-19001907" + }, + "domain": { + "modulus": "odd Q>=3", + "extents": "canonical positive B,M,S", + "coefficients": [ + -4, + -2, + -1, + 1, + 2, + 4 + ], + "numerical_width": "bit_length(Q)+1", + "entry_contract": "Initialized separate numerical bank and scratch pool; distinct borrowed roles, all borrowed heads restored; permanent inventories, templates, markers and already occupied roles charged to the caller.", + "finite_packets": "Q in {3,5,9,17}; four spectator choices, six coefficients, four occupied-pool fixtures, nine complete basis columns at Q=3.", + "traffic_currency": "Physical Tape reads, writes and unit moves, including acquisitions and arithmetic; not full finite-control machine steps." + }, + "scientific_status": "Scoped source-level proof and independent audit of unchanged retained modules, with finite corroboration; no formal-kernel proof, selected supplier admission, new kappa or frontier change.", + "family_expansion": { + "decision": "narrow", + "reason": "Closes one named local reserve/time implication without changing the construction or asserting a paid whole-caller bound." + }, + "dependency_heads": { + "PR2982_high_route_prefix_cost": "b9ac0d07eb9cdc31c4dca8dcc218943998edd3e8", + "PR2968_high_scaling_scratch_traffic": "cf4fc903951cd3f034531f7089d0a178f0f67b05", + "PR2915_selected_bit_fast_primitives": "fecc5a87574df441ddc3dad44f99fca9bd7fdd92", + "PR2915_main_compatibility_integration": "d112c69dcfae71849feb8ffdb463b244c16db545", + "PR2899_physical_ordinary_interchange": "2f0911ad735643a069b9790302fbf179e49f74f8", + "PR2809_selected_bit_physical_caller": "e7d93dd0de0bb81308bc3356f65eddeeb22fd712", + "PR2753_selected_bit_logical_caller": "7dba5452a4071a856a0b11cebdcd2d3b6bcd7659", + "PR2157_stream_routes": "eb1bf93950e9b14f7fadca7892866e9f29a26ad3", + "PR2877_positive_countdown_identity": "bbafe95af535004c7b605059e611cc8a569f88f6" + }, + "refresh_checkpoint": { + "utc": "2026-10-17T17:50:13Z", + "command": "git fetch origin main", + "canonical_main": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "priority_revision": 6, + "changes": "No commits or file changes since the scientific base; guidance, selected record and all source pins unchanged.", + "decision": "Continue the bounded audit and preserve frozen source inputs." + }, + "overlap": { + "queries": [ + "--task selected-stock-envelope", + "lease-end; scratch inventory; callback leases; fixed scratch", + "complete high route; route scratch; q\u00b2+128", + "high-field ADD; ordered high; kernels.added; single-cube" + ], + "method": "Repository helper against the complete cached anonymous metadata snapshot, plus merged main packages and the disposition ledger; no usable closed-PR snapshot.", + "preclaim_open_prs_utc": "2026-10-17T17:26:19.594925Z", + "preclaim_discussions_utc": "2026-10-17T17:27:03.117721Z", + "final_open_prs_utc": "2026-10-17T17:49:11.608413Z", + "final_discussions_utc": "2026-10-17T17:39:04.580509Z", + "coverage": { + "open_prs": 253, + "discussions": 2015, + "complete_pagination": true + }, + "nearest": "PR2982 prices the prefix wrapper (265V/277V); PR2968 prices high scaling (7/8 scratch roles); PR2877 supplies the all-width countdown identity, including its zero case, which PR2473 derived earlier together with the unpooled ADD's exact payload bill; PR2810 bounds stream.add_pass numerical Words outside callbacks by six; PR2905 and PR2923 bound its Counter and joint backing. This package adds the exact pooled scratch inventory, the pool acquisitions, the one-bit-suffix path, the marginal lifecycles and the explicit complete I/O constant including arithmetic. PR3041 and the active enclosing-node claim address different NODE/MERGE ownership operations.", + "limits": "Cached metadata is not a novelty certificate and may miss changes after its timestamps; arbitrary diffs and unpublished work are not searched." + } +} diff --git a/research/high-add-scratch-invoice/VERIFY.json b/research/high-add-scratch-invoice/VERIFY.json new file mode 100644 index 0000000000..170de9e668 --- /dev/null +++ b/research/high-add-scratch-invoice/VERIFY.json @@ -0,0 +1,55 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "research/bit2234-stock-threshold/README.md", + "research/community-frontier1094-audit/ASSEMBLY.json", + "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL.json", + "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "research/high-route-prefix-cost/README.md", + "research/high-scaling-scratch-traffic/README.md", + "research/idle-axis-hosting/PROOF.md", + "research/physical-ordinary-interchange/physical_words.py", + "research/pr589-five-helper-hosting/PROOF.md", + "research/pr589-five-helper-hosting/verify.py", + "research/recursive-parking-boundary/README.md", + "research/selected-bit-fast-primitives/high_route.py", + "research/selected-bit-fast-primitives/inputs/pr2157.tar", + "research/selected-bit-fast-primitives/inputs/pr2899.tar", + "research/selected-bit-fast-primitives/kernels.py", + "research/selected-bit-fast-primitives/stage_sources.py", + "research/selected-bit-local-ring-sweeps/PROOF.md", + "research/selected-bit-physical-caller/scratch_pool.py", + "research/selected-bit-recursive-closure/PROOF.md", + "upstream/build/sections/02-streams.tex" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Complete literal high ADDs, exact shell invoice, uniform traffic bound, tight capacity and semantic controls" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 120, + "checks": "Source, receipt, cost, width and capacity rejection controls under optimized Python" + } + ] +} diff --git a/research/high-add-scratch-invoice/invoice.py b/research/high-add-scratch-invoice/invoice.py new file mode 100644 index 0000000000..38138579ee --- /dev/null +++ b/research/high-add-scratch-invoice/invoice.py @@ -0,0 +1,53 @@ +"""Independent integer invoices; no retained implementation is imported.""" + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def counter(n, width): + """Fully drained pooled Counter, with width encoded digits on entry.""" + require(type(n) is int and n >= 0, "nonnegative count") + require(type(width) is int and width >= max(1, n.bit_length()), "count width") + return 15 * n + 14 * width - 5 * n.bit_count() + 37 + 4 * (n == 0) + + +def suffix_probe(suffix): + return 4 if suffix % 2 == 0 else 15 if suffix % 4 == 1 else 12 + + +def allocations(q, before, middle, suffix): + return (8 + 2 * before + 2 * before * q + 4 * before * middle * q + + 2 * before * middle * q * q * (suffix > 1)) + + +def shell(q, before, middle, suffix, *, zero_correction=True): + """All physical I/O outside the explicitly classified arithmetic calls.""" + require(type(q) is int and q >= 3 and q % 2, "odd high modulus") + require(all(type(n) is int and n > 0 for n in (before, middle, suffix)), + "positive canonical extents") + b = q.bit_length() + 1 + lengths = [n.bit_length() for n in (before, middle, suffix)] + volume = before * middle * q * q * suffix + # Unit coefficients permute offsets 0,...,q-1. One split is empty. + split = counter(0, b) + counter(q, b) + split += 2 * sum(counter(n, b) for n in range(1, q)) + if not zero_correction: + split -= 4 + result = sum(27 * length + 63 for length in lengths) + 23 * volume + 32 + result += 2 * counter(before, lengths[0] + 1) + result += 2 * before * counter(q, b) + result += 2 * before * q * counter(middle, lengths[1] + 1) + result += 2 * before * middle * (split + 2 * q * suffix_probe(suffix)) + if suffix > 1: + result += 2 * before * middle * q * q * counter(suffix, lengths[2] + 1) + return result + + +def limits(q, before, middle, suffix): + volume = before * middle * q * q * suffix + b = q.bit_length() + 1 + return dict(volume=volume, scratch=10 + (suffix > 1), numerical_extra=6, + shell=640 * volume, arithmetic=832 * before * q * b * b, + total=4096 * volume, disposed=4102 * volume) diff --git a/research/high-add-scratch-invoice/runtime.py b/research/high-add-scratch-invoice/runtime.py new file mode 100644 index 0000000000..7754649571 --- /dev/null +++ b/research/high-add-scratch-invoice/runtime.py @@ -0,0 +1,197 @@ +"""Authenticate and observe complete frozen modules, without source edits.""" + +import atexit +import hashlib +import json +import sys +from contextlib import ExitStack +from pathlib import Path +from types import ModuleType, SimpleNamespace +from unittest.mock import patch + +from invoice import require + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] + + +def authenticate(rows=None): + if rows is None: + rows = json.loads((PACKAGE / "SOURCES.json").read_bytes())["files"] + require(0 < len(rows) <= 64, "bounded input inventory") + bodies = {} + for row in rows: + if row["usage"] != "input": + continue + name = row["path"] + require(name not in bodies and not Path(name).is_absolute() + and ".." not in Path(name).parts, "unique contained source") + path = ROOT / name + require(path.is_file() and not path.is_symlink(), "regular source: " + name) + require(path.stat().st_size < 32 * 1024 * 1024, "bounded source file") + body = path.read_bytes() + require(hashlib.sha256(body).hexdigest() == row["sha256"], "source hash: " + name) + bodies[name] = body + require(sum(map(len, bodies.values())) < 64 * 1024 * 1024, "bounded input bytes") + return bodies + + +def module(name, relative, data): + result = ModuleType(name) + result.__file__ = str(ROOT / relative) + sys.modules[name] = result + exec(compile(data[relative], result.__file__, "exec"), result.__dict__) + return result + + +def close(): + for name in ("source", "stage_sources"): + temporary = getattr(sys.modules.get(name), "_temporary", None) + if temporary is not None: + temporary.cleanup() + + +def load(): + data = authenticate() + require("stage_sources" not in sys.modules, "cold source namespace") + prefix = "research/selected-bit-fast-primitives/" + stage = module("stage_sources", prefix + "stage_sources.py", data) + try: + stage.activate() + kernels = module("kernels", prefix + "kernels.py", data) + import physical_words + import scratch_pool + require(Path(scratch_pool.__file__).read_bytes() == + data["research/selected-bit-physical-caller/scratch_pool.py"], + "actual retained pool bytes") + require(Path(physical_words.__file__).read_bytes() == + data["research/physical-ordinary-interchange/physical_words.py"], + "actual retained physical arena bytes") + except BaseException: + close() + raise + atexit.register(close) + names = ("words", "records", "stream", "cardinality", "cardinal_counts") + return SimpleNamespace(kernels=kernels, pool=scratch_pool, physical=physical_words, + **{name: sys.modules[name] for name in names}) + + +class Traffic: + """Raw physical methods counted once; nested arithmetic intervals are disjoint.""" + + def __init__(self, rt): + self.rt, self.total, self.arithmetic, self.depth = rt, 0, 0, 0 + self.intervals = {} + + def operation(self, method): + def observed(*args, **kwargs): + self.total += 1 + return method(*args, **kwargs) + return observed + + def numerical(self, name, method): + def observed(*args, **kwargs): + outer, start = self.depth == 0, self.total + self.depth += 1 + try: + return method(*args, **kwargs) + finally: + self.depth -= 1 + if outer: + elapsed = self.total - start + self.arithmetic += elapsed + item = self.intervals.setdefault(name, [0, 0, 0]) + item[0] += 1 + item[1] += elapsed + item[2] = max(item[2], elapsed) + return observed + + def installed(self): + stack = ExitStack() + for name in ("read", "write", "step"): + cls = self.rt.records.Tape + stack.enter_context(patch.object(cls, name, self.operation(getattr(cls, name)))) + targets = [(self.rt.kernels, "fixed_coefficient"), + (self.rt.words.Ring, "multiply")] + targets += [(self.rt.words.Unsigned, n) for n in + ("compare", "subtract_exact", "increment_in_place")] + targets += [(self.rt.words.Arena, n) for n in ("zero", "free", "free_many")] + for owner, name in targets: + stack.enter_context(patch.object(owner, name, + self.numerical(name, getattr(owner, name)))) + return stack + + +def encoded(tape): + physical = getattr(tape, "physical", tape) + return bytes(physical.cells), physical.head + + +def physical_total(tapes): + unique = {id(tape): tape for tape in tapes} + return sum(t.meter.reads + t.meter.writes + t.meter.moves for t in unique.values()) + + +def prepare(rt, q, before, middle, suffix, coefficient, spare, occupied, pooled, + numerical_capacity=8, basis=None, numerical_occupied=0): + require(q <= 129 and before <= 4 and middle <= 4 and suffix <= 5, "fixture caps") + require(before * middle * q * q * suffix <= 100000, "payload cap") + require(coefficient in (-4, -2, -1, 1, 2, 4), "selected coefficient alphabet") + bank = rt.physical.PhysicalArena(numerical_capacity) + Count = rt.cardinal_counts.Count + value = Count.literal(q) + bank.prepare(value) + modulus = bank.load(value) + ring = rt.words.Ring(modulus) + value.close() + for _ in range(numerical_occupied): + bank.literal(q - 1) + extents = [Count.literal(v) for v in (before, middle, suffix)] + pool = rt.pool.ScratchPool(spare + occupied) + held = [pool.acquire() for _ in range(occupied)] + require(not pooled or held, "pooled source already owned") + source = held[0] if pooled else rt.records.Tape() + for address in range(before * middle * q * q * suffix): + value = (address * 11 ^ address // 3 ^ 5) & 1 if basis is None else int(address == basis) + source.append(value) + source.rewind() + for lease in held[int(pooled):]: + lease.append(1) + lease.append(0) + lease.rewind() + tapes = [getattr(source, "physical", source), *pool.tapes, bank.template.tape] + tapes += [word.tape for word in bank.words] + [v.tape for v in extents] + return SimpleNamespace(bank=bank, modulus=modulus, ring=ring, extents=extents, + pool=pool, held=held, source=source, tapes=tapes) + + +def endpoint(fixture, output, q, before, middle, suffix, coefficient): + original = encoded(fixture.source)[0] + expected = bytearray(before * q * middle * q * suffix) + for address in range(len(expected)): + rest, tail = divmod(address, suffix) + rest, y = divmod(rest, q) + rest, gap = divmod(rest, middle) + prefix, x = divmod(rest, q) + target = ((((prefix * q + x) * middle + gap) * q + + (y + coefficient * x) % q) * suffix + tail) + expected[target] = original[address + 1] + actual = encoded(output)[0] + require(actual[1:len(expected) + 1] == expected, "complete modular ADD endpoint") + require(all(v == 4 for v in actual[len(expected) + 1:]), "no extra output body") + require(fixture.source.head == output.head == 1, "canonical endpoint heads") + + +def dispose(fixture, output=None): + if output is not None: + output.clear() + # Failure controls clean their fixture explicitly; no source exception theorem. + for lease in list(fixture.pool.live.values()): + lease.clear() + fixture.pool.empty() + if fixture.source not in fixture.held: + fixture.source.clear() + for count in fixture.extents: + count.close() + fixture.bank.rollback(set()) + fixture.bank.erase_owned() diff --git a/research/high-add-scratch-invoice/test_verify.py b/research/high-add-scratch-invoice/test_verify.py new file mode 100644 index 0000000000..24b1612b65 --- /dev/null +++ b/research/high-add-scratch-invoice/test_verify.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 +"""Fault controls for the source-bound capacity and physical-cost claims.""" + +import copy +import json +import sys +import unittest +from pathlib import Path +from unittest.mock import patch + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import invoice +import runtime +import verify + + +class Controls(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.rt = runtime.load() + + def test_exact_scratch_capacity_and_one_short(self): + for suffix in (1, 3): + for pooled in (False, True): + with self.subTest(suffix=suffix, pooled=pooled): + verify.run_case(self.rt, 5, 1, 1, suffix, -2, + occupied=2, pooled=pooled) + with self.assertRaisesRegex(ValueError, "fixed scratch role inventory exhausted"): + verify.run_case(self.rt, 5, 1, 1, suffix, -2, + occupied=2, pooled=pooled, spare=9 + (suffix > 1)) + f = runtime.prepare(self.rt, 5, 1, 1, 3, 2, 11, 2, True) + try: + original = runtime.encoded(f.source) + for coefficient in (-4, 1, 2): + trace = runtime.Traffic(self.rt) + with trace.installed(), f.pool.install(): + output = self.rt.kernels.added(f.source, f.ring, *f.extents, coefficient) + runtime.endpoint(f, output, 5, 1, 1, 3, coefficient) + self.assertEqual(trace.total - trace.arithmetic, invoice.shell(5, 1, 1, 3)) + output.clear() + self.assertEqual(set(f.pool.live.values()), set(f.held)) + self.assertEqual(runtime.encoded(f.source), original) + finally: + runtime.dispose(f) + + def test_six_numerical_slots_are_needed_by_one_fixture(self): + row = verify.run_case(self.rt, 3, 1, 1, 1, -4) + self.assertEqual(row["numerical_extra"], 6) + with self.assertRaisesRegex(ValueError, "fixed register inventory"): + verify.run_case(self.rt, 3, 1, 1, 1, -4, numerical_capacity=7) + guarded = verify.run_case(self.rt, 3, 1, 1, 1, -4, + numerical_capacity=10, numerical_occupied=2) + self.assertEqual(guarded["numerical_extra"], 6) + + def test_wrong_coefficient_rejects_at_endpoint(self): + original = self.rt.kernels.fixed_coefficient + def opposite(ring, value): + return original(ring, -value) + with patch.object(self.rt.kernels, "fixed_coefficient", opposite): + with self.assertRaisesRegex(ValueError, "complete modular ADD endpoint"): + verify.run_case(self.rt, 5, 1, 1, 2, 2) + + def test_endpoint_preserving_cost_mutation(self): + original = self.rt.stream.copy_blocks + def extra_read(source, *args, **kwargs): + result = original(source, *args, **kwargs) + source.read() + return result + with patch.object(self.rt.stream, "copy_blocks", extra_read): + with self.assertRaisesRegex(ValueError, "exact non-arithmetic invoice"): + verify.run_case(self.rt, 5, 2, 1, 2, 2) + + def test_noncanonical_borrow_preserves_endpoint_but_changes_cost(self): + original = verify.prepare + def padded(*args, **kwargs): + fixture = original(*args, **kwargs) + count = fixture.extents[0] + count.msb() + count.step(1) + count.tape.write(0) + count.step(1) + count.tape.write(3) + count.rewind() + return fixture + with patch.object(verify, "prepare", padded): + with self.assertRaisesRegex(ValueError, "exact non-arithmetic invoice"): + verify.run_case(self.rt, 5, 2, 1, 2, 2) + + def test_empty_split_is_not_the_positive_formula(self): + for before, middle in ((1, 1), (2, 3)): + row = verify.run_case(self.rt, 3, before, middle, 1, 1) + wrong = invoice.shell(3, before, middle, 1, zero_correction=False) + self.assertEqual(row["shell"] - wrong, 8 * before * middle) + + def test_source_corruption_rejected_before_loading(self): + rows = json.loads((runtime.PACKAGE / "SOURCES.json").read_bytes())["files"] + for wanted in ("kernels.py", "pr2899.tar", "scratch_pool.py"): + changed = copy.deepcopy(rows) + row = next(r for r in changed if r["path"].endswith(wanted)) + row["sha256"] = "0" * 64 + with self.subTest(wanted=wanted): + with self.assertRaisesRegex(ValueError, "source hash"): + runtime.authenticate(changed) + + def test_typed_receipt_does_not_accept_boolean_alias(self): + original = {"cases": [1], "scratch": 10} + with self.assertRaisesRegex(ValueError, "complete typed receipt"): + verify.check_receipt(original, {"cases": [True], "scratch": 10}) + + def test_pooled_counter_zero_and_padding(self): + self.assertEqual(verify.counter_controls(self.rt), 51) + + def test_integer_width_absorption_and_invoice_domain(self): + for q in range(3, 4096, 2): + b = q.bit_length() + 1 + self.assertLessEqual(b * b, 4 * q) + self.assertLessEqual(invoice.shell(q, 1, 1, 1), 640 * q * q) + with self.assertRaisesRegex(ValueError, "odd high modulus"): + invoice.shell(4, 1, 1, 1) + with self.assertRaisesRegex(ValueError, "positive canonical extents"): + invoice.shell(3, 0, 1, 1) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/high-add-scratch-invoice/verify.py b/research/high-add-scratch-invoice/verify.py new file mode 100644 index 0000000000..4bd5b6d4fd --- /dev/null +++ b/research/high-add-scratch-invoice/verify.py @@ -0,0 +1,200 @@ +#!/usr/bin/env python3 +"""Source-bound high ADD capacity, endpoint and physical invoice audit.""" + +import argparse +import hashlib +import json +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from invoice import allocations, counter, limits, require, shell +from runtime import (PACKAGE, Traffic, dispose, encoded, endpoint, load, + physical_total, prepare) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) + + +def check_receipt(actual, expected): + require(canonical(actual) == canonical(expected), "complete typed receipt") + + +def primitive_bounds(traffic, q, before): + b = q.bit_length() + 1 + expected = { + "fixed_coefficient": (2, 256 * b * b), + "compare": (2, 18 * b), "zero": (2 * before, 13 * b), + "multiply": (2 * before * q, 300 * b * b), + "subtract_exact": (2 * before * q, 36 * b), + "free_many": (2 * before * q, 20 * b), + "increment_in_place": (2 * before * (q - 1), 10 * b), + "free": (2 * before + 2, 10 * b), + } + require(set(traffic.intervals) == set(expected), "complete arithmetic partition") + for name, (count, bound) in expected.items(): + row = traffic.intervals[name] + require(row[0] == count and row[2] <= bound, "arithmetic count/bound: " + name) + + +def run_case(rt, q, before, middle, suffix, coefficient, *, occupied=0, + pooled=False, basis=None, spare=None, numerical_capacity=8, + numerical_occupied=0): + bound = limits(q, before, middle, suffix) + f = prepare(rt, q, before, middle, suffix, coefficient, + bound["scratch"] if spare is None else spare, occupied, pooled, + numerical_capacity, basis, numerical_occupied) + original = dict(source=encoded(f.source), counts=[encoded(v.tape) for v in f.extents], + numerical={slot: encoded(f.bank.words[slot].tape) for slot in f.bank.live}) + held = [encoded(lease) for lease in f.held] + residents = set(f.bank.live) + start, acquisitions = physical_total(f.tapes), f.pool.allocations + traffic, output = Traffic(rt), None + try: + with traffic.installed(), f.pool.install(): + output = rt.kernels.added(f.source, f.ring, *f.extents, coefficient) + require(traffic.total == physical_total(f.tapes) - start, "unique physical meters") + validate_boundary(f, output, original, held, residents, q, before, middle, + suffix, coefficient, occupied, bound) + require(traffic.total - traffic.arithmetic == shell(q, before, middle, suffix), + "exact non-arithmetic invoice") + primitive_bounds(traffic, q, before) + require(f.pool.allocations - acquisitions == allocations(q, before, middle, suffix), + "exact lease acquisition count") + require(traffic.arithmetic <= bound["arithmetic"] and + traffic.total - traffic.arithmetic <= bound["shell"] and + traffic.total <= bound["total"], "uniform complete local I/O bound") + row = dict(q=q, before=before, middle=middle, suffix=suffix, coefficient=coefficient, + basis=basis, occupied=occupied, pooled_source=pooled, volume=bound["volume"], + scratch_peak=f.pool.peak - occupied, numerical_extra=f.bank.meter.peak_live - len(residents), + acquisitions=f.pool.allocations - acquisitions, traffic=traffic.total, + arithmetic=traffic.arithmetic, shell=traffic.total - traffic.arithmetic, + arithmetic_intervals=traffic.intervals) + output.clear() + output = None + require(physical_total(f.tapes) - start == traffic.total + 5 * bound["volume"] + 7, + "complete returned-output disposal invoice") + require(set(f.pool.live.values()) == set(f.held), "only entry leases after disposal") + return row + finally: + dispose(f, output) + + +def validate_boundary(f, output, original, held, residents, q, before, middle, + suffix, coefficient, occupied, bound): + observed = dict(source=encoded(f.source), counts=[encoded(v.tape) for v in f.extents], + numerical={slot: encoded(f.bank.words[slot].tape) for slot in residents}) + require(original == observed, "borrowed payload/count/numerical bytes and heads preserved") + require(held == [encoded(lease) for lease in f.held], "all occupied entry roles preserved") + require(set(f.bank.live) == residents, "numerical residents restored") + require(f.bank.meter.peak_live - len(residents) <= 6, "six additional numerical slots") + require(f.pool.peak == occupied + bound["scratch"], "exact free scratch inventory") + require(set(f.pool.live.values()) == {*f.held, output}, "only owned output remains") + require(output not in f.held and output is not f.source, "distinct owned output") + endpoint(f, output, q, before, middle, suffix, coefficient) + + +def counter_controls(rt): + cases = 0 + for n in range(17): + for extra in (0, 1, 3): + width = max(2, n.bit_length()) + extra + bank = rt.physical.PhysicalArena(2) + maximum = rt.cardinal_counts.Count.literal(2 ** (width - 2)) + bank.prepare(maximum) + value = bank.literal(n) + pool = rt.pool.ScratchPool(1) + tapes = [value.tape, *pool.tapes] + start = physical_total(tapes) + with pool.install(): + item = rt.stream.Counter(value) + while not item.finished: + item.decrement() + item.close() + require(physical_total(tapes) - start == counter(n, width), "padded/zero counter invoice") + require(counter(n, width) <= 16 * n + 16 * width + 64, "counter majorant") + maximum.close() + bank.free(value) + bank.erase_owned() + pool.empty() + cases += 1 + return cases + + +def large_word_controls(rt): + """Probe the width-dependent arithmetic tariff without materializing Q^2 bits.""" + checks = 0 + for q in (129, 65537, 2 ** 80 + 7): + b = q.bit_length() + 1 + bank = rt.physical.PhysicalArena(8) + encoded_q = rt.cardinal_counts.Count.literal(q) + bank.prepare(encoded_q) + modulus = bank.load(encoded_q) + ring = rt.words.Ring(modulus) + for coefficient in (-4, 1, 2): + trace = Traffic(rt) + with trace.installed(): + value = rt.kernels.fixed_coefficient(ring, coefficient) + require(trace.total <= 256 * b * b, "large fixed-coefficient bill") + require(word_value(value) == coefficient % q, "large fixed coefficient") + checks += 1 + for x in (0, 1, q - 1): + argument = bank.literal(x) + trace = Traffic(rt) + with trace.installed(): + product = ring.multiply(value, argument) + require(trace.total <= 300 * b * b, "large multiplication bill") + require(word_value(product) == coefficient * x % q, "large product") + bank.free_many(argument, product) + checks += 1 + bank.free(value) + require(bank.meter.peak_live <= 8, "large numerical capacity") + ring.close() + bank.free(modulus) + bank.erase_owned() + encoded_q.close() + return checks + + +def word_value(word): + # Checker-only decoding, outside every measured source interval. + digits = word.tape.cells[1:] + require(3 in digits, "word right delimiter") + return sum(bit << index for index, bit in enumerate(digits[:digits.index(3)])) + + +def result(rt): + cases = [] + for q in (3, 5, 9, 17): + for before, middle, suffix in ((1, 1, 1), (1, 1, 2), (2, 3, 1), (2, 1, 3)): + for coefficient in (-4, -2, -1, 1, 2, 4): + cases.append(run_case(rt, q, before, middle, suffix, coefficient)) + for suffix in (1, 3): + for pooled in (False, True): + cases.append(run_case(rt, 5, 2, 2, suffix, -2, occupied=3, pooled=pooled)) + for column in range(9): + cases.append(run_case(rt, 3, 1, 1, 1, -1, basis=column)) + return dict(status="PASS_HIGH_ADD_SCRATCH_INVOICE", cases=len(cases), + payload_bits=sum(row["volume"] for row in cases), basis_columns=9, + counter_cases=counter_controls(rt), large_word_checks=large_word_controls(rt), + scratch_roles=[10, 11], numerical_extra=6, + uniform_io_coefficient=4096, disposed_io_coefficient=4102, + cases_sha256=hashlib.sha256(canonical(cases).encode()).hexdigest(), cases_detail=cases) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--emit", action="store_true", help="print a new receipt without replacing it") + args = parser.parse_args() + actual = result(load()) + if args.emit: + print(json.dumps(actual, indent=2, sort_keys=True)) + else: + check_receipt(actual, json.loads((PACKAGE / "RESULT.json").read_bytes())) + print(actual["status"], "cases=" + str(actual["cases"]), + "payload_bits=" + str(actual["payload_bits"]), "scratch=10,11 numerical_extra<=6 io<=4096V") + + +if __name__ == "__main__": + main()