diff --git a/research/centre-shared-kcall-charged-seed615415/README.md b/research/centre-shared-kcall-charged-seed615415/README.md new file mode 100644 index 0000000000..fab604d34a --- /dev/null +++ b/research/centre-shared-kcall-charged-seed615415/README.md @@ -0,0 +1,196 @@ +# Fully charged favourable relaxation for a k-call shared centre window + +**Scoped planning result for the `centre-path-sharing` card (construction reading). +No shared centre is constructed or admitted, and no new kappa is claimed.** + +The card asks whether the 64-per-call centre path (eight rank-8 COPY/ERASE totals +through the private temporary) can be shared across calls or shrunk, and its +construction method asks for a fully charged favourable relaxation for sharing +one centre path across k calls, including restoration, hosting and precision. +This package supplies that relaxation for the one sharing pattern whose contract +is pinned: the shared-sink return window of +[centre-shared-return-guard](../centre-shared-return-guard/README.md) +(PR1708 forward fanout / PR1748 reverse phase lineage), generalised from two +panels to k panels. The three named costs are charged explicitly instead of +being left as free overhead, and the ceiling is computed with +`ceiling.ceiling(centre=...)` from [complex-local-word-ceiling](../complex-local-word-ceiling/ceiling.py). + +## Conversion contract + +The pinned contract's literal backward centre-phase bill is 16 rank-8 returns, +368 ADDs and 32 CLEARs for two literal phases, and 8 rank-8 returns, 360 ADDs +and 16 CLEARs for the two-call fused window (its `RESULT.json` counts; the +k = 1 and k = 2 formulas below reproduce all six numbers exactly). One fused +k-call window gathers k panels before one ascent per centre and writes the +shared sink once. The conversion to the ceiling model's mass units is: + +| Macro or obligation | Charge | +| --- | --- | +| One rank-8 COPY/ERASE total | one rank-8 child, 8 mass units (ascent and erase inside) | +| One ADD | one rank-1 child | +| One scratch CLEAR | one rank-1 child (restoration of the private temporary) | +| Hosting of shared rows across the window | 0 mass, idle-axis-hosting lemma | +| Precision: k summed panels | `ceil(log2 k)` magnitude bits on 8 shared totals, each bit one rank-1 unit per total per window | + +Per call, a literal phase pays 8 rank-8 + 184 ADD + 8 scratch CLEAR; a fused +k-call window pays `8/k` rank-8, `176 + 8/k` ADD and `8/k` scratch CLEAR per +call. The k = 2 row matches levers.py's ideal lever "shared by two calls +(copies and charge halved)", and the charged profile exceeds it slightly because +the ADD and scratch-CLEAR savings are credited too. + +Restoration is the scratch CLEAR set (charged) plus the contracted zero scratch +endpoint; scratch dirt is not promised to return to its incoming value. Hosting +is charged zero mass on the idle-axis-hosting lemma, on the contract's +constraints: the shared rows, panels and scratch must be untouched across the +window (no source or panel mutation, observation or required canonical +checkpoint may intervene). Precision is charged at the derived bit count +(`additional_magnitude_bits_sufficient = 1` for k = 2 in the pinned guard; +`ceil(log2 k)` for k panels by envelope summation). + +## Results: changed centre charge, copy profile and charged ceiling + +All values exact; ceilings are certified brackets at grid `1e-12`; ratios are +against the baseline ceiling `0.001690054109...`. `kappa` uses the retained +planning transfer `kappa < a/(1+a)`. + +| k | centre | copy children (rank-8/call) | restoration (scratch CLEAR/call) | hosting | precision (rank-1/call) | rank-1/call | gross ceiling | fully charged ceiling | kappa cap | ratio | +| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | +| 1 | 64 | 8 | 8 | 0 | 0 | 2412 | 0.001690054110 | 0.001690054110 | 0.001687202646 | 1.000 | +| 2 | 32 | 4 | 4 | 0 | 4 | 2408 | 0.003217794406 | 0.003215381840 | 0.003205076296 | 1.903 | +| 4 | 16 | 2 | 2 | 0 | 4 | 2404 | 0.003984054054 | 0.003981062728 | 0.003965276713 | 2.356 | +| 8 | 8 | 1 | 1 | 0 | 3 | 2401 | 0.004367783311 | 0.004365321517 | 0.004346348309 | 2.583 | +| 16 | 4 | 1/2 | 1/2 | 0 | 2 | 2399 | 0.004559798056 | 0.004558083777 | 0.004537401919 | 2.697 | + +The k = 1 row is the selected word and reproduces the published baseline +ceiling exactly. The k = 2 fully charged ceiling is `a < 0.003215381840`, +`kappa < 0.003205076296`; charging restoration, hosting and precision moves the +gross ceiling by only 0.075 per cent. Rows k >= 4 use the derived k-panel +generalisation of the pinned two-panel contract, not a pinned construction. + +## Break-even overhead at k = 2 (rank-1 children per call) + +The named charges are not the binding constraint; how much *additional* +unmodelled overhead the window can absorb is. Two treatments, both sharp +(H passes the exact moment test at the threshold and H+1 fails): + +| Treatment | keep full bit-limited gain (at T2) | at c_bit | any gain over selected | +| --- | ---: | ---: | ---: | +| overhead displaces idle mass (coverage identity kept) | 1650 (identity-feasible maximum) | 1650 (identity-feasible maximum) | 1650 (identity-feasible maximum) | +| overhead adds pure moment (predecessor treatment) | 31 | 31 | 32 | + +Under the ceiling model's own accounting (extra children displace idle mass at +rank 51), consuming the *entire* idle remainder of 1650 rank-1 units per call +still leaves the ceiling above the complex-unbinding point +`T2 = 1733427039589844234749/(10^24 - 1)` and above the selected endpoint: the +break-even is capped by coverage-identity feasibility, not by cost. Under the +additive treatment of [centre-sharing-overhead-budget](../centre-sharing-overhead-budget/README.md) +(overhead as pure moment cost), at most 31 rank-1 children per call fit before +the full bit-limited gain is lost and 32 before any gain remains; their sharp +budgets on the identity profile are 4415/144 = 30.66 and 4591/144 = 31.88 per +call. The verifier recomputes both under its ideal-packing relaxation (30.98 and +32.19, ratios 1.010 and 1.010) and the residual difference is the ideal-packing +versus actual-histogram moment, not a shared term. + +## Screen and what the relaxation decides + +The card's first experiment screens the route on the levers.py scale: the ideal +shared-by-two ceiling ratio is 1.90 against the 1.10 stop threshold, so the +route survives the screen. The whole-bound gain is a different quantity: the bit +supplier binds at `c_bit = 0.001733427039589844234749`, so any mechanism whose +complex ceiling reaches that point gains at most the bit-limited +`kappa = 865213734911801/5*10^17 = 0.001730427469823602` (+3.4536 per cent over +the selected record). The fully charged k = 2 window clears that point with the +wide margins recorded above, so **for this pattern the cost side of sharing +(restoration, hosting, precision) is not the blocker**. The blockers are +eligibility and demand coupling, below. + +## Scope and limits + +- This is a favourable relaxation for one sharing pattern: a fused window whose + k calls share sink rows, return operator and chart. It grants eligibility. + [centre-shared-return-guard](../centre-shared-return-guard/README.md) supplies + neither a full pair of fused local calls nor an eligible selected owner pair; + [p112-batch-centre-floor](../p112-batch-centre-floor/README.md) proves that + independent root-code demands cannot share at all (copied-pairing-rank bill + `64k`), so the pattern needs genuinely coupled demands. +- The conversion contract (macro to rank-mass) is stated, not inherited: each + scalar total pays one child at its pairing rank. Changing it changes the rows. +- Hosting is charged zero mass on the idle-axis-hosting lemma with its window + constraints named; a window crossed by an observation or checkpoint cannot + host, and then the per-use copy/erase returns (no saving). +- Precision is charged at the sufficient bit count for positive envelopes only. + The pinned guard explicitly does not establish rounding-error, native guard, + tape or global admission, and the fused primitives at width `mu+1` price at + the invoice level (outside this mass model). +- The consumer and central readout are unchanged: the fused window writes the + same endpoint rows as the separate phases (linearity of the shared-sink + write), so the readout count is neither saved nor added. +- No new kappa, supplier admission or eligible pair is claimed; the selected + record is unchanged. Fractional child counts are allowed by the relaxation, + as in the incumbent ceiling model. + +## Reproduce + +Standard library only, from the repository root (Python 3.12): + +```sh +python3 -I -B research/centre-shared-kcall-charged-seed615415/verify.py +python3 scripts/research_package.py --package research/centre-shared-kcall-charged-seed615415 --check-only +``` + +Expected first output: `PASS_CENTRE_SHARED_KCALL_CHARGED k2_charged_ceiling 0.003215381840 k2_ratio 1.902532 H_bit_displace 1650 H_bit_additive 31 H_any_additive 32 no_new_kappa`. +`verify.py --write` regenerates `RESULT.json`; the normal run requires the +committed file to equal the recomputation byte for byte. Controls (each enforced, +not advisory): + +- the k = 1 and k = 2 conversion formulas reproduce the pinned separate bill + (16/368/32) and fused bill (8/360/16) exactly, and the precision bit count + matches the pinned guard; +- the k = 1 profile equals the selected word and reproduces the published + baseline ceiling to the grid; +- one extra rank-1 child lowers the k = 2 charged ceiling, and a doubled + precision charge lowers it again; +- every break-even is sharp, or explicitly capped by identity feasibility; +- the additive identity-profile budgets stay within a factor of two of + centre-sharing-overhead-budget (measured 1.010 and 1.010). + +## Open next questions + +- **Is any selected call pair eligible for a fused window?** Trace one candidate + pair through the selected owner map and call schedule: shared post-A sink + rows, identical return operator and chart, and an uninterrupted window with no + intervening observation or checkpoint. *Why it matters:* the relaxation shows + cost is not the blocker for this pattern; eligibility is. *First step:* + extract the backward centre-phase invocations of two calls that share sink + rows from the selected replay schedule. *Blocked by:* the owner map and + schedule are not in this package; the guard leaves this open explicitly. +- **Which selected call pairs have coupled rather than independent demands?** + *Why it matters:* the `64k` copied-pairing-rank floor of p112-batch-centre-floor + blocks sharing for independent root-code demands; only coupled (shared-sink) + demands can use this pattern. *First step:* classify the 144 calls of the + selected record by shared sink rows and return operator. *Blocked by:* a + machine-readable demand-coupling table for the selected record. +- **Does the fused primitive tariff fit the scalar guard?** The guard prices + fused primitives at `mu+1`; centre-sharing-overhead-budget leaves about + 654,144 extra macros per call of primitive headroom, and the fused window adds + none (it removes 32 macros per two calls). *Why it matters:* it would close + the invoice-level obligation the mass model cannot see. *First step:* + instantiate the two-panel fused bill under the selected invoice formulas. + *Blocked by:* the actual tariffs and precision headroom are uninstantiated. + +## Credit + +The sharing constructions are 1337isnot1337's PR1708 (forward fanout) and +ToikY's PR1748 (reverse phase). The pinned two-panel contract, its exact bill +and its one-magnitude-bit precision guard are ToikY's +[centre-shared-return-guard](../centre-shared-return-guard/README.md); its +`RESULT.json` counts are used unchanged as a pinned input. The packing-ceiling +model, the lever table and the coverage identity are Douglas Colkitt's +[complex-local-word-ceiling](../complex-local-word-ceiling/README.md) and +PR1012. The additive overhead budgets and the bit endpoint are +[centre-sharing-overhead-budget](../centre-sharing-overhead-budget/README.md) +(prepared for rtyu193-rgb). The hosting lemma is +[idle-axis-hosting](../idle-axis-hosting/PROOF.md). The `64k` floor for +independent demands is [p112-batch-centre-floor](../p112-batch-centre-floor/README.md). +Prepared by Aaron Wang with help from opencode (substantial AI assistance; no +model named; no independent human review claimed). Apache-2.0. diff --git a/research/centre-shared-kcall-charged-seed615415/RESULT.json b/research/centre-shared-kcall-charged-seed615415/RESULT.json new file mode 100644 index 0000000000..90c3cd1ba2 --- /dev/null +++ b/research/centre-shared-kcall-charged-seed615415/RESULT.json @@ -0,0 +1,332 @@ +{ + "baseline_ceiling": { + "hi": "169005411/100000000000", + "hi_dec": "0.001690054110", + "lo": "1690054109/1000000000000", + "lo_dec": "0.001690054109" + }, + "break_even_k2_rank1_per_call": { + "additive": { + "any_gain_at_selected": { + "H": 32, + "H_feasible_max": 100032, + "capped_by_identity": false, + "moment_hi_at_H": "28947136953701027538155619106050757626824753261255661535339183994446828235751/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "sharp": true + }, + "full_gain_at_T2": { + "H": 31, + "H_feasible_max": 100031, + "capped_by_identity": false, + "moment_hi_at_H": "14474004265228675610539889913072020026601914580195513627348865707445185170495/14474011154664524427946373126085988481658748083205070504932198000989141204992", + "sharp": true + }, + "full_gain_at_c_bit": { + "H": 31, + "H_feasible_max": 100031, + "capped_by_identity": false, + "moment_hi_at_H": "115792034121829404884319118720349060089928577086300663048001824739656504363997/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "sharp": true + } + }, + "displace": { + "any_gain_at_selected": { + "H": 1650, + "H_feasible_max": 1650, + "capped_by_identity": true, + "moment_hi_at_H": "115448880228476980638946026023802784317963365194874150355235742520426192844567/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "sharp": false + }, + "full_gain_at_T2": { + "H": 1650, + "H_feasible_max": 1650, + "capped_by_identity": true, + "moment_hi_at_H": "115474329560080292873996521850731178592816140929544601850855899183198545209815/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "sharp": false + }, + "full_gain_at_c_bit": { + "H": 1650, + "H_feasible_max": 1650, + "capped_by_identity": true, + "moment_hi_at_H": "115474329560080292873996521089581777952328426081395167148201697486566429976699/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "sharp": false + } + } + }, + "controls": [ + "k=1 and k=2 conversion formulas reproduce the pinned separate and fused bills exactly", + "k=1 profile equals the selected word and reproduces the published baseline ceiling", + "one extra rank-1 child lowers the k=2 charged ceiling", + "double precision charge lowers the k=2 charged ceiling", + "break-even overheads are sharp: H passes the moment test and H+1 fails (or H is the identity-feasible maximum)", + "additive identity-profile budgets stay within a factor of two of centre-sharing-overhead-budget" + ], + "conversion_contract": { + "add": "one ADD macro = one rank-1 child", + "hosting": "0 mass under the idle-axis-hosting lemma; window constraints named in README", + "precision": "ceil(log2 k) magnitude bits on 8 shared totals, each charged one rank-1 unit per total per window", + "rank8_total": "one rank-8 COPY/ERASE total = one rank-8 child (8 mass units)", + "scratch_clear": "one scratch CLEAR = one rank-1 child" + }, + "cross_check_overhead_budget_rank1": { + "note": "their engine is the full invoice moment on the actual idle histogram; ours is the ideal-packing relaxation; equality not required", + "ours_any_estimate": "32.194417", + "ours_full_estimate": "30.976264", + "ratio_any": "1.009801", + "ratio_full": "1.010324", + "their_any_gain_per_call": "4591/144", + "their_full_gain_per_call": "4415/144" + }, + "endpoints": { + "T2": "1733427039589844234749/999999999999999999999999", + "a_selected": "836330098538459/499163669901461541", + "c_bit": "1733427039589844234749/1000000000000000000000000" + }, + "model": { + "baseline_centre": 64, + "baseline_word": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "families": 896, + "m": 73, + "stages": 9, + "w": "896/9" + }, + "pinned_bill_reproduction": { + "fused_per_window": { + "add": 360, + "clear": 16, + "r8": 8 + }, + "separate_per_two_calls": { + "add": 368, + "clear": 32, + "r8": 16 + } + }, + "rows": [ + { + "centre_charge_per_call": "64", + "charged_ceiling": { + "hi": "169005411/100000000000", + "hi_dec": "0.001690054110", + "lo": "1690054109/1000000000000", + "lo_dec": "0.001690054109" + }, + "charged_kappa_cap": "0.001687202646", + "charged_profile": { + "1": "2412", + "2": "418", + "3": "432", + "4": "142", + "5": "82", + "8": "8" + }, + "charged_ratio_vs_baseline": "1.000000", + "copy_children_r8_per_call": "8", + "gross_ceiling": { + "hi": "169005411/100000000000", + "hi_dec": "0.001690054110", + "lo": "1690054109/1000000000000", + "lo_dec": "0.001690054109" + }, + "gross_profile": { + "1": "2412", + "2": "418", + "3": "432", + "4": "142", + "5": "82", + "8": "8" + }, + "hosting_mass_per_call": "0", + "idle_mass_charged": "1646", + "idle_mass_gross": "1646", + "k": 1, + "magnitude_bits": 0, + "precision_rank1_per_call": "0", + "rank1_children_per_call": "2412", + "restoration_scratch_clear_per_call": "8" + }, + { + "centre_charge_per_call": "32", + "charged_ceiling": { + "hi": "40192273/12500000000", + "hi_dec": "0.003215381840", + "lo": "3215381839/1000000000000", + "lo_dec": "0.003215381839" + }, + "charged_kappa_cap": "0.003205076296", + "charged_profile": { + "1": "2408", + "2": "418", + "3": "432", + "4": "142", + "5": "82", + "8": "4" + }, + "charged_ratio_vs_baseline": "1.902532", + "copy_children_r8_per_call": "4", + "gross_ceiling": { + "hi": "1608897203/500000000000", + "hi_dec": "0.003217794406", + "lo": "643558881/200000000000", + "lo_dec": "0.003217794405" + }, + "gross_profile": { + "1": "2404", + "2": "418", + "3": "432", + "4": "142", + "5": "82", + "8": "4" + }, + "hosting_mass_per_call": "0", + "idle_mass_charged": "1650", + "idle_mass_gross": "1654", + "k": 2, + "magnitude_bits": 1, + "precision_rank1_per_call": "4", + "rank1_children_per_call": "2408", + "restoration_scratch_clear_per_call": "4" + }, + { + "centre_charge_per_call": "16", + "charged_ceiling": { + "hi": "497632841/125000000000", + "hi_dec": "0.003981062728", + "lo": "3981062727/1000000000000", + "lo_dec": "0.003981062727" + }, + "charged_kappa_cap": "0.003965276713", + "charged_profile": { + "1": "2404", + "2": "418", + "3": "432", + "4": "142", + "5": "82", + "8": "2" + }, + "charged_ratio_vs_baseline": "2.355583", + "copy_children_r8_per_call": "2", + "gross_ceiling": { + "hi": "1992027027/500000000000", + "hi_dec": "0.003984054054", + "lo": "3984054053/1000000000000", + "lo_dec": "0.003984054053" + }, + "gross_profile": { + "1": "2400", + "2": "418", + "3": "432", + "4": "142", + "5": "82", + "8": "2" + }, + "hosting_mass_per_call": "0", + "idle_mass_charged": "1654", + "idle_mass_gross": "1658", + "k": 4, + "magnitude_bits": 2, + "precision_rank1_per_call": "4", + "rank1_children_per_call": "2404", + "restoration_scratch_clear_per_call": "2" + }, + { + "centre_charge_per_call": "8", + "charged_ceiling": { + "hi": "4365321517/1000000000000", + "hi_dec": "0.004365321517", + "lo": "1091330379/250000000000", + "lo_dec": "0.004365321516" + }, + "charged_kappa_cap": "0.004346348309", + "charged_profile": { + "1": "2401", + "2": "418", + "3": "432", + "4": "142", + "5": "82", + "8": "1" + }, + "charged_ratio_vs_baseline": "2.582948", + "copy_children_r8_per_call": "1", + "gross_ceiling": { + "hi": "4367783311/1000000000000", + "hi_dec": "0.004367783311", + "lo": "436778331/100000000000", + "lo_dec": "0.004367783310" + }, + "gross_profile": { + "1": "2398", + "2": "418", + "3": "432", + "4": "142", + "5": "82", + "8": "1" + }, + "hosting_mass_per_call": "0", + "idle_mass_charged": "1657", + "idle_mass_gross": "1660", + "k": 8, + "magnitude_bits": 3, + "precision_rank1_per_call": "3", + "rank1_children_per_call": "2401", + "restoration_scratch_clear_per_call": "1" + }, + { + "centre_charge_per_call": "4", + "charged_ceiling": { + "hi": "4558083777/1000000000000", + "hi_dec": "0.004558083777", + "lo": "71220059/15625000000", + "lo_dec": "0.004558083776" + }, + "charged_kappa_cap": "0.004537401919", + "charged_profile": { + "1": "2399", + "2": "418", + "3": "432", + "4": "142", + "5": "82", + "8": "1/2" + }, + "charged_ratio_vs_baseline": "2.697005", + "copy_children_r8_per_call": "1/2", + "gross_ceiling": { + "hi": "569974757/125000000000", + "hi_dec": "0.004559798056", + "lo": "911959611/200000000000", + "lo_dec": "0.004559798055" + }, + "gross_profile": { + "1": "2397", + "2": "418", + "3": "432", + "4": "142", + "5": "82", + "8": "1/2" + }, + "hosting_mass_per_call": "0", + "idle_mass_charged": "1659", + "idle_mass_gross": "1661", + "k": 16, + "magnitude_bits": 4, + "precision_rank1_per_call": "2", + "rank1_children_per_call": "2399", + "restoration_scratch_clear_per_call": "1/2" + } + ], + "screen": { + "ideal_shared_by_two_ratio": "1.90", + "metric": "complex packing ceiling ratio vs baseline (levers.py scale)", + "threshold": "1.10", + "verdict": "route survives: ideal ratio 1.90 >= 1.10", + "whole_bound_caveat": "bit side binds at c_bit; whole-bound gain capped at +3.4536 per cent (centre-sharing-overhead-budget)" + }, + "status": "PASS_CENTRE_SHARED_KCALL_CHARGED" +} diff --git a/research/centre-shared-kcall-charged-seed615415/SOURCES.json b/research/centre-shared-kcall-charged-seed615415/SOURCES.json new file mode 100644 index 0000000000..63ae196a06 --- /dev/null +++ b/research/centre-shared-kcall-charged-seed615415/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/centre-shared-return-guard/RESULT.json", + "usage": "input", + "git_blob": "62a00f032d7fa7906f1658d4fd32fa02bdf14cd0", + "sha256": "8e8f53e8574d1dbc2845ce910f3b01713aba8996c00bdd847935c85bacc0287e" + }, + { + "path": "research/complex-local-word-ceiling/RESULT.json", + "usage": "input", + "git_blob": "77f55043a679dd722330f1e2499863e36376d9f9", + "sha256": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + } + ] +} diff --git a/research/centre-shared-kcall-charged-seed615415/TASK.json b/research/centre-shared-kcall-charged-seed615415/TASK.json new file mode 100644 index 0000000000..0d0e08e4a7 --- /dev/null +++ b/research/centre-shared-kcall-charged-seed615415/TASK.json @@ -0,0 +1,92 @@ +{ + "schema_version": 1, + "task_id": "centre-path-sharing", + "priority_revision": 6, + "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "original_card": { + "id": "centre-path-sharing", + "question": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt", + "certificates/selected-result.json" + ], + "methods": [ + "Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.", + "Prove a lower bound on copied information per call for the selected decoder contract." + ], + "acceptance_gate": "Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).", + "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.", + "allowed_variations": [ + "One sharing pattern across a fixed number of calls.", + "One reduced copied-total contract for the existing decoder.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Removing copies without a replacement contract for the decoder's copied totals.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "centre path", + "copied totals", + "private temporary", + "shared centre", + "batching" + ] + }, + "scope_status": "unchanged", + "actual_scope": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?", + "scope_change_reason": null, + "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, about 64 per cent of the raw deficit, so sharing or shrinking it is one of the largest single levers on the complex side. The relaxation shows the named sharing costs (restoration, hosting, precision) consume under 0.1 per cent of the k=2 ceiling, so cost does not block this sharing pattern; eligibility of a shared window and demand coupling do.", + "budget_minutes": 60, + "stop_rule": "Stop after the k=2 smallest instance, the k=4/8/16 rows and the two break-even overhead treatments, with the eligibility, consumer and precision obligations named; no physical fused call is built, no supplier admission is attempted and the selected record is unchanged.", + "outcome": "completed", + "evidence": "RESULT.json: fully charged k=2 window ceiling a<0.003215381840 (kappa<0.003205076296, 1.903x baseline) with centre charge 32, copy children 4 rank-8/call, restoration 4 scratch CLEARs/call, hosting 0 (window constraints named), precision 4 rank-1/call; gross ceiling 0.003217794406; k=4/8/16 charged ceilings 0.003981062728 / 0.004365321517 / 0.004558083777. Break-even extra rank-1 overhead per call: 1650 (identity-feasible maximum) under coverage-identity displacement, 31 for the full bit-limited gain and 32 for any gain under the additive treatment. The pinned separate (16/368/32) and fused (8/360/16) bills are reproduced exactly; six controls enforced.", + "author": "Aaron Wang", + "ai_assistance": "Substantial: help from opencode (no model named) in deriving the conversion contract, writing verify.py and drafting the README; no independent human review claimed.", + "draw_record": { + "chooser": "scripts/choose_research_task.py", + "seed": "615415b58548f9dea7ddac4165b1e2e2", + "catalog_assessed_on": "2026-10-16", + "catalog_sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "priority_revision": 6, + "cards_drawn": ["centre-path-sharing", "joint-query-controller", "coverage-law-change"], + "card_worked": "centre-path-sharing", + "reading": "construction reading of the card's method 1 (fully charged favourable relaxation for sharing one centre path across k calls, including restoration, hosting and precision); the incremental census reading was not taken", + "saturation_handling": "The card is heavily drawn by local packages, so per the saturation rule a construction reading was preferred over a census reading. The unpriced construction is the fully charged ceiling via ceiling.ceiling(centre=...) with restoration, hosting and precision charged: centre-sharing-overhead-budget prices tolerable overhead budgets only (its own limits leave hosting, precision and the DeltaH form unpriced), centre-shared-return-guard prices the macro bill and the precision boundary but never converts to rank mass or a ceiling, and the observation-floor packages explicitly supply no restoration/hosting/precision bill. No re-draw was needed; the other two cards were not substituted.", + "pair_collision_check": "discussions 1166 and 1317 checked via toolkit disc-comments --grep for centre path / copied totals / private temporary / shared centre / batching and for CLAIM headers with timestamps: no live CLAIM on this card's object at draw time (all CLAIM hits belong to other objects: F-star kappa-blockers, 18-point cover, P104, QQ16). CLAIM posted before computation at discussions/1166#discussioncomment-18983433.", + "re_draw": "none" + }, + "open_questions": [ + { + "question": "Is any selected call pair eligible for a fused shared-sink window (shared post-A rows, identical return operator and chart, uninterrupted window)?", + "why_it_matters": "The relaxation shows the named costs do not block this sharing pattern, so eligibility is the actual blocker for turning the favourable relaxation into a construction.", + "first_step": "Extract the backward centre-phase invocations of two selected calls that share sink rows from the selected replay schedule and compare their operators and charts.", + "blocked_by": "The owner map and call schedule are not in this package; centre-shared-return-guard leaves eligibility open explicitly." + }, + { + "question": "Which selected call pairs have coupled (shared-sink) rather than independent demands?", + "why_it_matters": "p112-batch-centre-floor's 64k copied-pairing-rank floor blocks sharing for independent root-code demands; only coupled demands can use this pattern at all.", + "first_step": "Classify the 144 calls of the selected record by shared sink rows and return operator.", + "blocked_by": "No machine-readable demand-coupling table exists for the selected record." + }, + { + "question": "Does the fused primitive bill at width mu+1 fit the selected invoice guard?", + "why_it_matters": "It closes the invoice-level obligation the rank-mass model cannot see (the guard prices no tariff and no tape).", + "first_step": "Instantiate the pinned two-panel fused bill under the selected invoice formulas and compare with the primitive guard.", + "blocked_by": "Actual tariffs and precision headroom are uninstantiated in the predecessors." + } + ] +} diff --git a/research/centre-shared-kcall-charged-seed615415/VERIFY.json b/research/centre-shared-kcall-charged-seed615415/VERIFY.json new file mode 100644 index 0000000000..69388dd207 --- /dev/null +++ b/research/centre-shared-kcall-charged-seed615415/VERIFY.json @@ -0,0 +1,22 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/centre-shared-return-guard/RESULT.json", + "research/complex-local-word-ceiling/RESULT.json", + "research/complex-local-word-ceiling/ceiling.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Bill conversion reproduces the pinned separate (16/368/32) and fused (8/360/16) counts; k=1 profile and ceiling reproduce the selected word and published baseline; fully charged ceilings for k=2/4/8/16 with restoration, hosting and precision charged; sharp break-even overheads in both treatments; monotone controls for extra rank-1 and doubled precision; additive budgets compared with centre-sharing-overhead-budget." + } + ] +} diff --git a/research/centre-shared-kcall-charged-seed615415/verify.py b/research/centre-shared-kcall-charged-seed615415/verify.py new file mode 100644 index 0000000000..dd4de03114 --- /dev/null +++ b/research/centre-shared-kcall-charged-seed615415/verify.py @@ -0,0 +1,331 @@ +#!/usr/bin/env python3 +"""Fully charged favourable relaxation for a k-call shared centre window. + +This verifier converts the pinned two-panel shared-return contract of +research/centre-shared-return-guard (PR1708/PR1748 lineage) and its k-call +generalisation into the packing-ceiling model of research/complex-local-word-ceiling, +charging restoration, hosting and precision explicitly instead of leaving them +as free overhead. All arithmetic is exact (Fraction) except the printed captions. + +Conversion contract (README.md states the full contract and its scope): + * one rank-8 COPY/ERASE total = one rank-8 child (8 mass units); its ascent + and its erase are inside that one child; + * one ADD macro = one rank-1 child; one scratch CLEAR = one rank-1 child; + * precision: k summed panels have envelope at most k * max, so ceil(log2 k) + extra magnitude bits are sufficient on the 8 shared totals; each bit is + charged as one rank-1 unit per shared total per window; + * hosting: shared rows persist across the window at zero mass under the + idle-axis-hosting lemma; the window constraints are named, not priced. + +usage: python3.12 -B research/centre-shared-kcall-charged-seed615415/verify.py [--write] +Aaron Wang, with help from opencode (substantial AI assistance; no model named). +Apache-2.0. +""" +import json +import sys +from fractions import Fraction as Q +from math import isqrt +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(ROOT / 'research' / 'complex-local-word-ceiling')) +import ceiling as C # noqa: E402 + +M, FAM, ST = 73, 896, 9 +WORD = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8} +BASE_CENTRE = 64 +GRID = Q(1, 10 ** 12) + +# Exact endpoints recorded by predecessor packages (README citations). +BIT_ENDPOINT = Q(1733427039589844234749, 10 ** 24) # c_bit, centre-sharing-overhead-budget +KAPPA_TRANSFER = Q(1, 10 ** 24) # complex-coverage-law-relief T2 +T2 = BIT_ENDPOINT / (1 - KAPPA_TRANSFER) +KAPPA_SELECTED = Q(836330098538459, 500000000000000000) # certificates/selected-result.json +A_SELECTED = KAPPA_SELECTED / (1 - KAPPA_SELECTED) + +GUARD = ROOT / 'research' / 'centre-shared-return-guard' / 'RESULT.json' +CEILING_RESULT = ROOT / 'research' / 'complex-local-word-ceiling' / 'RESULT.json' +OVERHEAD_RESULT = ROOT / 'research' / 'centre-sharing-overhead-budget' / 'RESULT.json' + + +def bits(k): + """Extra magnitude bits sufficient for k summed panel envelopes: ceil(log2 k).""" + b, p = 0, 1 + while p < k: + p *= 2 + b += 1 + return b + + +def window_bill(k): + """Backward centre-phase bill of one fused k-call window (integer macros).""" + return {'r8': 8, 'add': 176 * k + 8, 'clear_scratch': 8, 'clear_erase': 8} + + +def per_call_bill(k): + """Per-call amplitudes of the shared window (exact Fractions).""" + w = window_bill(k) + return {'r8': Q(w['r8'], k), 'add': Q(w['add'], k), 'scratch': Q(w['clear_scratch'], k)} + + +def profile(k, precision=True, extra_rank1=Q(0)): + """Per-call local profile of the shared window, fully charged.""" + b = per_call_bill(k) + base_rank1 = 184 + 8 # literal phase: 184 ADD + 8 scratch CLEAR per call + rank1 = Q(2412) - (Q(base_rank1) - (b['add'] + b['scratch'])) + if precision: + rank1 += Q(8 * bits(k), k) + rank1 += extra_rank1 + return {1: rank1, 2: Q(418), 3: Q(432), 4: Q(142), 5: Q(82), 8: b['r8']} + + +def centre(k): + return Q(BASE_CENTRE, k) + + +def cap(local, cent, extra=None): + return C.ceiling(local, M, FAM, ST, cent, grid=GRID, **(extra or {})) + + +def moment_hi(local, cent, a, extra=None): + return C.relax(local, M, FAM, ST, cent, a, **(extra or {}))[1] + + +def moment_lo(local, cent, a, extra=None): + return C.relax(local, M, FAM, ST, cent, a, **(extra or {}))[0] + + +def max_extra_rank1(k, precision, threshold_a, treatment): + """Largest per-call rank-1 overhead H whose moment at threshold_a stays below one. + + treatment 'displace': overhead children displace idle mass (coverage identity + conserved; ceiling model treatment). treatment 'additive': overhead children + add pure moment cost on top of the identity (centre-sharing-overhead-budget + treatment). Sharp: H passes (upper enclosure below 1) and H+1 fails (lower + enclosure above 1), or H is capped by coverage-identity feasibility. + """ + base = profile(k, precision=precision) + lo, hi = moment_lo(base, centre(k), threshold_a), moment_hi(base, centre(k), threshold_a) + C.require(hi < Q(1), 'base shared profile already fails at the threshold') + R = C.max_idle_rank(M) + one = C.child_cost(1, M, threshold_a) + idle = C.child_cost(R, M, threshold_a) + if treatment == 'additive': + delta = one[1] / Q(FAM, ST) + else: + delta = (one[0] - idle[1] / R) / Q(FAM, ST) + est = int((Q(1) - hi) / delta) + h_feas = int(C.model(base, M, FAM, ST, centre(k))['idle_mass']) if treatment != 'additive' else est + 100000 + + def moment_at(h): + shifted = dict(base) + shifted[1] = base[1] + Q(h) + extra_centre = Q(h) if treatment == 'additive' else Q(0) + return C.relax(shifted, M, FAM, ST, centre(k) + extra_centre, threshold_a) + + h = max(0, min(est - 2, h_feas)) + while h > 0 and moment_at(h)[1] >= Q(1): + h -= 1 + while h + 1 <= h_feas and moment_at(h + 1)[1] < Q(1): + h += 1 + C.require(h < est + 100000, 'break-even search diverged') + capped = (h == h_feas and treatment != 'additive') + passed = moment_at(h)[1] + C.require(passed < Q(1), 'break-even witness does not pass the moment test') + if h + 1 <= h_feas and not capped: + failed = moment_at(h + 1)[0] + C.require(failed > Q(1), 'break-even not sharp at the threshold') + return {'H': h, 'sharp': not capped, 'capped_by_identity': capped, + 'moment_hi_at_H': fstr(passed), 'H_feasible_max': h_feas} + + +def fstr(fr): + return str(fr) + + +def ffloat(fr, digits=12): + return f'{float(fr):.{digits}f}' + + +def bracket(pair): + return {'lo': fstr(pair[0]), 'hi': fstr(pair[1]), + 'lo_dec': ffloat(pair[0]), 'hi_dec': ffloat(pair[1])} + + +def compute(): + guard = json.loads(GUARD.read_text(encoding='utf-8')) + overhead = json.loads(OVERHEAD_RESULT.read_text(encoding='utf-8')) + ceiling_result = json.loads(CEILING_RESULT.read_text(encoding='utf-8')) + + # Control 1: the k = 1 and k = 2 formulas reproduce the pinned bills exactly. + sep, fus = guard['separate_counts'], guard['fused_counts'] + k1 = window_bill(1) + k2 = window_bill(2) + pinned = { + 'separate_per_two_calls': {'r8': 2 * k1['r8'], 'add': 2 * k1['add'], + 'clear': 2 * (k1['clear_scratch'] + k1['clear_erase'])}, + 'fused_per_window': {'r8': k2['r8'], 'add': k2['add'], + 'clear': k2['clear_scratch'] + k2['clear_erase']}, + } + C.require(pinned['separate_per_two_calls'] == {'r8': sep['R8'], 'add': sep['add'], 'clear': sep['clear']}, + 'k=1 conversion does not reproduce the pinned separate bill') + C.require(pinned['fused_per_window'] == {'r8': fus['R8'], 'add': fus['add'], 'clear': fus['clear']}, + 'k=2 conversion does not reproduce the pinned fused bill') + C.require(bits(2) == guard['precision_and_bill']['additional_magnitude_bits_sufficient'], + 'precision bit count does not match the pinned guard') + + # Control 2: k = 1 profile equals the selected word and its ceiling matches + # the published baseline (complex-local-word-ceiling/RESULT.json). + base_profile = profile(1, precision=False) + C.require(base_profile == {1: Q(2412), 2: Q(418), 3: Q(432), 4: Q(142), 5: Q(82), 8: Q(8)}, + 'k=1 profile does not equal the selected word') + base_cap = cap(base_profile, Q(BASE_CENTRE)) + published = ceiling_result['ceiling'] + published_hi = Q(published['a_ceiling']) + C.require(abs(base_cap[1] - published_hi) < Q(2, 10 ** 12), + 'k=1 ceiling does not reproduce the published baseline ceiling') + + rows = [] + for k in (1, 2, 4, 8, 16): + gross = profile(k, precision=False) + charged = profile(k, precision=True) + model_g = C.model(gross, M, FAM, ST, centre(k)) + model_c = C.model(charged, M, FAM, ST, centre(k)) + cap_g = cap(gross, centre(k)) + cap_c = cap(charged, centre(k)) + rows.append({ + 'k': k, + 'magnitude_bits': bits(k), + 'centre_charge_per_call': fstr(centre(k)), + 'copy_children_r8_per_call': fstr(per_call_bill(k)['r8']), + 'restoration_scratch_clear_per_call': fstr(per_call_bill(k)['scratch']), + 'hosting_mass_per_call': '0', + 'precision_rank1_per_call': fstr(Q(8 * bits(k), k)) if k > 1 else '0', + 'rank1_children_per_call': fstr(charged[1]), + 'gross_profile': {str(r): fstr(n) for r, n in gross.items()}, + 'charged_profile': {str(r): fstr(n) for r, n in charged.items()}, + 'idle_mass_gross': fstr(model_g['idle_mass']), + 'idle_mass_charged': fstr(model_c['idle_mass']), + 'gross_ceiling': bracket(cap_g), + 'charged_ceiling': bracket(cap_c), + 'charged_kappa_cap': ffloat(cap_c[1] / (1 + cap_c[1])), + 'charged_ratio_vs_baseline': ffloat(cap_c[1] / base_cap[1], 6), + }) + + # Control 3: one extra rank-1 child lowers the ceiling. + extra_child_cap = cap(profile(2, True, Q(1)), centre(2)) + C.require(extra_child_cap[1] < Q(rows[1]['charged_ceiling']['hi']), + 'one extra rank-1 child did not lower the k=2 ceiling') + + # Control 4: double precision charge lowers the ceiling (sensitivity). + double_profile = profile(2, precision=False) + double_profile[1] += Q(8 * 2 * bits(2), 2) + double_cap = cap(double_profile, centre(2)) + C.require(double_cap[1] < Q(rows[1]['charged_ceiling']['hi']), + 'double precision charge did not lower the k=2 ceiling') + + # Break-evens for the k = 2 charged profile, in rank-1 children per call. + # 'displace' keeps the coverage identity (ceiling model); 'additive' adds + # pure moment cost (centre-sharing-overhead-budget treatment). + break_even = {} + for treatment in ('displace', 'additive'): + break_even[treatment] = { + 'full_gain_at_T2': max_extra_rank1(2, True, T2, treatment), + 'full_gain_at_c_bit': max_extra_rank1(2, True, BIT_ENDPOINT, treatment), + 'any_gain_at_selected': max_extra_rank1(2, True, A_SELECTED, treatment), + } + + # Informative comparison with centre-sharing-overhead-budget's sharp rank-1 + # budgets on their identity profile {**WORD, 8: 4}, centre 32. Their moment + # engine is the full invoice moment on the actual idle histogram; this + # verifier uses the ideal-packing relaxation, so equality is not required, + # but a gross deviation falsifies the conversion machinery. + ident = {1: Q(2412), 2: Q(418), 3: Q(432), 4: Q(142), 5: Q(82), 8: Q(4)} + R = C.max_idle_rank(M) + one = C.child_cost(1, M, BIT_ENDPOINT) + delta_add = one[1] / Q(FAM, ST) + h_est = (Q(1) - moment_hi(ident, Q(32), BIT_ENDPOINT)) / delta_add + one_sel = C.child_cost(1, M, A_SELECTED) + h_any_est = (Q(1) - moment_hi(ident, Q(32), A_SELECTED)) / (one_sel[1] / Q(FAM, ST)) + their_full = Q(overhead['two_call']['budgets'][0]['full_gain_total'], 144) + their_any = Q(overhead['two_call']['budgets'][0]['any_gain_total'], 144) + ratio_full = h_est / their_full + ratio_any = h_any_est / their_any + C.require(Q(1, 2) < ratio_full < Q(3) and Q(1, 2) < ratio_any < Q(3), + 'additive budgets deviate grossly from centre-sharing-overhead-budget') + cross_check = { + 'their_full_gain_per_call': fstr(their_full), + 'their_any_gain_per_call': fstr(their_any), + 'ours_full_estimate': ffloat(h_est, 6), + 'ours_any_estimate': ffloat(h_any_est, 6), + 'ratio_full': ffloat(ratio_full, 6), + 'ratio_any': ffloat(ratio_any, 6), + 'note': 'their engine is the full invoice moment on the actual idle histogram; ours is the ideal-packing relaxation; equality not required', + } + + # Screen from the card's first_experiment (levers.py metric). + screen = { + 'metric': 'complex packing ceiling ratio vs baseline (levers.py scale)', + 'ideal_shared_by_two_ratio': '1.90', + 'threshold': '1.10', + 'verdict': 'route survives: ideal ratio 1.90 >= 1.10', + 'whole_bound_caveat': 'bit side binds at c_bit; whole-bound gain capped at +3.4536 per cent (centre-sharing-overhead-budget)', + } + + result = { + 'status': 'PASS_CENTRE_SHARED_KCALL_CHARGED', + 'model': {'m': M, 'families': FAM, 'stages': ST, 'w': fstr(Q(FAM, ST)), + 'baseline_word': {str(r): n for r, n in WORD.items()}, + 'baseline_centre': BASE_CENTRE}, + 'conversion_contract': { + 'rank8_total': 'one rank-8 COPY/ERASE total = one rank-8 child (8 mass units)', + 'add': 'one ADD macro = one rank-1 child', + 'scratch_clear': 'one scratch CLEAR = one rank-1 child', + 'precision': 'ceil(log2 k) magnitude bits on 8 shared totals, each charged one rank-1 unit per total per window', + 'hosting': '0 mass under the idle-axis-hosting lemma; window constraints named in README', + }, + 'pinned_bill_reproduction': pinned, + 'baseline_ceiling': bracket(base_cap), + 'rows': rows, + 'break_even_k2_rank1_per_call': break_even, + 'cross_check_overhead_budget_rank1': cross_check, + 'endpoints': {'c_bit': fstr(BIT_ENDPOINT), 'T2': fstr(T2), 'a_selected': fstr(A_SELECTED)}, + 'screen': screen, + 'controls': [ + 'k=1 and k=2 conversion formulas reproduce the pinned separate and fused bills exactly', + 'k=1 profile equals the selected word and reproduces the published baseline ceiling', + 'one extra rank-1 child lowers the k=2 charged ceiling', + 'double precision charge lowers the k=2 charged ceiling', + 'break-even overheads are sharp: H passes the moment test and H+1 fails (or H is the identity-feasible maximum)', + 'additive identity-profile budgets stay within a factor of two of centre-sharing-overhead-budget', + ], + } + return result + + +def main(): + write = '--write' in sys.argv[1:] + result = compute() + text = json.dumps(result, indent=1, sort_keys=True, ensure_ascii=True) + '\n' + out = HERE / 'RESULT.json' + if write: + out.write_text(text, encoding='utf-8', newline='\n') + else: + C.require(out.is_file(), 'RESULT.json missing; run with --write first') + C.require(out.read_bytes() == text.encode('utf-8'), + 'RESULT.json does not match the recomputation') + k2 = result['rows'][1] + hb = result['break_even_k2_rank1_per_call'] + print('PASS_CENTRE_SHARED_KCALL_CHARGED', + 'k2_charged_ceiling', f"{k2['charged_ceiling']['hi_dec']}", + 'k2_ratio', k2['charged_ratio_vs_baseline'], + 'H_bit_displace', hb['displace']['full_gain_at_T2']['H'], + 'H_bit_additive', hb['additive']['full_gain_at_T2']['H'], + 'H_any_additive', hb['additive']['any_gain_at_selected']['H'], + 'no_new_kappa') + return 0 + + +if __name__ == '__main__': + sys.exit(main())