From 3eb6c26b7439ea5827fa647cdd1c0d2dd3deddb9 Mon Sep 17 00:00:00 2001 From: Matarener Date: Fri, 23 Oct 2026 19:28:04 +0300 Subject: [PATCH 1/2] Add joint bit+complex supplier average ceiling on the p16 controller (negative result) Side-by-side (rank, role) ledger of the #4470 complex invoice and the #4814 BIT invoice. Every mass-consistent joint ledger has saving between the two side roots, at most 0.003232, below the BIT gate 0.003475458. The literal "paid once" rule violates the rank-mass identity; idle ranks never coincide; the only larger variants are the known small-job merge lever. Co-Authored-By: Claude Fable 5.1 --- .../joint-supplier-average-ceiling/README.md | 119 +++++++ .../RESULT.json | 202 +++++++++++ .../SOURCES.json | 42 +++ .../joint-supplier-average-ceiling/TASK.json | 90 +++++ .../VERIFY.json | 23 ++ .../joint-supplier-average-ceiling/verify.py | 325 ++++++++++++++++++ 6 files changed, 801 insertions(+) create mode 100644 research/joint-supplier-average-ceiling/README.md create mode 100644 research/joint-supplier-average-ceiling/RESULT.json create mode 100644 research/joint-supplier-average-ceiling/SOURCES.json create mode 100644 research/joint-supplier-average-ceiling/TASK.json create mode 100644 research/joint-supplier-average-ceiling/VERIFY.json create mode 100644 research/joint-supplier-average-ceiling/verify.py diff --git a/research/joint-supplier-average-ceiling/README.md b/research/joint-supplier-average-ceiling/README.md new file mode 100644 index 0000000000..98192fc9e2 --- /dev/null +++ b/research/joint-supplier-average-ceiling/README.md @@ -0,0 +1,119 @@ +# One native word for both sides: the joint supplier cannot beat the average of the two invoices (negative result) + +`research/kappa01-outer-repair` §2 leaves a door open: a self-contained supplier that implements the address interchange +and the butterfly layer in one native call removes the separate bit endpoint, and the outer assembly then admits +`a = b = s` for its joint saving `s`, with the scoped limit `κ < s/(1+s)`. The natural hope is that such a word adds the +credits of the two sides while the large neutral work (idle stages, local small jobs) is done once, so that +`C_joint ≈ (S_complex + S_bit) / G_shared` could exceed both sides. + +**Result: on the current p16 controller this cannot happen.** Any joint ledger that respects the rank-mass identity of +the admission has a saving between the two side roots, at most **0.003232** (+7.0% over the selected 0.00302015 of +#4470), which is **below the BIT gate 0.003475458** (+15.1%) that an ordinary complex-side improvement already reaches. +The selected κ and the BIT admission are unchanged. The script runs in seconds on the standard library. + +## The two invoices side by side + +| | complex #4470 (`joint-helper-lattice/RESULT.json`) | BIT #4814 (`bit-finite-ordinary-bootstrap/RESULT.json`, `raw_invoice`) | +|---|---|---| +| controller | p16, 18 full calls, 15 thin query stages, 2 main fields per port | same | +| ports | 112 (E8 word, 9-bit labels, 8 fresh axes) | 111 (h = 8 word, 7 fresh axes) | +| targets | 224 main (rank 145) + 3360 idle (8j+1) + 7344 helpers | 222 main (127) + 3330 idle (7j+1) + 7848 helpers | +| paid | 3360 idle (8j) + 59 436 local (ranks 1–5) + 1680 shears + 144 centre | 3330 idle (7j) + 52 344 local (1–7) + 1665 shears, no centre | +| surplus S = mass(T) − mass(P) | 752 = 112·32 − 18·64 − 1680 | 753 (recorded `rank_surplus`) | +| G = Σ_T r ln r − Σ_P r ln r | 250 637 | 218 265 | +| S/G vs exact root | 0.003000 vs 0.003020166 | 0.003450 vs 0.003475458 | + +The roots are the raw crossings of `Σ_T n_r r^(1−C) = Σ_P n_r r^(1−C)`; the package reproduces both to 10⁻¹³. +Because `C ≈ 0.003`, the equation is nearly linear: `C ≈ S/G` to within 1%. + +Identical `(rank, role)` paid jobs on the two sides: 35 589 jobs of mass 74 499 (local ranks 1–5, the 1665 shears, and +the accidental idle coincidence 56 = 8·7 = 7·8). The idle stages, 56–59% of either side's paid moment, otherwise never +coincide in rank, because stage j costs 8(j+1) on complex and 7(j+1) on BIT. + +## Six joint models and their ceilings + +Targets of both sides are productive in the joint call; the rules differ in how the paid jobs combine. All are ideal +relaxations (no extra charges), so each number is a ceiling for its model, never a construction. + +| model | C_joint | × 0.00302 | × 0.003475 | S | G | mass identity | +|---|---:|---:|---:|---:|---:|---| +| A. two networks side by side on disjoint wires (sum of the two equations) | 0.003232 | 1.070 | 0.930 | 1505 | 468 902 | kept | +| B. literal "identical (rank, role) paid once", targets of both sides | 0.182 | 60.3 | 52.4 | 76 004 | 592 405 | **violated** (−74 499 paid mass) | +| C. aligned twins: matched wires carry both frames, rank = max | no saving | 0 | 0 | −5314 | — | kept | +| D. stacked frames: matched wires, rank = r_c + r_b for targets and paid | 0.003199 | 1.059 | 0.920 | 1505 | 474 776 | kept | +| E. paid jobs merged pairwise at rank r_c + r_b, targets separate | 0.009325 | 3.09 | 2.68 | 1505 | 162 702 | kept | +| F. as E, largest complex job paired with smallest BIT job | 0.007541 | 2.50 | 2.17 | 1505 | 201 811 | kept | + +How to read them. + +- **B is the intuitive rule and it is not a ceiling.** Paying the common work once while crediting both target sets + removes 74 499 units of paid mass with the target mass unchanged. But `S = mass(T) − mass(P)` is set by the + controller (credits per port window minus centre minus thin shears, `controller.py` surplus identity; see + `research/admission-constant-derivation`), not by the word. A joint word on the same ports has the same windows, so + `S_joint ≤ S_c + S_b = 1505` and the paid mass must be at least `456 672 − 1505`. The heuristic "same S, G once" is + self-contradictory: S and G are the same function `f(C)` at two points, and paid moment cannot be removed without + removing paid mass. +- **A and D are the honest two-sided models**, and both give the mass-weighted average of the two roots + (`C ≈ (S_c + S_b)/(G_c + G_b)`), 6–7% above the complex root and 7–8% below the BIT root. The verifier checks that + both side equations are decreasing on `[0, 0.05]`, so the root of their sum lies strictly between the two side roots. + Model A moreover requires the caller to supply an interchange task and a layer task simultaneously and + independently; in the pipeline they are always sequential on the same data (basis change, then children, then the + inverse basis change inside a layer node in `05-layers.tex`; layout move, then layer, then twiddle between rounds in + `06-transforms.tex`), so even the +7% is not available. +- **C, the aligned twins** (one wire carries an F2⁹ frame and a rational h = 8 frame, one child moves both at the price + of the larger rank): the credits do not add, they coincide (the same central +1 on the same window), and the mismatch + between the local-job distributions (40 266 rank-1 jobs on complex against 24 156 rank-2 jobs on BIT) costs more than + the whole surplus, so `S < 0` and there is no saving at all. +- **E and F are not a two-sided effect.** Their gain is the concavity of `r^(1−C)` when small paid jobs are merged into + larger ones, the known small-job merge lever (`research/productive-lever-reprice`, "rank-16 children"). The same + pairwise merge inside the complex side alone already gives 0.004109 (×1.36), above the BIT root, with no second side. + That lever is closed by the whole-job premise of #4416 and the centre and thin-shear floors; a joint word does not + reopen it. + +## Why this closes the door of `kappa01-outer-repair` §2 on the current controller + +The outer side is fine: the balanced engine (`balanced_shared.py`) has standalone-swap margins `g2 = g4 = a` and the +controlling margin `G = ε·q` from the layer, so a joint supplier with saving `s` on both endpoints would indeed give +`κ < s/(1+s)`. What the invoices show is that `s` itself cannot exceed the average of the two sides: the surplus lives in +the controller's port windows, the denominator lives in the paid mass, and the mass identity ties the two. "Credits +add while the common work is paid once" would need twice the windows, i.e. two words. + +This is a statement about the p16 controller with the #4470 and #4814 words. A joint word with a different controller +(more credits per window, or a controller whose idle stages are shared) is outside this ceiling; see the open question. + +## Reproduce + +```sh +python3 scripts/research_package.py --package research/joint-supplier-average-ceiling --check-only +python3.12 scripts/research_package.py --package research/joint-supplier-average-ceiling +python3.12 -B research/joint-supplier-average-ceiling/verify.py --json /tmp/receipt.json +``` + +`verify.py` authenticates the four pinned inputs, reproduces both raw roots, checks the surplus identities +(752 = 112·32 − 18·64 − 1680, 753 recorded), partitions both invoices into roles, recomputes the six models, checks +the averaging property for A and D, the identity violation of B, the negative surplus of C, the within-side merge +control for E/F, binds the two quoted outer statements to their source bytes, and runs six rejecting controls +(broken surplus, wrong recorded surplus, foreign idle rank, swapped targets/paid, literal model as ceiling, tampered +source pin). The stored receipt in `RESULT.json` must match. Decimal arithmetic at 40 digits, roots bisected to +10⁻¹²; no numpy. + +Not run: the 47-inequality outer engine with `a = b = s`; the outer admission is cited from +`kappa01-outer-repair` §2 and not replayed, because the invoice ceiling alone decides the question. + +## Open next questions + +- **Can a changed controller give a joint word more credits per port window than either side has?** Why it matters: + the ceiling above is tied to `S ≤ S_c + S_b` on the same windows; a controller whose idle stages or thin shears are + genuinely shared between the two endpoints would change S, not only G. First step: write the surplus identity of + `controller.py` for a two-endpoint port (one window serving both the complex target and the address target) and + check whether the +1 credit can be claimed twice without a second main field. Blocked by: no two-endpoint native + word or controller exists; `research/thin-query-shear-floor` and the centre floors (#4700, #5060) bound the + per-endpoint terms separately. + +## Credit + +Invoices: #4470 (zxv lineage, `joint-helper-lattice`) and #4814 (ai-nanachi, `bit-finite-ordinary-bootstrap`, on +PR4760's compact436 word). Outer reduction and the conditional one-supplier remark: `kappa01-outer-repair` (OpenAI +assistance) and the balanced engine of `coordinated-frames-and-entrance-banks` (Zhihao Chen, RaD/hipotures, icekylinx, +eumemic). Moment model and lever table: `productive-lever-reprice` (Matarener). Prepared by Mark (Matarener) with +substantial Claude (Anthropic) assistance; Apache-2.0. No human review beyond the author is claimed. diff --git a/research/joint-supplier-average-ceiling/RESULT.json b/research/joint-supplier-average-ceiling/RESULT.json new file mode 100644 index 0000000000..ed8f93dbe9 --- /dev/null +++ b/research/joint-supplier-average-ceiling/RESULT.json @@ -0,0 +1,202 @@ +{ + "schema_version": 1, + "status": "negative-result", + "summary": { + "claim": "On the p16 controller, any one-word-for-both-sides supplier whose joint ledger respects the rank-mass identity has saving at most the mass-weighted average of the #4470 complex root and the #4814 BIT root: C_joint <= 0.003232 (+7.0% over the selected 0.00302015), below the 0.003475458 BIT gate (+15.1%) that an ordinary complex-side improvement reaches. Idle ranks 8(j+1) and 7(j+1) never coincide; the literal 'identical (rank, role) paid once' rule drops 74,499 paid mass with unchanged targets and is not a ceiling; aligned-max twins have negative surplus; the only large variants are the known small-job merge lever.", + "selected_kappa_unchanged": "0.00302015", + "bit_admitted_unchanged": "0.003475458" + }, + "receipt": { + "baseline": { + "complex_root": "0.003020165977015620489716149158188481802050", + "bit_root": "0.003475458064076428997514139772259187321850", + "S_complex": 752, + "S_bit": 753, + "G_complex": "250637", + "G_bit": "218265", + "S_over_G_complex": "0.003000", + "S_over_G_bit": "0.003450" + }, + "models": { + "A_side_by_side": { + "C_joint": "0.003232027079", + "S": 1505, + "G": "468902", + "ratio_to_complex": "1.0701", + "ratio_to_bit": "0.9300", + "mass_identity": true, + "target_mass": 456672, + "paid_mass": 455167 + }, + "B_literal_paid_once": { + "C_joint": "0.182226946239", + "S": 76004, + "G": "592405", + "ratio_to_complex": "60.3367", + "ratio_to_bit": "52.4325", + "mass_identity": false, + "target_mass": 456672, + "paid_mass": 380668 + }, + "C_aligned_max": { + "C_joint": "0E-12", + "S": -5314, + "G": "244590", + "ratio_to_complex": "0.0000", + "ratio_to_bit": "0.0000", + "mass_identity": true, + "target_mass": 245772, + "paid_mass": 251086 + }, + "D_stacked_sum": { + "C_joint": "0.003198535119", + "S": 1505, + "G": "474776", + "ratio_to_complex": "1.0591", + "ratio_to_bit": "0.9203", + "mass_identity": true, + "target_mass": 456672, + "paid_mass": 455167 + }, + "E_paid_merged_targets_separate": { + "C_joint": "0.009324901846", + "S": 1505, + "G": "162702", + "ratio_to_complex": "3.0875", + "ratio_to_bit": "2.6831", + "mass_identity": true, + "target_mass": 456672, + "paid_mass": 455167 + }, + "F_paid_merged_reverse_pairing": { + "C_joint": "0.007541218084", + "S": 1505, + "G": "201811", + "ratio_to_complex": "2.4970", + "ratio_to_bit": "2.1698", + "mass_identity": true, + "target_mass": 456672, + "paid_mass": 455167 + } + }, + "conclusion": { + "best_mass_consistent_joint": "0.003232027", + "gain_over_selected": "0.0701", + "bit_gate_gain": "0.1508" + } + }, + "ledger": { + "identical_rank_role_paid_jobs": 35589, + "identical_rank_role_paid_mass": 74499, + "paid_mass": { + "complex": 239134, + "bit": 216033 + }, + "paid_by_role": { + "complex": { + "centre": { + "8": 144 + }, + "local": { + "1": 40266, + "2": 6984, + "3": 8892, + "4": 2646, + "5": 648 + }, + "shear": { + "1": 1680 + }, + "idle": { + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 224 + } + }, + "bit": { + "centre": {}, + "local": { + "1": 23742, + "2": 24156, + "3": 1404, + "4": 702, + "5": 1836, + "6": 180, + "7": 324 + }, + "shear": { + "1": 1665 + }, + "idle": { + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444, + "63": 222 + } + } + }, + "targets_by_role": { + "complex": { + "main": { + "145": 224 + }, + "idle": { + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 224 + }, + "helper": { + "4": 504, + "7": 126, + "8": 846, + "9": 5868 + } + }, + "bit": { + "main": { + "127": 222 + }, + "idle": { + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222 + }, + "helper": { + "4": 72, + "8": 7776 + } + } + } + }, + "within_side_merge_control": { + "complex_local_jobs_paired": "0.004109298", + "ratio_to_complex": "1.3606" + }, + "rejected_controls": [ + "surplus identity", + "recorded BIT surplus", + "idle rank grid", + "decreasing equation", + "literal model as ceiling", + "source pin" + ] +} \ No newline at end of file diff --git a/research/joint-supplier-average-ceiling/SOURCES.json b/research/joint-supplier-average-ceiling/SOURCES.json new file mode 100644 index 0000000000..414eab28e2 --- /dev/null +++ b/research/joint-supplier-average-ceiling/SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "ff3cc58e370d0f678e529246f8c73e8094e18fcf", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/bit-finite-ordinary-bootstrap/RESULT.json", + "usage": "input", + "git_blob": "0d5096a14323292bbf34718b9486218fc69ec330", + "sha256": "3dac46ede90682b793e4508d7ca48000780501e54218425545a47399fc24d745" + }, + { + "path": "research/coordinated-frames-and-entrance-banks/arithmetic/balanced_shared.py", + "usage": "input", + "git_blob": "e94c7dcaa98b72941f35416009c33801ab4ebbb0", + "sha256": "c3204e1758057f5ef10724014f38b91b8a01f6d8a3562b054263fc74795bfd90" + }, + { + "path": "research/joint-helper-lattice/RESULT.json", + "usage": "input", + "git_blob": "edf41a49a0350862c23378f837c7397fc5dc7596", + "sha256": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21" + }, + { + "path": "research/kappa01-outer-repair/README.md", + "usage": "input", + "git_blob": "656c3746a6ea30b709fa748e7a392169c66bf8a4", + "sha256": "068cd8333facf27c9ea85c114f027a890801ec9fdd81370a4ca5c92ec2ed4f2d" + } + ] +} diff --git a/research/joint-supplier-average-ceiling/TASK.json b/research/joint-supplier-average-ceiling/TASK.json new file mode 100644 index 0000000000..46e57220ab --- /dev/null +++ b/research/joint-supplier-average-ceiling/TASK.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 7, + "base_commit": "ff3cc58e370d0f678e529246f8c73e8094e18fcf", + "original_card": { + "id": "joint-query-controller", + "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/qq16-caller-install/README.md" + ], + "methods": [ + "Derive the matched whole-caller physical bill for installed and baseline protocols.", + "Change the actual demanded observations and prove a cheaper legal producer/consumer contract." + ], + "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 #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.", + "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.", + "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.", + "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving." + ], + "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", + "4166", + "qq16-caller-install" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Price a changed demand on the two installed endpoints: one native word serving the bit address-interchange endpoint and the complex butterfly-layer endpoint in one call. Side-by-side (rank, role) ledger of the #4470 complex invoice and the #4814 BIT invoice, and the ceiling of every mass-consistent joint ledger.", + "scope_change_reason": "The card asks about the QQ16 caller's matched protocol bill or a changed demand that removes paid work. This package prices a different changed demand (a joint bit+complex supplier, the door left open by kappa01-outer-repair sec. 2) rather than the installed caller; it answers whether that demand can remove paid work on the current p16 controller. It does not touch the QQ16 producer/consumer contract.", + "bottleneck_link": "kappa = min(bit, complex) is set inside the layer recursion where bit swaps implement the per-node basis changes; a joint supplier would remove the min. The invoices show its saving cannot exceed the mass-weighted average of the two sides (0.003232), below the BIT gate 0.003475458, so the joint route cannot move the selected kappa past an ordinary complex-side improvement.", + "budget_minutes": 90, + "stop_rule": "Stop once every mass-consistent joint model is bounded by the two side roots and the only larger variants are identified as the known small-job merge lever; no word search.", + "outcome": "negative-result", + "evidence": "RESULT.json receipt reproduced by verify.py: both raw roots to 1e-13, surplus identities 752/753, six joint models (A 0.003232, B identity violated, C no saving, D 0.003199, E/F merge lever), within-side merge control 0.004109, six rejecting controls.", + "author": "Mark (Matarener)", + "ai_assistance": "Substantial: Claude (Anthropic) via Claude Code wrote the analysis, scripts and text under the author's direction; no OpenAI tools.", + "open_questions": [ + { + "question": "Can a changed controller give a joint two-endpoint word more credits per port window than either side has alone?", + "why_it_matters": "The ceiling here rests on S_joint <= S_c + S_b on the same port windows; a controller whose idle stages or thin shears are genuinely shared between the two endpoints would change the surplus, not only the paid moment.", + "first_step": "Write the controller.py surplus identity for a two-endpoint port (one window serving the complex target and the address target) and check whether the +1 credit can be claimed twice without a second main field.", + "blocked_by": "No two-endpoint native word or controller exists; thin-query-shear-floor and the centre floors (#4700, #5060) bound the per-endpoint terms separately." + } + ] +} \ No newline at end of file diff --git a/research/joint-supplier-average-ceiling/VERIFY.json b/research/joint-supplier-average-ceiling/VERIFY.json new file mode 100644 index 0000000000..a8d19ebfbf --- /dev/null +++ b/research/joint-supplier-average-ceiling/VERIFY.json @@ -0,0 +1,23 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/bit-finite-ordinary-bootstrap/RESULT.json", + "research/coordinated-frames-and-entrance-banks/arithmetic/balanced_shared.py", + "research/joint-helper-lattice/RESULT.json", + "research/kappa01-outer-repair/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Authenticates the four pinned inputs; reproduces the #4470 complex raw root 0.00302016597702 and the #4814 BIT raw root 0.00347545806408 to 1e-13; surplus identities 752 = 112*32 - 18*64 - 1680 and 753 (recorded); role partition of both invoices; identical (rank, role) paid mass 74499 with idle ranks coinciding only at 56; six joint models: A and D between the side roots with surplus 1505, B violates the mass identity (-74499 paid mass), C negative surplus, E/F surplus 1505; within-side merge control 0.004109 > BIT root; best mass-consistent joint 0.003232 < 0.003475458; source binding of the kappa01-outer-repair sec. 2 remark and the balanced-engine margins; six rejecting controls; receipt equals RESULT.json." + } + ] +} \ No newline at end of file diff --git a/research/joint-supplier-average-ceiling/verify.py b/research/joint-supplier-average-ceiling/verify.py new file mode 100644 index 0000000000..30e8875000 --- /dev/null +++ b/research/joint-supplier-average-ceiling/verify.py @@ -0,0 +1,325 @@ +#!/usr/bin/env python3 +"""Joint bit+complex supplier on the p16 controller: side-by-side ledger of the #4470 complex invoice and the #4814 BIT +invoice, and the ceiling of any one-call-for-both-sides word under the paid-profile moment model. + +usage: python3.12 -B verify.py [--json OUT] + +Model (#4470 PROOF.md section 5, #4814 price.py): a side's saving C is the root of + f(C) = sum_T n_r r^(1-C) - sum_P n_r r^(1-C) = 0 +over its productive targets T and paid recursive jobs P. The rank-mass identity sum_T r - sum_P r = S is fixed by the +p16 controller (credits per port window - centre - thin shears): 752 on complex, 753 on BIT. +Standard library only; roots are bisected with 40-digit Decimal arithmetic. +""" +from collections import Counter +from decimal import Decimal, getcontext +from pathlib import Path +import hashlib, json, re, sys + +getcontext().prec = 40 +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +CX = "research/joint-helper-lattice/RESULT.json" # #4470 complex invoice, selected kappa 0.00302015 +BT = "research/bit-finite-ordinary-bootstrap/RESULT.json" # #4814 BIT invoice, admitted ordinary 0.003475458 +OUTER = "research/kappa01-outer-repair/README.md" # conditional "one supplier for both" reduction, sec. 2 +ENGINE = "research/coordinated-frames-and-entrance-banks/arithmetic/balanced_shared.py" + + +def need(ok, msg): + if not ok: + raise ValueError("FAIL: " + msg) + + +def sha256(path): + return hashlib.sha256((ROOT / path).read_bytes()).hexdigest() + + +def authenticate(): + pins = {f["path"]: f["sha256"] for f in json.loads((HERE / "SOURCES.json").read_text())["files"]} + for p in (CX, BT, OUTER, ENGINE): + need(sha256(p) == pins[p], "source bytes changed: " + p) + + +# ------------------------------------------------------------------ moment arithmetic +def D(x): + return Decimal(x) + + +def mom(prof, t): + return sum((D(n) * D(r) ** t for r, n in prof.items() if n), D(0)) + + +def f_of(T, P): + return lambda c: mom(T, 1 - c) - mom(P, 1 - c) + + +def root(T, P, lo=D("1e-12"), hi=D(1), iters=140): + """Root of f in (0,1): 0 if f(lo) <= 0 (no saving), 1 if f(1) > 0 (beyond the model).""" + f = f_of(T, P) + if f(lo) <= 0: + return D(0) + if f(hi) > 0: + return D(1) + for _ in range(iters): + mid = (lo + hi) / 2 + lo, hi = (mid, hi) if f(mid) > 0 else (lo, mid) + return lo + + +def mass(prof): + return sum(r * n for r, n in prof.items()) + + +def logmoment(prof): + return sum(D(n) * D(r) * D(r).ln() for r, n in prof.items() if n) + + +def SG(T, P): + """Linearisation f(C) ~= S - C*G: S = mass surplus, G = log-moment difference.""" + return mass(T) - mass(P), logmoment(T) - logmoment(P) + + +def cnt(d): + return Counter({int(k): int(v) for k, v in d.items()}) + + +def expand(prof, reverse=True): + out = [] + for r, n in sorted(prof.items()): + out += [r] * n + return sorted(out, reverse=reverse) + + +def pair(a, b, combine, rev_b=True): + """Pair two rank multisets element-wise after sorting; leftovers stay single.""" + la, lb = expand(a), expand(b, rev_b) + out = Counter() + k = min(len(la), len(lb)) + for i in range(k): + out[combine(la[i], lb[i])] += 1 + for r in la[k:] + lb[k:]: + out[r] += 1 + return out + + +# ------------------------------------------------------------------ invoices and roles +def load(): + cx = json.loads((ROOT / CX).read_text()) + bt = json.loads((ROOT / BT).read_text())["raw_invoice"] + need(cx["full_calls"] == bt["thick_calls"] == 18, "both sides are the 18-call p16 controller") + need(cx["query_shears"] == 15 and bt["thin_queries"] == 1665, "15 thin query stages per port") + Tc, Pc, Tb, Pb = cnt(cx["targets"]), cnt(cx["paid"]), cnt(bt["targets"]), cnt(bt["paid"]) + return cx, bt, Tc, Pc, Tb, Pb + + +def roles(cx, bt, Tc, Pc, Tb, Pb): + """Split paid jobs into idle / local / shear / centre and targets into main / idle / helper on both sides.""" + calls, pc, pb = 18, 112, 111 + LPc = cnt(cx["local_paid"]) + paid_c = {"centre": Counter({8: calls * LPc[8]}), + "local": Counter({r: calls * n for r, n in LPc.items() if r != 8}), + "shear": Counter({1: cx["query_shears"] * pc})} + idle = Pc.copy() + for p in paid_c.values(): + idle.subtract(p) + paid_c["idle"] = +idle + need(all(r % 8 == 0 and r >= 16 for r in paid_c["idle"]), "complex idle ranks 8(j+1)") + idle_b = Counter({r: n for r, n in Pb.items() if r >= 14}) + need(all(r % 7 == 0 for r in idle_b), "BIT idle ranks 7(j+1)") + shear_b = Counter({1: bt["thin_queries"]}) + local_b = Pb.copy(); local_b.subtract(idle_b); local_b.subtract(shear_b); local_b = +local_b + need(all(1 <= r <= 7 for r in local_b), "BIT local ranks 1..7") + paid_b = {"centre": Counter(), "local": local_b, "shear": shear_b, "idle": idle_b} + for name, parts, P in (("complex", paid_c, Pc), ("bit", paid_b, Pb)): + tot = Counter() + for p in parts.values(): + tot.update(p) + need(+tot == +P, name + " paid roles partition the invoice") + + def targets(T, big, step): + main = Counter({big: T[big]}) + idle = Counter({r: n for r, n in T.items() if r != big and r > 9 and (r - 1) % step == 0}) + helper = T.copy(); helper.subtract(main); helper.subtract(idle) + return {"main": main, "idle": idle, "helper": +helper} + + tg_c, tg_b = targets(Tc, 145, 8), targets(Tb, 127, 7) + need(sum(tg_c["idle"].values()) == sum(paid_c["idle"].values()) == 3360, "3360 complex idle pairs") + need(sum(tg_b["idle"].values()) == sum(paid_b["idle"].values()) == 3330, "3330 BIT idle pairs") + need(tg_c["main"][145] == 2 * pc and tg_b["main"][127] == 2 * pb, "two main fields per port") + return paid_c, paid_b, tg_c, tg_b + + +def identities(cx, bt, Tc, Pc, Tb, Pb): + Sc, Sb = mass(Tc) - mass(Pc), mass(Tb) - mass(Pb) + need(Sc == 752 == 112 * 32 - 18 * 64 - 1680, "complex surplus 752 = ports*32 - centre - shears") + need(Sb == 753 == bt["rank_surplus"], "BIT surplus 753 as recorded in #4814") + need(sum(Tc.values()) == cx["productive_fields"] == 10928 and sum(Pc.values()) == cx["paid_calls"] == 64620, "#4470 counts") + need(sum(Tb.values()) == bt["original_fields"] == 11400, "#4814 original fields") + return Sc, Sb + + +# ------------------------------------------------------------------ the six joint models +def models(paid_c, paid_b, tg_c, tg_b): + both = lambda a, b: Counter(a) + Counter(b) + once = lambda a, b: Counter({r: max(a[r], b[r]) for r in set(a) | set(b)}) + amax = lambda a, b: pair(a, b, max) + asum = lambda a, b: pair(a, b, lambda x, y: x + y) + asum_rev = lambda a, b: pair(a, b, lambda x, y: x + y, rev_b=False) + + def build(rule_t, rule_p): + T, P = Counter(), Counter() + for role in ("main", "idle", "helper"): + T.update(rule_t(tg_c[role], tg_b[role])) + for role in ("idle", "local", "shear", "centre"): + P.update(rule_p(paid_c[role], paid_b[role])) + return T, P + + return { + "A_side_by_side": build(both, both), + "B_literal_paid_once": build(both, once), + "C_aligned_max": build(amax, amax), + "D_stacked_sum": build(asum, asum), + "E_paid_merged_targets_separate": build(both, asum), + "F_paid_merged_reverse_pairing": build(both, asum_rev), + } + + +def decreasing(T, P, upto=D("0.05"), steps=50): + """f is strictly decreasing on [0, upto] iff its log-moment G(t) stays positive there (checked on a grid).""" + for i in range(steps + 1): + c = upto * i / steps + t = 1 - c + g = sum(D(n) * D(r) ** t * D(r).ln() for r, n in T.items()) - sum(D(n) * D(r) ** t * D(r).ln() for r, n in P.items()) + if g <= 0: + return False + return True + + +def run(out): + authenticate() + cx, bt, Tc, Pc, Tb, Pb = load() + Sc, Sb = identities(cx, bt, Tc, Pc, Tb, Pb) + paid_c, paid_b, tg_c, tg_b = roles(cx, bt, Tc, Pc, Tb, Pb) + Cc, Cb = root(Tc, Pc), root(Tb, Pb) + need(abs(Cc - D("0.00302016597702")) < D("1e-13"), "complex raw root 0.00302016597702 (#4470)") + need(abs(Cb - D("0.00347545806408")) < D("1e-13"), "BIT raw root 0.00347545806408 (#4814)") + Gc, Gb = SG(Tc, Pc)[1], SG(Tb, Pb)[1] + need(decreasing(Tc, Pc) and decreasing(Tb, Pb), "both side equations are decreasing on [0, 0.05]") + out["baseline"] = {"complex_root": str(Cc), "bit_root": str(Cb), "S_complex": Sc, "S_bit": Sb, + "G_complex": str(Gc.quantize(D(1))), "G_bit": str(Gb.quantize(D(1))), + "S_over_G_complex": str((D(Sc) / Gc).quantize(D("1e-6"))), "S_over_G_bit": str((D(Sb) / Gb).quantize(D("1e-6")))} + + # ledger of identical (rank, role) paid jobs + common = {role: Counter({r: min(paid_c[role][r], paid_b[role][r]) for r in set(paid_c[role]) | set(paid_b[role])}) + for role in paid_c} + common_mass = sum(mass(+c) for c in common.values()) + need(set(+common["idle"]) == {56}, "idle ranks 8(j+1) and 7(j+1) coincide only at 56") + need(common_mass == 74499, "identical (rank, role) paid mass 74499") + out["ledger"] = {"identical_rank_role_paid_jobs": sum(sum((+c).values()) for c in common.values()), + "identical_rank_role_paid_mass": common_mass, + "paid_mass": {"complex": mass(Pc), "bit": mass(Pb)}, + "paid_by_role": {s: {role: dict(sorted(p.items())) for role, p in parts.items()} + for s, parts in (("complex", paid_c), ("bit", paid_b))}, + "targets_by_role": {s: {role: dict(sorted(p.items())) for role, p in parts.items()} + for s, parts in (("complex", tg_c), ("bit", tg_b))}} + + res = {} + for name, (T, P) in models(paid_c, paid_b, tg_c, tg_b).items(): + C = root(T, P) + S, G = SG(T, P) + res[name] = {"C_joint": str(C.quantize(D("1e-12"))), "S": S, "G": str(G.quantize(D(1))), + "ratio_to_complex": str((C / Cc).quantize(D("1e-4"))), "ratio_to_bit": str((C / Cb).quantize(D("1e-4"))), + "mass_identity": S <= Sc + Sb, "target_mass": mass(T), "paid_mass": mass(P)} + out["models"] = res + A, B, Cm, Dm, E, F = (res[k] for k in ("A_side_by_side", "B_literal_paid_once", "C_aligned_max", "D_stacked_sum", + "E_paid_merged_targets_separate", "F_paid_merged_reverse_pairing")) + # averaging: any mass-consistent joint model with both target sets stays between the two side roots + for name in ("A_side_by_side", "D_stacked_sum"): + C = D(res[name]["C_joint"]) + need(Cc < C < Cb, name + " lies strictly between the two side roots") + need(res[name]["S"] == Sc + Sb, name + " keeps the surplus 1505") + need(not B["mass_identity"] and B["S"] == Sc + Sb + 74499 and D(B["C_joint"]) > D("0.1"), + "literal paid-once rule drops 74499 paid mass with unchanged targets: identity violated, root not a ceiling") + need(Cm["S"] < 0 and D(Cm["C_joint"]) == 0, "aligned-max twins have negative surplus: no saving") + need(E["S"] == F["S"] == Sc + Sb and D(E["C_joint"]) > Cb and D(F["C_joint"]) > Cb, "E/F keep the surplus and gain only from merging") + + # E/F are the within-side small-job merge lever, not a two-sided effect: the same pairing inside the complex side alone + loc = paid_c["local"] + half = expand(loc) + merged = Counter() + for i in range(0, len(half) - 1, 2): + merged[half[i] + half[i + 1]] += 1 + if len(half) % 2: + merged[half[-1]] += 1 + P1 = Counter(paid_c["idle"]) + paid_c["shear"] + paid_c["centre"] + merged + C1 = root(Tc, P1) + need(mass(P1) == mass(Pc) and C1 > Cb, "pairwise merge of complex local jobs alone already exceeds the BIT root") + out["within_side_merge_control"] = {"complex_local_jobs_paired": str(C1.quantize(D("1e-9"))), + "ratio_to_complex": str((C1 / Cc).quantize(D("1e-4")))} + + # the best mass-consistent two-sided model (A or D) stays below the BIT gate that an ordinary complex improvement reaches + best = max(D(A["C_joint"]), D(Dm["C_joint"])) + need(best < Cb, "joint word ceiling below the BIT gate 0.003475458") + out["conclusion"] = {"best_mass_consistent_joint": str(best.quantize(D("1e-9"))), + "gain_over_selected": str(((best / Cc) - 1).quantize(D("1e-4"))), + "bit_gate_gain": str(((Cb / Cc) - 1).quantize(D("1e-4")))} + + # source binding of the outer statements used in the README (provenance only; no engine replay here) + outer = (ROOT / OUTER).read_text(encoding="utf-8") + need(re.search(r"no separate numerical bit endpoint: one can choose both `a Date: Sat, 24 Oct 2026 20:21:35 +0300 Subject: [PATCH 2/2] State the joint-supplier ceiling under the whole-job premise; prove single crossing by weighted tails Review of #5298: models E/F keep the rank mass and exceed both roots, so the 0.003232 ceiling needs the no-merge (whole-job) premise; README, RESULT and TASK now say so and add the open question. Monotonicity is now certified by the #5341 weighted-tail lemma (exact minimum tails 32480 / 26160 / 32480, ranks below e^5) instead of a grid; the surplus identity of admission-constant-derivation is written out. Co-Authored-By: Claude Opus 5.5 (1M context) --- .../joint-supplier-average-ceiling/README.md | 45 ++++++++++++++----- .../RESULT.json | 9 +++- .../joint-supplier-average-ceiling/TASK.json | 4 +- .../joint-supplier-average-ceiling/verify.py | 31 ++++++++++--- 4 files changed, 70 insertions(+), 19 deletions(-) diff --git a/research/joint-supplier-average-ceiling/README.md b/research/joint-supplier-average-ceiling/README.md index 98192fc9e2..fb8ecde3f5 100644 --- a/research/joint-supplier-average-ceiling/README.md +++ b/research/joint-supplier-average-ceiling/README.md @@ -6,10 +6,15 @@ and the butterfly layer in one native call removes the separate bit endpoint, an credits of the two sides while the large neutral work (idle stages, local small jobs) is done once, so that `C_joint ≈ (S_complex + S_bit) / G_shared` could exceed both sides. -**Result: on the current p16 controller this cannot happen.** Any joint ledger that respects the rank-mass identity of -the admission has a saving between the two side roots, at most **0.003232** (+7.0% over the selected 0.00302015 of -#4470), which is **below the BIT gate 0.003475458** (+15.1%) that an ordinary complex-side improvement already reaches. -The selected κ and the BIT admission are unchanged. The script runs in seconds on the standard library. +**Result: on the current p16 controller, under the whole-job premise, this cannot happen.** If each side's paid jobs +keep their individual ranks (no paid job of one side is merged with another job), any joint ledger that respects the +rank-mass identity of the admission has a saving between the two side roots, at most **0.003232** (+7.0% over the +selected 0.00302015 of #4470), which is **below the BIT gate 0.003475458** (+15.1%) that an ordinary complex-side +improvement already reaches. The premise is needed: the mass identity alone does not cap the joint saving, because +merging paid jobs keeps mass and raises the root (models E and F below, and the same merge inside the complex side +alone). That premise is #4416's whole-job premise; whether it binds a *joint* native word, where one child could serve +jobs of both endpoints, is open. The selected κ and the BIT admission are unchanged. The script runs in seconds on the +standard library. ## The two invoices side by side @@ -53,9 +58,21 @@ How to read them. `S_joint ≤ S_c + S_b = 1505` and the paid mass must be at least `456 672 − 1505`. The heuristic "same S, G once" is self-contradictory: S and G are the same function `f(C)` at two points, and paid moment cannot be removed without removing paid mass. + + The surplus is the controller identity of `research/admission-constant-derivation` §2, + `S = (p + 2)·(H − C + Σ_ports (2·b_port + 1)) − P` for `p + 2` thick stages, per-stage helper target mass `H`, + paid child mass `C` and `P` ports of block width `b`. Both sides have local balance `H − C + (2b + 1)P = 48`, so + `S_c = 18·48 − 112 = 752` and `S_b = 18·48 − 111 = 753`. A joint word that keeps both sides' ports, helpers and + children has every term of the identity equal to the sum of the two sides' terms, so `S_joint = S_c + S_b = 1505`. + The identity does not by itself bound a word whose ports or windows serve both endpoints at once (see the open + question). - **A and D are the honest two-sided models**, and both give the mass-weighted average of the two roots - (`C ≈ (S_c + S_b)/(G_c + G_b)`), 6–7% above the complex root and 7–8% below the BIT root. The verifier checks that - both side equations are decreasing on `[0, 0.05]`, so the root of their sum lies strictly between the two side roots. + (`C ≈ (S_c + S_b)/(G_c + G_b)`), 6–7% above the complex root and 7–8% below the BIT root. Betweenness is rigorous: + by the weighted-tail lemma of #5341 (`research/fragmentation-single-crossing`), an invoice with all tails + `B_k = Σ_{r≥k} r(n_T − n_P)` nonnegative for `k ≥ 2`, one positive, and largest rank below `e^5` has `f` strictly + decreasing in `C` on `[0, 1/5]`. The verifier computes the tails exactly: minimum 32 480 (complex), 26 160 (BIT) and + 32 480 (their sum), with largest ranks 145 and 127. So each equation has one root, and the sum, positive at the + complex root and negative at the BIT root, crosses strictly between them. Model A moreover requires the caller to supply an interchange task and a layer task simultaneously and independently; in the pipeline they are always sequential on the same data (basis change, then children, then the inverse basis change inside a layer node in `05-layers.tex`; layout move, then layer, then twiddle between rounds in @@ -64,11 +81,12 @@ How to read them. of the larger rank): the credits do not add, they coincide (the same central +1 on the same window), and the mismatch between the local-job distributions (40 266 rank-1 jobs on complex against 24 156 rank-2 jobs on BIT) costs more than the whole surplus, so `S < 0` and there is no saving at all. -- **E and F are not a two-sided effect.** Their gain is the concavity of `r^(1−C)` when small paid jobs are merged into +- **E and F are not a two-sided effect, and they are why the result needs the whole-job premise.** Their gain is the concavity of `r^(1−C)` when small paid jobs are merged into larger ones, the known small-job merge lever (`research/productive-lever-reprice`, "rank-16 children"). The same pairwise merge inside the complex side alone already gives 0.004109 (×1.36), above the BIT root, with no second side. - That lever is closed by the whole-job premise of #4416 and the centre and thin-shear floors; a joint word does not - reopen it. + The lever is closed for each side by the whole-job premise of #4416 and the centre and thin-shear floors. The ceiling + above assumes that this premise also holds for the joint word. That is not shown here: a joint native word in which + one child serves jobs of both endpoints would be a merge across sides. ## Why this closes the door of `kappa01-outer-repair` §2 on the current controller @@ -102,6 +120,11 @@ Not run: the 47-inequality outer engine with `a = b = s`; the outer admission is ## Open next questions +- **Does the whole-job premise bind a joint native word?** Why it matters: the 0.003232 ceiling is conditional on it, + and models E/F show that merging paid jobs across the two endpoints would exceed the BIT root. First step: state + #4416's whole-job premise for a word with two endpoints and check whether one native child can legitimately carry a + complex job and a BIT job at once. + - **Can a changed controller give a joint word more credits per port window than either side has?** Why it matters: the ceiling above is tied to `S ≤ S_c + S_b` on the same windows; a controller whose idle stages or thin shears are genuinely shared between the two endpoints would change S, not only G. First step: write the surplus identity of @@ -115,5 +138,7 @@ Not run: the 47-inequality outer engine with `a = b = s`; the outer admission is Invoices: #4470 (zxv lineage, `joint-helper-lattice`) and #4814 (ai-nanachi, `bit-finite-ordinary-bootstrap`, on PR4760's compact436 word). Outer reduction and the conditional one-supplier remark: `kappa01-outer-repair` (OpenAI assistance) and the balanced engine of `coordinated-frames-and-entrance-banks` (Zhihao Chen, RaD/hipotures, icekylinx, -eumemic). Moment model and lever table: `productive-lever-reprice` (Matarener). Prepared by Mark (Matarener) with +eumemic). Moment model and lever table: `productive-lever-reprice` (Matarener). Single-crossing lemma: #5341 (Ali Romman). +James Reed (jwr404) reviewed the package, found that the headline needs the whole-job premise, and computed the +weighted tails. Prepared by Mark (Matarener) with substantial Claude (Anthropic) assistance; Apache-2.0. No human review beyond the author is claimed. diff --git a/research/joint-supplier-average-ceiling/RESULT.json b/research/joint-supplier-average-ceiling/RESULT.json index ed8f93dbe9..9452ad12bb 100644 --- a/research/joint-supplier-average-ceiling/RESULT.json +++ b/research/joint-supplier-average-ceiling/RESULT.json @@ -2,12 +2,17 @@ "schema_version": 1, "status": "negative-result", "summary": { - "claim": "On the p16 controller, any one-word-for-both-sides supplier whose joint ledger respects the rank-mass identity has saving at most the mass-weighted average of the #4470 complex root and the #4814 BIT root: C_joint <= 0.003232 (+7.0% over the selected 0.00302015), below the 0.003475458 BIT gate (+15.1%) that an ordinary complex-side improvement reaches. Idle ranks 8(j+1) and 7(j+1) never coincide; the literal 'identical (rank, role) paid once' rule drops 74,499 paid mass with unchanged targets and is not a ceiling; aligned-max twins have negative surplus; the only large variants are the known small-job merge lever.", + "claim": "On the p16 controller, under the whole-job premise (each side's paid jobs keep their individual ranks; no cross-job merge), any one-word-for-both-sides supplier whose joint ledger respects the rank-mass identity has saving at most the mass-weighted average of the #4470 complex root and the #4814 BIT root: C_joint <= 0.003232 (+7.0% over the selected 0.00302015), below the 0.003475458 BIT gate (+15.1%) that an ordinary complex-side improvement reaches. The mass identity alone does not cap the joint saving: merging paid jobs keeps mass and raises the root (models E/F, and the same merge inside the complex side alone), so whether the premise binds a joint native word is open. Idle ranks 8(j+1) and 7(j+1) never coincide; the literal 'identical (rank, role) paid once' rule drops 74,499 paid mass with unchanged targets and is not a ceiling; aligned-max twins have negative surplus. Each equation has one root in (0, 1/5] by the weighted-tail lemma of #5341 (minimum tails 32480 / 26160 / 32480).", "selected_kappa_unchanged": "0.00302015", "bit_admitted_unchanged": "0.003475458" }, "receipt": { "baseline": { + "min_weighted_tail": { + "complex": 32480, + "bit": 26160, + "A_sum": 32480 + }, "complex_root": "0.003020165977015620489716149158188481802050", "bit_root": "0.003475458064076428997514139772259187321850", "S_complex": 752, @@ -199,4 +204,4 @@ "literal model as ceiling", "source pin" ] -} \ No newline at end of file +} diff --git a/research/joint-supplier-average-ceiling/TASK.json b/research/joint-supplier-average-ceiling/TASK.json index 46e57220ab..593e73d5c6 100644 --- a/research/joint-supplier-average-ceiling/TASK.json +++ b/research/joint-supplier-average-ceiling/TASK.json @@ -72,11 +72,11 @@ "scope_status": "changed", "actual_scope": "Price a changed demand on the two installed endpoints: one native word serving the bit address-interchange endpoint and the complex butterfly-layer endpoint in one call. Side-by-side (rank, role) ledger of the #4470 complex invoice and the #4814 BIT invoice, and the ceiling of every mass-consistent joint ledger.", "scope_change_reason": "The card asks about the QQ16 caller's matched protocol bill or a changed demand that removes paid work. This package prices a different changed demand (a joint bit+complex supplier, the door left open by kappa01-outer-repair sec. 2) rather than the installed caller; it answers whether that demand can remove paid work on the current p16 controller. It does not touch the QQ16 producer/consumer contract.", - "bottleneck_link": "kappa = min(bit, complex) is set inside the layer recursion where bit swaps implement the per-node basis changes; a joint supplier would remove the min. The invoices show its saving cannot exceed the mass-weighted average of the two sides (0.003232), below the BIT gate 0.003475458, so the joint route cannot move the selected kappa past an ordinary complex-side improvement.", + "bottleneck_link": "kappa = min(bit, complex) is set inside the layer recursion where bit swaps implement the per-node basis changes; a joint supplier would remove the min. The invoices show that, under the whole-job (no cross-job merge) premise, its saving cannot exceed the mass-weighted average of the two sides (0.003232), below the BIT gate 0.003475458, so the joint route cannot move the selected kappa past an ordinary complex-side improvement.", "budget_minutes": 90, "stop_rule": "Stop once every mass-consistent joint model is bounded by the two side roots and the only larger variants are identified as the known small-job merge lever; no word search.", "outcome": "negative-result", - "evidence": "RESULT.json receipt reproduced by verify.py: both raw roots to 1e-13, surplus identities 752/753, six joint models (A 0.003232, B identity violated, C no saving, D 0.003199, E/F merge lever), within-side merge control 0.004109, six rejecting controls.", + "evidence": "RESULT.json receipt reproduced by verify.py: both raw roots to 1e-13, surplus identities 752/753, six joint models (A 0.003232, B identity violated, C no saving, D 0.003199, E/F merge lever), within-side merge control 0.004109, single crossing by exact weighted tails (#5341 lemma), six rejecting controls.", "author": "Mark (Matarener)", "ai_assistance": "Substantial: Claude (Anthropic) via Claude Code wrote the analysis, scripts and text under the author's direction; no OpenAI tools.", "open_questions": [ diff --git a/research/joint-supplier-average-ceiling/verify.py b/research/joint-supplier-average-ceiling/verify.py index 30e8875000..76aa692785 100644 --- a/research/joint-supplier-average-ceiling/verify.py +++ b/research/joint-supplier-average-ceiling/verify.py @@ -8,7 +8,9 @@ f(C) = sum_T n_r r^(1-C) - sum_P n_r r^(1-C) = 0 over its productive targets T and paid recursive jobs P. The rank-mass identity sum_T r - sum_P r = S is fixed by the p16 controller (credits per port window - centre - thin shears): 752 on complex, 753 on BIT. -Standard library only; roots are bisected with 40-digit Decimal arithmetic. +Standard library only; roots are bisected with 40-digit Decimal arithmetic. Uniqueness of each root on [0, 1/5] and the +betweenness of model A's root follow from the weighted-tail lemma of #5341 (exact integer tails, no grid). +The ceiling assumes the whole-job premise: paid jobs keep their individual ranks (no cross-job merge, models A and D). """ from collections import Counter from decimal import Decimal, getcontext @@ -194,6 +196,22 @@ def decreasing(T, P, upto=D("0.05"), steps=50): return True +def weighted_tails(T, P): + """Single-crossing certificate (#5341, research/fragmentation-single-crossing PROOF.md): with c_r = n_T - n_P and + B_k = sum_{r>=k} r c_r, if every B_k (k >= 2) is >= 0, one is > 0 and the largest rank is below e^5, then + f'(t) = sum_{k>=2} B_k (h_t(k) - h_t(k-1)) > 0 with h_t(x) = x^(t-1) ln x increasing on [1, e^5] for t in [4/5, 1]. + So f(C) is strictly decreasing for C = 1 - t in [0, 1/5] and has at most one root there. Returns min B_k.""" + from fractions import Fraction + from math import factorial + c = Counter(T); c.subtract(P) + top = max(r for r in c if c[r]) + exp5 = sum(Fraction(5 ** j, factorial(j)) for j in range(13)) # a rational lower bound for e^5 + need(exp5 > top, "largest rank below e^5") + tails = [sum(r * c[r] for r in c if r >= k) for k in range(2, top + 1)] + need(min(tails) >= 0 and max(tails) > 0, "weighted tails B_k nonnegative with one positive") + return min(tails) + + def run(out): authenticate() cx, bt, Tc, Pc, Tb, Pb = load() @@ -203,8 +221,11 @@ def run(out): need(abs(Cc - D("0.00302016597702")) < D("1e-13"), "complex raw root 0.00302016597702 (#4470)") need(abs(Cb - D("0.00347545806408")) < D("1e-13"), "BIT raw root 0.00347545806408 (#4814)") Gc, Gb = SG(Tc, Pc)[1], SG(Tb, Pb)[1] - need(decreasing(Tc, Pc) and decreasing(Tb, Pb), "both side equations are decreasing on [0, 0.05]") - out["baseline"] = {"complex_root": str(Cc), "bit_root": str(Cb), "S_complex": Sc, "S_bit": Sb, + need(decreasing(Tc, Pc) and decreasing(Tb, Pb), "both side equations are decreasing on [0, 0.05] (grid sanity)") + tails = {"complex": weighted_tails(Tc, Pc), "bit": weighted_tails(Tb, Pb), + "A_sum": weighted_tails(Counter(Tc) + Counter(Tb), Counter(Pc) + Counter(Pb))} + need(tails == {"complex": 32480, "bit": 26160, "A_sum": 32480}, "minimum weighted tails 32480 / 26160 / 32480") + out["baseline"] = {"min_weighted_tail": tails, "complex_root": str(Cc), "bit_root": str(Cb), "S_complex": Sc, "S_bit": Sb, "G_complex": str(Gc.quantize(D(1))), "G_bit": str(Gb.quantize(D(1))), "S_over_G_complex": str((D(Sc) / Gc).quantize(D("1e-6"))), "S_over_G_bit": str((D(Sb) / Gb).quantize(D("1e-6")))} @@ -296,8 +317,8 @@ def rejects(name, fn): # 3. a paid profile with a foreign idle rank is not the p16 role split Pc3 = Counter(Pc); Pc3[20] += 1; Pc3[16] -= 1 rejects("idle rank grid", lambda: roles(cx, bt, Tc, Pc3, Tb, Pb)) - # 4. swapping targets and paid on one side destroys monotonicity, which the averaging argument needs - rejects("decreasing equation", lambda: need(decreasing(Pc, Tc), "x")) + # 4. swapping targets and paid on one side destroys the single-crossing certificate the averaging argument needs + rejects("decreasing equation", lambda: weighted_tails(Pc, Tc)) # 5. the literal paid-once model is rejected as a ceiling by the mass identity check rejects("literal model as ceiling", lambda: need(mass(Tc) + mass(Tb) - (mass(Pc) + mass(Pb) - 74499) <= 752 + 753, "x")) # 6. a tampered source byte is caught by the pin