diff --git a/research/qq16-consumer-cap-audit/PR3181-README.md.gz b/research/qq16-consumer-cap-audit/PR3181-README.md.gz new file mode 100644 index 000000000..14779caff Binary files /dev/null and b/research/qq16-consumer-cap-audit/PR3181-README.md.gz differ diff --git a/research/qq16-consumer-cap-audit/README.md b/research/qq16-consumer-cap-audit/README.md new file mode 100644 index 000000000..d4606ff57 --- /dev/null +++ b/research/qq16-consumer-cap-audit/README.md @@ -0,0 +1,90 @@ +# QQ16 decoder consumer charge under the selected coverage law + +## Question and scope + +This is a narrow independent check of the consumer-price branch in open PR +[#3181](https://github.com/CrocSwap/integer-mult-bounds/pull/3181), head +`80fc72d14546088e9fce3c06dc12bc67270da0af`. The audited candidate is one +`CONSERVED-QQ16` `F0 + B_1_2` two-call pair followed by the pinned #2707 +zero-retention decoder. The specific question is whether its rank-one decoder +children leave enough recursive budget to reach the selected kappa under the +unchanged `centre=64` coverage law. + +The exact local F and B profiles come from +`research/joint-query/evidence/CONSERVED-QQ16.json`; the #2707 child count comes +from `research/qq16-line-normalized-decoder/RESULT.json`. Those source files, +the selected record, and the selected ceiling model are pinned in +[`SOURCES.json`](SOURCES.json). The PR #3181 README was retrieved at its exact +head. Its path, Git blob, and SHA256 are recorded in [`TARGET.json`](TARGET.json). +The fetched PR README is preserved as [compressed raw PR #3181 README](PR3181-README.md.gz). +Its bytes are checked against the exact Git blob and SHA256 recorded in +[`TARGET.json`](TARGET.json), so the numerical premise can be replayed offline. +The PR head itself remains an external source premise; the package does not +claim that this unmerged commit is in local Git history. + +## Result + +The source profiles are + +```text +F0: {1:2420, 2:418, 3:432, 4:142, 5:82} +B1_2: {1:2436, 2:418, 3:432, 4:142, 5:82} +#2707: 336 rank-one children across the two-call pair +``` + +Their per-call average is `{1:2596, 2:418, 3:432, 4:142, 5:82}`. For the +most favorable test, I omit the PR #3181 profile's eight rank-eight children +and allow their 64 units of rank mass to move into rank-51 idle children. This +lowers the relaxed moment. The resulting local mass is 5,706 per call; the +unchanged coverage law gives 7,232 total units per call and 1,526 idle units. + +At the exact selected saving +`a = kappa/(1-kappa) = 836330098538459/499163669901461541`, an independent +rational lower bound on the relaxed moment exceeds `100009/100000 = 1.00009`. +The proof uses a 32-term positive atanh expansion after range reduction for +each logarithm and a five-term positive exponential sum. Every operation in +the verifier is exact `Fraction` arithmetic. Since the relaxation is already +above one at the selected exponent, the cap for this fixed local profile and +coverage law is strictly below the selected kappa. The reported rank-eight +profile has an even larger lower bound. + +This establishes a scoped recursive-price obstruction for the stated +two-call profile. It does not establish the exact root reported in #3181, a +physical consumer bill, storage/retention feasibility, a global barrier, or a +new kappa. Endpoint adapters, movement, owner placement, routing, cleanup, and +physical hosting are not charged. The `centre=0` alternative is a changed +coverage law and is outside this result. + +## Reproduce + +From the repository root: + +```sh +python3 -B research/qq16-consumer-cap-audit/verify.py +python3 -B scripts/research_package.py --package research/qq16-consumer-cap-audit --check-only +python3.12 -B scripts/research_package.py --package research/qq16-consumer-cap-audit +``` + +The verifier checks the exact source hashes and Git blob IDs, reconstructs the +per-call profile, computes the favorable rank-51 relaxation, and checks +negative controls for an illegal rank-52 child and an uneven two-call split. +Expected verifier status: +`PASS_QQ16_CONSUMER_CAP_BELOW_SELECTED no_new_kappa`. + +## Open next questions + +Can a changed, globally valid coverage law remove the 64-per-call centre cost +while an actual F17 consumer accepts the decoder output in its produced frame? +This matters because the fixed centre-64 profile already misses the selected +threshold before physical costs. The first step is to pin a real downstream +caller, state its entry frames and owner lifetimes, then derive its coverage +identity and complete physical bill. The blocker is that the current evidence +does not bind such a caller; a centre-free local surrogate is not that proof. + +## Credit and review status + +Credit the #2697 `CONSERVED-QQ16` producer and its retained native lineage, +ywz65/#2707 for the zero-retention decoder, Nick Petalas/#2965 for the +completed-output transfer, and dcharb78 for the #3181 profile and cost screen. +This package adds a separate exact one-sided moment proof. No independent +human or formal-kernel review is claimed. New work is Apache-2.0. diff --git a/research/qq16-consumer-cap-audit/SOURCES.json b/research/qq16-consumer-cap-audit/SOURCES.json new file mode 100644 index 000000000..a7d38c778 --- /dev/null +++ b/research/qq16-consumer-cap-audit/SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "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/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" + }, + { + "path": "research/joint-query/evidence/CONSERVED-QQ16.json", + "usage": "input", + "git_blob": "7a155a27dcf7f1ccd48e40d57a2c5d2724016e9b", + "sha256": "b91eb8599c403db55c889bb225a1cd93f46fdb83eb339f101d18843d52b1c920" + }, + { + "path": "research/qq16-line-normalized-decoder/RESULT.json", + "usage": "input", + "git_blob": "ba4167dbf133cff51513bb832802c290edcdffea", + "sha256": "58df4ad68e2ff335ee58fa4336a449d0f73f3366d840574e5e30b50f507c358d" + } + ] +} diff --git a/research/qq16-consumer-cap-audit/TARGET.json b/research/qq16-consumer-cap-audit/TARGET.json new file mode 100644 index 000000000..750e72bdb --- /dev/null +++ b/research/qq16-consumer-cap-audit/TARGET.json @@ -0,0 +1,33 @@ +{ + "schema_version": 1, + "source": { + "pr": 3181, + "state_at_check": "OPEN", + "head": "80fc72d14546088e9fce3c06dc12bc67270da0af", + "path": "research/qq16-interior-dynamic-range-and-adjoint-ledger/README.md", + "git_blob": "b2408a73cdcf287fbbf274ff68f9a208c2d01bb2", + "sha256": "2d2284bcb33cc437a9d3e03eaf93ca1ebfef4ced52fdb5d727a79970eab3b61b", + "checked_utc_date": "2026-10-19", + "local_archive": "PR3181-README.md.gz" + }, + "audited_claim": { + "producer_pair_calls": 2, + "decoder_rank_one_children_per_pair": 336, + "coverage": { + "m": 73, + "families_per_nine_stage_replica": 896, + "stages": 9, + "centre_per_call": 64, + "idle_rank_cap": 51 + }, + "reported_profile_per_call": { + "1": 2596, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "reported_kappa_cap": "0.001631159602" + } +} diff --git a/research/qq16-consumer-cap-audit/TASK.json b/research/qq16-consumer-cap-audit/TASK.json new file mode 100644 index 000000000..c869052a9 --- /dev/null +++ b/research/qq16-consumer-cap-audit/TASK.json @@ -0,0 +1,119 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "joint-query-controller", + "question": "Can a literal QQ16 producer meet the proposed completed-output error budgets with dirty helpers and an affordable physical consumer?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/joint-query/README.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "docs/research/community-efficient1000-review.md", + "research/qq16-producer-defect-transfer/README.md" + ], + "methods": [ + "Derive one literal producer's completed-output defects and intermediate dirty-helper bounds, with its physical bill.", + "Design or audit one consumer, retention or hosting boundary and its complete cost for the pinned producer/decoder." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the revision-6 family record and #2965 producer-defect transfer after the local QQ16 decoder contract. Its author-checked output-error estimate does not implement producer interiors, bound dirty helpers, or pay for the consumer; independently check the implication used.", + "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": "Pin one literal F0/B1 producer and its native-child contracts; derive the actual intermediate magnitude ledger and completed-output defects, including dirty helpers and correlations. Compare with #2965 budgets and price storage, movement, cleanup and F17 consumption. Stop with a precise missing bound if no producer contract supplies it; do not optimize another decoder precision constant in isolation.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer" + ] + }, + "scope_status": "refined", + "actual_scope": "Independently test whether the pinned decoder rank-one children of the PR #3181 F0+B1_2 pair fit the exact selected recursive-price budget under the unchanged centre-64 coverage law.", + "scope_change_reason": "The full physical consumer invoice is not source-bound. This isolates one exact necessary budget condition using the pinned producer and decoder while retaining the card\u2019s consumer-boundary focus; a failure before physical costs is a scoped obstruction, not a complete supplier or universal barrier.", + "bottleneck_link": "Tests whether the proposed local QQ16 consumer profile can reach the selected exponent even under the most favorable allowed idle-rank relaxation.", + "budget_minutes": 60, + "stop_rule": "Stop after an exact one-sided moment bound for the pinned pair and decoder, or if the PR source/profile cannot be bound. Do not optimize a new profile or infer a global barrier.", + "outcome": "completed", + "evidence": "Reconstructed the per-call profile from pinned F0 and B1_2 native counts plus the decoder\u2019s 336 rank-one children across two calls. An exact Fraction lower bound exceeds 1.00009 after dropping rank-eight children and relaxing all freed mass to rank 51.", + "author": "macbook-07", + "ai_assistance": "Substantial automated assistance was used for research and implementation. No independent human or formal-kernel review is claimed.", + "open_questions": [ + { + "question": "Can a changed globally valid coverage law remove the 64-per-call centre charge while an actual F17 consumer accepts the decoder output in its produced frame?", + "why_it_matters": "The fixed centre-64 profile already misses the selected threshold before physical movement, storage, hosting, and consumption costs.", + "first_step": "Pin a real downstream caller, its entry frames and owner lifetimes; derive its coverage identity and full physical bill.", + "blocked_by": "Current evidence does not bind a physical F17 caller or a globally valid centre-free coverage law." + } + ], + "assignment": { + "seed": "dcad28253c4c262b26d8deea86c90cc4", + "track": "recursive-interfaces", + "task_id": "joint-query-controller" + }, + "overlap": { + "searched_at": "2026-10-19T02:37:11.955097+00:00", + "terms": [ + "QQ16", + "joint-query", + "1969", + "2540", + "output-bank retention", + "2965", + "producer defect", + "F17 consumer" + ], + "coverage": { + "open_prs": { + "fetched_at": "2026-10-19T02:36:30.574262+00:00", + "complete_pagination": true, + "records": 587 + }, + "discussions": { + "fetched_at": "2026-10-19T02:37:09.290746+00:00", + "complete_pagination": true, + "records": 2536 + } + }, + "warnings": [], + "matches_total": 164, + "assessment": "The refreshed search found open PR #3181, whose exact-head README supplies the candidate profile, and prior early-record/decoder discussions. Live PR #3652 still states that physical routing, caller admission and F17 consumption remain open. This package adds an exact independent necessary-budget inequality for the fixed centre-64 profile; the search is not a novelty certificate.", + "limits": "Open PR and discussion titles/bodies plus local records are searched; code diffs and arbitrary package files are not. PR #3181 and #3652 were checked directly for current state and head." + }, + "freshness": { + "checked_at": "2026-10-19T02:37:11.955097+00:00", + "main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "relevant_change": "Final canonical-main fetch returned the same commit as the launch pin. PR #3181 remains open at the pinned head; PR #3652 remains open and leaves the physical caller/F17 consumer unresolved. Relevant #1166 and #1163 discussions were re-read." + } +} diff --git a/research/qq16-consumer-cap-audit/VERIFY.json b/research/qq16-consumer-cap-audit/VERIFY.json new file mode 100644 index 000000000..37caf50e7 --- /dev/null +++ b/research/qq16-consumer-cap-audit/VERIFY.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "research/complex-local-word-ceiling/RESULT.json", + "research/complex-local-word-ceiling/ceiling.py", + "research/joint-query/evidence/CONSERVED-QQ16.json", + "research/qq16-line-normalized-decoder/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact source blob and SHA256 pins; producer/decoder profile reconstruction; favourable rank-51 moment lower bound; centre-free scope control; invalid-rank and uneven-split controls." + } + ] +} diff --git a/research/qq16-consumer-cap-audit/verify.py b/research/qq16-consumer-cap-audit/verify.py new file mode 100644 index 000000000..dd6c8b9f1 --- /dev/null +++ b/research/qq16-consumer-cap-audit/verify.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python3 +"""Independent exact lower bound for the scoped QQ16 consumer budget.""" +from fractions import Fraction as Q +from hashlib import sha1, sha256 +from math import factorial +import gzip +import json +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = Path(__file__).resolve().parent + + +def require(ok, why): + if not ok: + raise ValueError(why) + + +def pinned_bytes(relpath): + manifest = json.loads((PACKAGE / 'SOURCES.json').read_text()) + rows = [x for x in manifest['files'] if x['path'] == relpath and x['usage'] == 'input'] + require(len(rows) == 1, f'missing or duplicate source pin: {relpath}') + raw = (ROOT / relpath).read_bytes() + row = rows[0] + require(sha256(raw).hexdigest() == row['sha256'], f'SHA256 mismatch: {relpath}') + blob = sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() + require(blob == row['git_blob'], f'Git blob mismatch: {relpath}') + return raw + + +def git_blob(raw): + return sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() + + +def ln_unit_lower(y, terms=32): + """Lower bound for ln(y), 1 <= y < 2, by a positive atanh series.""" + require(Q(1) <= y <= Q(2), 'log range reduction') + z = (y - 1) / (y + 1) + return 2 * sum((z ** (2*j + 1)) / (2*j + 1) for j in range(terms)) + + +def ln_ratio_lower(x): + """Lower bound for ln(x), x >= 1, reducing to [1, 2).""" + require(x >= 1, 'log ratio must be at least one') + k = 0 + while x >= 2: + x /= 2 + k += 1 + return k * ln_unit_lower(Q(2)) + ln_unit_lower(x) + + +def exp_lower(x, terms=5): + """Positive Taylor partial sum, hence a lower bound for exp(x), x >= 0.""" + require(x >= 0, 'exponential argument must be nonnegative') + return sum(x**j / factorial(j) for j in range(terms)) + + +def child_cost_lower(rank, m, a): + require(0 < rank < m, 'child rank outside local range') + return Q(rank, m) * exp_lower(a * ln_ratio_lower(Q(m, rank))) + + +def derive_profile(f_profile, b_profile, decoder_children, calls=2): + require(calls > 0 and decoder_children % calls == 0, 'uneven decoder split across calls') + profile = {} + for key in set(f_profile) | set(b_profile): + rank = int(key) + profile[rank] = (Q(f_profile.get(str(rank), 0)) + Q(b_profile.get(str(rank), 0))) / calls + profile[1] = profile.get(1, Q(0)) + Q(decoder_children, calls) + return {r: n for r, n in profile.items() if n} + + +def moment_lower(profile, m, w, centre, idle_rank, unpaid=1): + require(2 * idle_rank * idle_rank < m * m, 'idle rank cap violates the halving guard') + total = (m - unpaid) * w + centre + local_mass = sum(Q(r) * Q(n) for r, n in profile.items()) + idle_mass = total - local_mass + require(idle_mass >= 0, 'local word pays more mass than coverage law allows') + local = sum(Q(n) * child_cost_lower(r, m, selected_a) for r, n in profile.items()) + idle = idle_mass / idle_rank * child_cost_lower(idle_rank, m, selected_a) + return (local + idle) / w, total, local_mass, idle_mass + + +selected_a = Q(836330098538459, 499163669901461541) + + +def main(): + selected_raw = pinned_bytes('certificates/selected-result.json') + ceiling_raw = pinned_bytes('research/complex-local-word-ceiling/RESULT.json') + ceiling_code = pinned_bytes('research/complex-local-word-ceiling/ceiling.py') + producer_raw = pinned_bytes('research/joint-query/evidence/CONSERVED-QQ16.json') + decoder_raw = pinned_bytes('research/qq16-line-normalized-decoder/RESULT.json') + selected = json.loads(selected_raw) + ceiling = json.loads(ceiling_raw) + producer = json.loads(producer_raw) + decoder = json.loads(decoder_raw) + target = json.loads((PACKAGE / 'TARGET.json').read_text()) + + require(selected['kappa'] == '836330098538459/500000000000000000', 'selected kappa pin') + require(ceiling['status'] == 'PASS_COMPLEX_LOCAL_WORD_CEILING', 'ceiling source status') + model = ceiling['model'] + require((model['m'], model['stages'], model['centre_per_call'], model['idle_rank_cap']) == (73, 9, 64, 51), 'selected coverage model') + require(Q(model['live_families_per_call']) == Q(896, 9), 'live families per call') + require('non-increasing in r' in ceiling_code.decode(), 'pinned ceiling argument source') + require('2 * R * R < m * m' in ceiling_code.decode(), 'pinned halving guard source') + + claim = target['audited_claim'] + source = target['source'] + external = gzip.decompress((PACKAGE / source['local_archive']).read_bytes()) + require(source['pr'] == 3181 and source['state_at_check'] == 'OPEN', 'PR state premise') + require(source['head'] == '80fc72d14546088e9fce3c06dc12bc67270da0af', 'PR head premise') + require(git_blob(external) == source['git_blob'], 'external PR README Git blob mismatch') + require(sha256(external).hexdigest() == source['sha256'], 'external PR README SHA256 mismatch') + external_text = external.decode() + require('`{1: 2596, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8}`' in external_text, 'PR profile text premise') + require('`0.001631159602`' in external_text and '`centre = 64`' in external_text, 'PR cap/coverage text premise') + require(claim['producer_pair_calls'] == 2 and claim['decoder_rank_one_children_per_pair'] == 336, 'PR pair/decoder premise') + require(claim['coverage'] == {'m': 73, 'families_per_nine_stage_replica': 896, 'stages': 9, 'centre_per_call': 64, 'idle_rank_cap': 51}, 'PR coverage premise') + + f_profile = producer['invoices']['F']['native_profile'] + b_profile = producer['invoices']['B']['native_profile'] + child_count = decoder['invoice']['rank_one_children'] + require(decoder['events'] == 3823 and child_count == claim['decoder_rank_one_children_per_pair'], 'decoder count pin') + require(producer['native_cases']['B_1_2']['added_rank1_children'] == 24, 'selected B1_2 producer case') + derived = derive_profile(f_profile, b_profile, child_count, calls=claim['producer_pair_calls']) + full = dict(derived) + full[8] = Q(claim['reported_profile_per_call']['8']) + reported = {int(r): Q(n) for r, n in claim['reported_profile_per_call'].items()} + require(full == reported, f"reconstructed profile mismatch: {full}") + + # Remove the eight rank-eight children and give their 64 mass units to the + # most favorable permitted idle rank. This can only lower the moment because + # (r/m)^(1-a)/r decreases with rank for a >= 0. + relaxed = {r: n for r, n in full.items() if r != 8} + moment, total, local_mass, idle = moment_lower(relaxed, 73, Q(896, 9), 64, 51) + require((total, local_mass, idle) == (Q(7232), Q(5706), Q(1526)), 'centre-64 coverage mass') + require(moment > Q(100009, 100000), 'selected exponent is not excluded with margin') + + full_moment, _, _, _ = moment_lower(full, 73, Q(896, 9), 64, 51) + require(full_moment > moment, 'dropping rank-eight children must be favorable') + no_centre, _, _, _ = moment_lower(relaxed, 73, Q(896, 9), 0, 51) + require(no_centre < 1, 'centre-free law must remain outside the proved obstruction') + + try: + moment_lower(relaxed, 73, Q(896, 9), 64, 52) + except ValueError as exc: + require('halving guard' in str(exc), 'wrong illegal-rank failure') + else: + raise ValueError('rank-52 idle child incorrectly accepted') + try: + derive_profile(f_profile, b_profile, 335, calls=2) + except ValueError as exc: + require('uneven decoder split' in str(exc), 'wrong uneven-split failure') + else: + raise ValueError('uneven decoder split incorrectly accepted') + + print(json.dumps({ + 'status': 'PASS_QQ16_CONSUMER_CAP_BELOW_SELECTED no_new_kappa', + 'selected_a': str(selected_a), + 'relaxed_profile': {str(r): str(n) for r, n in sorted(relaxed.items())}, + 'coverage_mass': {'total': str(total), 'local': str(local_mass), 'idle': str(idle)}, + 'checked_strictly_above': '100009/100000', + 'display_decimal': f'{float(moment):.15f}', + 'rank8_profile_lower_bound_decimal': f'{float(full_moment):.15f}', + 'centre_free_control_decimal': f'{float(no_centre):.15f}', + 'external_pr_source': {'head': source['head'], 'blob': source['git_blob'], 'sha256': source['sha256']} + }, indent=2, sort_keys=True)) + + +if __name__ == '__main__': + main()