From 4d71a44c1cba1de9cf3c164bcaabb909f4440fc9 Mon Sep 17 00:00:00 2001
From: Ali Romman <226877337+aliromman@users.noreply.github.com>
Date: Mon, 26 Oct 2026 12:55:54 -0500
Subject: [PATCH 1/3] Retain exact PR5756 tail invoice and pricing source

---
 .../inputs/RESULT.json                        | 1400 +++++++++++++++++
 .../inputs/pricing.py                         |  184 +++
 2 files changed, 1584 insertions(+)
 create mode 100644 research/p104-tail-feasible-envelope/inputs/RESULT.json
 create mode 100644 research/p104-tail-feasible-envelope/inputs/pricing.py

diff --git a/research/p104-tail-feasible-envelope/inputs/RESULT.json b/research/p104-tail-feasible-envelope/inputs/RESULT.json
new file mode 100644
index 0000000000..9d47144bd9
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/inputs/RESULT.json
@@ -0,0 +1,1400 @@
+{
+  "changed_charts": [
+    [
+      11545,
+      [
+        "ADD",
+        42,
+        41,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11546,
+      [
+        "ADD",
+        41,
+        42,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11547,
+      [
+        "ADD",
+        42,
+        41,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11548,
+      [
+        "SCALE",
+        41,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11549,
+      [
+        "SCALE",
+        41,
+        "-2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11550,
+      [
+        "ADD",
+        400,
+        41,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11551,
+      [
+        "ADD",
+        401,
+        41,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11552,
+      [
+        "SCALE",
+        42,
+        "-2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11553,
+      [
+        "ADD",
+        106,
+        42,
+        "1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11554,
+      [
+        "ADD",
+        403,
+        42,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11555,
+      [
+        "ADD",
+        405,
+        106,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11556,
+      [
+        "ADD",
+        106,
+        405,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11557,
+      [
+        "ADD",
+        405,
+        106,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11558,
+      [
+        "SCALE",
+        106,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11559,
+      [
+        "ADD",
+        41,
+        405,
+        "-2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11560,
+      [
+        "ADD",
+        405,
+        42,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11561,
+      [
+        "ADD",
+        405,
+        403,
+        "-1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11562,
+      [
+        "ADD",
+        741,
+        403,
+        "1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11563,
+      [
+        "ADD",
+        741,
+        42,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11564,
+      [
+        "ADD",
+        41,
+        741,
+        "2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11565,
+      [
+        "ADD",
+        410,
+        400,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11566,
+      [
+        "ADD",
+        400,
+        410,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11567,
+      [
+        "ADD",
+        410,
+        400,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11568,
+      [
+        "SCALE",
+        400,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11569,
+      [
+        "SCALE",
+        400,
+        "-2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11570,
+      [
+        "ADD",
+        403,
+        401,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11571,
+      [
+        "ADD",
+        401,
+        403,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11572,
+      [
+        "ADD",
+        403,
+        401,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11573,
+      [
+        "SCALE",
+        401,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11574,
+      [
+        "ADD",
+        42,
+        401,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11575,
+      [
+        "ADD",
+        741,
+        401,
+        "1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11576,
+      [
+        "ADD",
+        41,
+        403,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11577,
+      [
+        "ADD",
+        400,
+        403,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11578,
+      [
+        "ADD",
+        410,
+        403,
+        "-2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11579,
+      [
+        "ADD",
+        410,
+        741,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11580,
+      [
+        "ADD",
+        741,
+        410,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11581,
+      [
+        "ADD",
+        410,
+        741,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11582,
+      [
+        "SCALE",
+        741,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11583,
+      [
+        "SCALE",
+        741,
+        "-1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11584,
+      [
+        "ADD",
+        41,
+        741,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11585,
+      [
+        "ADD",
+        400,
+        741,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11586,
+      [
+        "ADD",
+        403,
+        741,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11587,
+      [
+        "ADD",
+        42,
+        410,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11588,
+      [
+        "ADD",
+        106,
+        410,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11589,
+      [
+        "ADD",
+        401,
+        410,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11590,
+      [
+        "ADD",
+        741,
+        410,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11591,
+      [
+        "ADD",
+        403,
+        410,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11592,
+      [
+        "ADD",
+        401,
+        410,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11593,
+      [
+        "SCALE",
+        410,
+        "2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11594,
+      [
+        "ADD",
+        403,
+        741,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11595,
+      [
+        "ADD",
+        106,
+        741,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11596,
+      [
+        "ADD",
+        42,
+        741,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11597,
+      [
+        "ADD",
+        410,
+        741,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11598,
+      [
+        "ADD",
+        741,
+        410,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11599,
+      [
+        "ADD",
+        410,
+        741,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11600,
+      [
+        "SCALE",
+        741,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11601,
+      [
+        "ADD",
+        410,
+        403,
+        "-1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11602,
+      [
+        "ADD",
+        741,
+        403,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11603,
+      [
+        "ADD",
+        401,
+        403,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11604,
+      [
+        "ADD",
+        400,
+        403,
+        "1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11605,
+      [
+        "ADD",
+        106,
+        403,
+        "-1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11606,
+      [
+        "ADD",
+        42,
+        403,
+        "1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11607,
+      [
+        "ADD",
+        41,
+        403,
+        "-1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11608,
+      [
+        "SCALE",
+        403,
+        "-1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11609,
+      [
+        "ADD",
+        741,
+        401,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11610,
+      [
+        "ADD",
+        403,
+        401,
+        "1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11611,
+      [
+        "ADD",
+        400,
+        401,
+        "-1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11612,
+      [
+        "ADD",
+        106,
+        401,
+        "1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11613,
+      [
+        "ADD",
+        42,
+        401,
+        "1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11614,
+      [
+        "ADD",
+        41,
+        401,
+        "1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11615,
+      [
+        "SCALE",
+        401,
+        "-2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11616,
+      [
+        "ADD",
+        106,
+        400,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11617,
+      [
+        "ADD",
+        42,
+        400,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11618,
+      [
+        "ADD",
+        41,
+        400,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11619,
+      [
+        "SCALE",
+        400,
+        "2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11620,
+      [
+        "ADD",
+        401,
+        400,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11621,
+      [
+        "ADD",
+        400,
+        401,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11622,
+      [
+        "ADD",
+        401,
+        400,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11623,
+      [
+        "SCALE",
+        400,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11624,
+      [
+        "ADD",
+        403,
+        106,
+        "1/2"
+      ],
+      477,
+      127
+    ],
+    [
+      11625,
+      [
+        "ADD",
+        401,
+        106,
+        "-1"
+      ],
+      477,
+      127
+    ],
+    [
+      11626,
+      [
+        "ADD",
+        41,
+        106,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11627,
+      [
+        "SCALE",
+        106,
+        "-2"
+      ],
+      477,
+      127
+    ],
+    [
+      11628,
+      [
+        "ADD",
+        403,
+        42,
+        "1/2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11629,
+      [
+        "ADD",
+        401,
+        42,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11630,
+      [
+        "ADD",
+        41,
+        42,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11631,
+      [
+        "SCALE",
+        42,
+        "-2"
+      ],
+      477,
+      1090
+    ],
+    [
+      11632,
+      [
+        "ADD",
+        400,
+        42,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11633,
+      [
+        "ADD",
+        42,
+        400,
+        "-1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11634,
+      [
+        "ADD",
+        400,
+        42,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11635,
+      [
+        "SCALE",
+        42,
+        "-1"
+      ],
+      477,
+      127
+    ],
+    [
+      11636,
+      [
+        "ADD",
+        403,
+        41,
+        "-1/2"
+      ],
+      477,
+      127
+    ],
+    [
+      11637,
+      [
+        "ADD",
+        401,
+        41,
+        "1"
+      ],
+      477,
+      127
+    ],
+    [
+      11638,
+      [
+        "ADD",
+        400,
+        41,
+        "1"
+      ],
+      477,
+      1090
+    ],
+    [
+      11639,
+      [
+        "ADD",
+        106,
+        41,
+        "1"
+      ],
+      477,
+      127
+    ],
+    [
+      11640,
+      [
+        "ADD",
+        42,
+        41,
+        "1"
+      ],
+      477,
+      127
+    ]
+  ],
+  "complete_cost": {
+    "compiler": {
+      "H": 80511200000000000,
+      "N": "2^80511200000000000",
+      "eta": {
+        "lower": "0.000000128387229643834457871291",
+        "upper": "0.000000128387229643834457871292"
+      },
+      "gap": "1/1400000000000",
+      "integer_test_exponent": 57508,
+      "logarithm_power": 1024,
+      "theta": "63/64",
+      "uniform_saving": "272399571/87500000000",
+      "word_materialized": false
+    },
+    "full_forward_calls": 18,
+    "gain": "2439/20000000000",
+    "kappa": "62262759/20000000000",
+    "kappa_decimal": "0.00311313795",
+    "margin_at_previous": {
+      "lower": "0.029578770580357904755090866637",
+      "upper": "0.029578770580357904755090866638"
+    },
+    "negative_controls": {
+      "old_BIT": "Rejected by outer inequalities",
+      "old_cutoff": "Rejected by completion-tail ratio greater than one",
+      "source_completion": "Rejected at cutoff17, floor18 and decay39/40",
+      "source_offset": "Rejected at cutoff16 with tail offset1/5"
+    },
+    "nonrecursive": {
+      "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.",
+      "local_paid_rank_mass": 5987,
+      "local_routes": 5240000,
+      "local_scalar": 224138,
+      "peak_owned_fields": 2,
+      "raw_budget": 1000000000,
+      "raw_scalar_upper": 184647552,
+      "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word."
+    },
+    "ordinary_BIT": {
+      "admitted": "17/5000",
+      "after_cover": "69/20000",
+      "atom": "1/250",
+      "before_cover": "3459/1000000",
+      "ordinary_saving": "8590884599/2500000000000",
+      "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses"
+    },
+    "outer": {
+      "functional_checks": {
+        "actual_new_BIT_stock_sublinear": "348599999999253/350000000000000",
+        "fixed_halo_explicit_metadata_branch": "26950000000001/350000000000",
+        "new_BIT_row_stock_sublinear_in_active_group": "1395799999997009/1400000000000000",
+        "new_semantic_group_guard": "3/1400000000000"
+      },
+      "margins": {
+        "boundary_algebraic_matrix": "6101750387595641606867/1960000000000000000000000",
+        "fused_gaussian": "6101750387586924820601/1960000000000000000000000",
+        "global_coordinate_router": "2179196567/700000000000",
+        "group_bit_router": "3050875194493462410299/980000000000000000000000",
+        "group_scans": "699999999999/700000000000",
+        "main_transform": "6101750386195641606867/1960000000000000000000000",
+        "microbox_face_corrections": "26950000000001/350000000000",
+        "polynomial_products": "1399999999999/1400000000000",
+        "sparse_union_movement": "802351750387595641606867/1960000000000000000000000"
+      },
+      "parameters": {
+        "a": "2179196567/700000000000",
+        "b": "871678627/280000000000",
+        "beta": "1399999999997/1400000000000",
+        "bit_saving": "17/5000",
+        "cap_xi": "1782351750386195641606867/1960000000000000000000000",
+        "complex_uniform_saving": "272399571/87500000000",
+        "d": "1/1400000000000",
+        "epsilon": "1399999999999/1400000000000",
+        "kappa": "62262759/20000000000",
+        "lambda_": "398754744819/400000000000",
+        "lambda_prime": "1395641606867/1400000000000",
+        "layout": "1/1400000000000",
+        "q": "4358393133/1400000000000",
+        "r0": "1/14000000000000",
+        "stop": "1/1400000000000",
+        "tested_saving": "622627591/200000000000"
+      },
+      "strict_checks": {
+        "actual_bit_above_effective": "200803433/700000000000",
+        "actual_logarithmic_gamma_guard": "1/1400000000000",
+        "actual_logarithmic_group_guard": "177648249615904358393133/980000000000000000000000",
+        "alpha_logarithm_absorption": "1/14000000000000",
+        "boundary_algebraic_matrix_above_kappa": "5595641606867/1960000000000000000000000",
+        "cap_above_band": "802351750386195641606867/1960000000000000000000000",
+        "cap_below_cell": "177648249612404358393133/1960000000000000000000000",
+        "cap_below_phase_cell_power": "2137648249613804358393133/1960000000000000000000000",
+        "complex_above_effective": "1/1400000000000",
+        "complex_below_one_over_32": "7878321373/280000000000",
+        "complex_endpoint": "1/700000000000",
+        "epsilon_below_one": "1/1400000000000",
+        "epsilon_positive": "1399999999999/1400000000000",
+        "fine_prime_halo_umbrella": "7/2",
+        "fused_gaussian_above_kappa": "5586924820601/1960000000000000000000000",
+        "gaussian_above_main": "695641606867/980000000000000000000000",
+        "global_coordinate_router_above_kappa": "1/350000000000",
+        "global_gamma_power_slack": "9/14000000000000",
+        "group_below_dimension": "1/700000000000",
+        "group_bit_router_above_kappa": "3493462410299/980000000000000000000000",
+        "group_gauge_power_slack": "177648249615834358393133/980000000000000000000000",
+        "group_key_fits_record": "1/700000000000",
+        "group_positive": "1399999999997/1400000000000",
+        "group_scans_above_kappa": "348910401717/350000000000",
+        "halo_covers_generic_inverse_radius": "5",
+        "improvement_over_user_baseline": "691083765400418148631/500000000000000000000000",
+        "lambda_above_internal": "1/2800000000000",
+        "lambda_above_sigma": "3/2800000000000",
+        "lambda_above_tau": "1/2800000000000",
+        "lambda_prime_above_lambda": "1/2800000000000",
+        "lambda_prime_above_leaf": "559128321373/392000000000000000000000",
+        "leaf_saving_above_effective": "279128321373/392000000000000000000000",
+        "main_transform_above_kappa": "4195641606867/1960000000000000000000000",
+        "membership_arithmetic_fits_record": "1/1400000000000",
+        "microbox_face_corrections_above_kappa": "53897820803437/700000000000",
+        "microbox_halo_volume": "110600000000003/1400000000000",
+        "new_complex_uniform_saving_above_b": "1/1400000000000",
+        "new_semantic_guard_with_C1_one": "1/1400000000000",
+        "polynomial_products_above_kappa": "1395641606869/1400000000000",
+        "positive_layout_slack": "1/1400000000000",
+        "q_below_effective": "1/1400000000000",
+        "q_below_internal": "1/1400000000000",
+        "q_below_leaf": "559128321373/392000000000000000000000",
+        "q_positive": "4358393133/1400000000000",
+        "short_record_fallback": "279128321373/280000000000",
+        "source_axis_superpolynomial": "1/1400000000000",
+        "sparse_union_movement_above_kappa": "796250000005595641606867/1960000000000000000000000",
+        "stop_below_one": "1399999999999/1400000000000",
+        "stop_positive": "1/1400000000000",
+        "strassen_integer_power_gap": "1951441519231",
+        "support_router_span": "3/1400000000000",
+        "theta_positive_polynomial_power": "2",
+        "union_header_fits_record": "3/1400000000000",
+        "union_tag_work_per_visit_fits_record": "3/1400000000000"
+      }
+    },
+    "paid": {
+      "1": 41520,
+      "16": 416,
+      "2": 8172,
+      "24": 416,
+      "3": 8856,
+      "32": 416,
+      "4": 1674,
+      "40": 416,
+      "48": 416,
+      "5": 3132,
+      "56": 416,
+      "6": 108,
+      "64": 416,
+      "7": 270,
+      "72": 208
+    },
+    "paid_calls": 66852,
+    "previous_pr5718": "389127/125000000",
+    "productive_fields": 13390,
+    "query_shears": 15,
+    "rank_mass_surplus": 760,
+    "raw_ceiling": {
+      "derivative_upper": "-738596154004511222636095493817850924833979710424488126325902089/3138550867693340381917894711603833208051177722232017256448",
+      "interval": [
+        "0",
+        "17/5000"
+      ]
+    },
+    "raw_headroom": [
+      "73/3125000000000",
+      "2337/100000000000000"
+    ],
+    "raw_root_interval": [
+      "38914224667/12500000000000",
+      "311313797337/100000000000000"
+    ],
+    "relative_gain_percent": "4065/1037672",
+    "strictification": {
+      "alpha": {
+        "lower": "0.999999999981368230437503066447",
+        "upper": "0.999999999981368230437503066448"
+      },
+      "cutoff": 16,
+      "delta": {
+        "lower": "0.944337257529929949513398128117",
+        "upper": "0.944337257529929949513398128118"
+      },
+      "floor": 17,
+      "gamma": {
+        "lower": "0.975484709128690914856977434634",
+        "upper": "0.975484709128690914856977434635"
+      },
+      "normalized_paid_upper": "1048576000976562501/1048576001073741824",
+      "power": 1024,
+      "reserve": "1/1000000000000",
+      "tail_block": 128,
+      "tail_decay": "125/128",
+      "tail_offset": "1/7",
+      "tested": "622627591/200000000000"
+    },
+    "targets": {
+      "1": 432,
+      "145": 208,
+      "17": 416,
+      "2": 90,
+      "25": 416,
+      "33": 416,
+      "4": 1656,
+      "41": 416,
+      "49": 416,
+      "5": 126,
+      "57": 416,
+      "65": 416,
+      "7": 108,
+      "73": 208,
+      "8": 666,
+      "9": 6984
+    },
+    "whole_idle_jobs": 3120
+  },
+  "controls": {
+    "block_op_on_old_chart": "Scalar destination and coefficient",
+    "extra_target_credit": "Every productive helper has a native target",
+    "missing_block_move": "Scalar destination and coefficient",
+    "old_helper_start": "Scalar destination and coefficient",
+    "read_after_write": "Dependent operations keep their order",
+    "unpaid_query": "Complete field and call counts"
+  },
+  "global_paid_delta": {
+    "1": 18,
+    "4": 18,
+    "5": -18
+  },
+  "helper_credit_delta": {
+    "1": -1,
+    "4": 1,
+    "5": 1,
+    "8": -1
+  },
+  "helper_finals": {
+    "405": [
+      477,
+      1090
+    ]
+  },
+  "helper_starts": {
+    "741": [
+      477,
+      1090
+    ]
+  },
+  "local": {
+    "endpoint_coefficients": 602176,
+    "helpers": {
+      "1": 24,
+      "2": 5,
+      "4": 92,
+      "5": 7,
+      "7": 6,
+      "8": 37,
+      "9": 388
+    },
+    "owned_fields": 9,
+    "owned_lifetimes": 11,
+    "paid": {
+      "1": 2220,
+      "2": 454,
+      "3": 492,
+      "4": 93,
+      "5": 174,
+      "6": 6,
+      "7": 15
+    },
+    "paid_rank_mass": 5987,
+    "peak_owned_fields": 2,
+    "public_inputs": 767,
+    "real_scalar_allowance": 224138
+  },
+  "local_paid_delta": {
+    "1": 1,
+    "4": 1,
+    "5": -1
+  },
+  "native": {
+    "distinct_maps": 2927,
+    "helper_normalizers": 1118,
+    "helpers": {
+      "1": 24,
+      "2": 5,
+      "4": 92,
+      "5": 7,
+      "7": 6,
+      "8": 37,
+      "9": 388
+    },
+    "main_adapters": 208,
+    "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width",
+    "recipe_payload_sha256": "b566ac8ebfb9df3d4c8a7be449c749283ec70dedbdaad7f943c264c692da544a",
+    "wrong_phase_rejected": true
+  },
+  "physical": {
+    "central_square_columns": 53248,
+    "full_calls": 18,
+    "main_targets": {
+      "145": 208,
+      "17": 416,
+      "25": 416,
+      "33": 416,
+      "41": 416,
+      "49": 416,
+      "57": 416,
+      "65": 416,
+      "73": 208
+    },
+    "new_paid_jobs": 0,
+    "physical_contacts": 7488,
+    "ports": 104,
+    "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142",
+    "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.",
+    "whole_idle_jobs": {
+      "16": 416,
+      "24": 416,
+      "32": 416,
+      "40": 416,
+      "48": 416,
+      "56": 416,
+      "64": 416,
+      "72": 208
+    },
+    "wrapper_sites": [
+      1,
+      3,
+      5,
+      7,
+      9,
+      11,
+      13,
+      15,
+      17,
+      19,
+      21,
+      23,
+      25,
+      27,
+      29,
+      31
+    ]
+  },
+  "source": {
+    "pr5751": "8483f9a679d06c1e270141dbc686a7e76e7a7522"
+  },
+  "status": "PASS_P104_R22_REFRAME_KAPPA_00311313795",
+  "transpose": {
+    "arithmetic": "Dense integer rows with binary denominators; reverse chronology",
+    "coefficients": 602176,
+    "columns": 776
+  }
+}
diff --git a/research/p104-tail-feasible-envelope/inputs/pricing.py b/research/p104-tail-feasible-envelope/inputs/pricing.py
new file mode 100644
index 0000000000..fe40a9cb39
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/inputs/pricing.py
@@ -0,0 +1,184 @@
+"""Complete mixed-target price, compiler and outer transfer.
+
+The interval and compiler bounds follow zxv and Cao Yifan. The productive
+recursion is by Jacob Alan Sussman. The controller is by Cinna Davis.
+Adapted from Ali Romman's PR5544/5545 for the two coupled contact changes.
+Successor choices were prepared for thu-nmrc with OpenAI Codex assistance.
+Helper-subspace targets were added by Ali Romman with OpenAI Codex assistance.
+The source commuting-contact construction is by Pierre-Loic Doulcet (hexapode) in PR5565.
+The source coupled-frame change is by Ali Romman with OpenAI Codex in PR5601.
+Five fixed boundary relations are from Ali Romman's PR5602.
+The shared and delayed relays are from flyingviper's PR5605 and PR5612. The preparation is from
+Scratch-net's PR5606. Their costs and target debit are included.
+Ali Romman's complete caller/price proof and all predecessor credit are retained.
+The paid A2 change is from zxv PR5643. The three helper relations are from
+Ali Romman PR5644. The four-gate change is by Ali Romman with Codex assistance.
+The four interior basis changes are by Ali Romman with Codex assistance.
+Paid intermediate meetings: Ali Romman with substantial OpenAI Codex assistance.
+Apache-2.0.
+"""
+from collections import Counter
+from fractions import Fraction as Q
+import local as L
+
+KAPPA, TESTED = Q('.00311313795'), Q('.003113137955')
+PREVIOUS = Q('.00311301600')
+
+
+def encode(x):
+    if isinstance(x,Q):
+        return str(x)
+    if isinstance(x,dict):
+        return {str(k):encode(v) for k,v in x.items()}
+    if isinstance(x,(list,tuple)):
+        return [encode(v) for v in x]
+    return x
+
+
+def assemble(local, native, word, physical):
+    paid, targets = Counter(), Counter()
+    counts = Counter()
+    L.need(local['helpers'] == native['helpers'], 'Every productive helper has a native target')
+    for e in word['physical_events']:
+        counts[e[0]] += 1
+        if e[0] == 'LOCAL':
+            L.need(e[3] is False, 'Every source invocation is forward')
+            paid.update(local['paid'])
+            targets.update(local['helpers'])
+        elif e[0] == 'QUERY_SHEAR':
+            paid[1] += 104
+        elif e[0] == 'IDLE':
+            paid[8*len(e[2])] += 208
+    main = Counter()
+    idle = Counter({8*len(e[2]):0 for e in word['physical_events'] if e[0] == 'IDLE'})
+    for e in word['physical_events']:
+        if e[0] == 'IDLE':
+            idle[8*len(e[2])] += 208
+    L.need(idle == physical['whole_idle_jobs'], 'Every whole idle has a native Gaussian and full rank')
+    for term in word['diagonal']:
+        main[1+8*sum(term[1:])] += 104
+    L.need(main == physical['main_targets'], 'Every main target has its full native phase')
+    targets.update(main)
+    L.need(counts['LOCAL'] == 18 and counts['QUERY_SHEAR'] == counts['IDLE'] == 15, 'Complete call census')
+    # Recount by the two path lengths, without using emitted main diagonals.
+    second_t = Counter({r:18*n for r,n in local['helpers'].items()})
+    second_p = Counter({r:18*n for r,n in local['paid'].items()})
+    second_t[145] += 208
+    second_p[1] += 15*104
+    for length in (7,8):
+        for j in range(1,length+1):
+            second_t[1+8*(j+1)] += 208
+            second_p[8*(j+1)] += 208
+    L.need((targets,paid) == (second_t,second_p), 'Independent full invoice')
+    L.need(max(targets) == 145 and max(paid) == 72, 'Maximum recursive ranks')
+    L.need(sum(targets.values()) == 13390 and sum(paid.values()) == 66852, 'Complete field and call counts')
+    L.need(sum(r*n for r,n in targets.items())-sum(r*n for r,n in paid.items()) == 760, 'Complete rank surplus')
+    return targets,paid,counts
+
+
+def run(local,native,word,physical):
+    T,P,counts = assemble(local,native,word,physical)
+    E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py','p104_productive_intervals')
+    other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','p104_productive_second_intervals')
+    def margin(k):
+        a,b = E.moment(T,1-k), E.moment(P,1-k)
+        return a[0]-b[1],a[1]-b[0]
+    lo,hi,grid = 0,10**12,10**14
+    while hi-lo > 1:
+        m=(lo+hi)//2
+        if margin(Q(m,grid))[0] > 0:
+            lo=m
+        else:
+            hi=m
+    lower,upper = Q(lo,grid),Q(hi,grid)
+    signed = Counter(T)
+    signed.subtract(P)
+    cap = Q('.0034')
+    derivative_upper = Q(0)
+    for rank, count in signed.items():
+        logarithm = E.log_bounds(rank)
+        low = E.mul(E.power(rank, 1-cap), logarithm)[0]
+        high = rank*logarithm[1]
+        derivative_upper -= count*(low if count >= 0 else high)
+    L.need(derivative_upper < 0, 'Unique raw crossing below the retained BIT cap')
+    L.need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure')
+    L.need(PREVIOUS < KAPPA < TESTED < lower and margin(PREVIOUS)[0] > 0, 'Changed complete bill improves the source claim')
+    t,u,v,c,b = 1-TESTED,Q(1,7),1024,16,17
+    target,paid = E.moment(T,t),E.moment(P,t)
+    tl,th = other.moment(T,TESTED)
+    pl,ph = other.moment(P,TESTED)
+    L.need(tl > ph and max(tl,target[0]) <= min(th,target[1]) and max(pl,paid[0]) <= min(ph,paid[1]), 'Two exact moment engines')
+    alpha = E.divide(paid,target)
+    gamma = E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target))
+    delta = E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target))
+    reserve,decay = Q(1,10**12),Q(125,128)
+    L.need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All three charged tail ratios')
+    L.need(decay**128 < Q(1,16), 'Both tail decay blocks')
+    normalized = 1/(1+v*reserve)+Q(4,2**32)
+    L.need(normalized < 1 and c**64 < b**63, 'Full completion, splitting and rounding charges')
+    theta,power = Q(63,64),1024
+    eta = E.scale(E.power(145,-v*TESTED),t)
+    L.need(2*(c**v)**64 <= (145**v)**63 and eta[0] > theta**power, 'Shifted exits and complement capacity')
+    L.need(E.power(145,v*TESTED)[1] < 2**power, 'Compiler initial range')
+    gap = (TESTED-KAPPA)/7
+    L.need(gap.numerator == 1, 'Exact compiler integer grid')
+    step = gap.denominator
+    def wins(j):
+        return (step*j+1)**power < 2**j
+    left,right=1,2
+    while not wins(right):
+        left,right=right,2*right
+    while right-left > 1:
+        m=(left+right)//2
+        if wins(m):
+            right=m
+        else:
+            left=m
+    H=step*right
+    L.need(H > 8*v and wins(right) and not wins(right-1), 'Finite uniform threshold with predecessor rejection')
+    local_routes = (sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000
+    L.need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local scalar, route and owned operation is funded')
+    boundary = sum(len(word['boundaries'][side+'_program']) for side in ('left','right'))
+    raw = 18*10**7 + 15*1664 + 32*104*(len(word['physical_events'])+boundary)
+    raw += 32*104*(26+1000)
+    L.need(raw < 10**9, 'Complete nonrecursive raw bound')
+    bit = L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT']
+    atom = Q(bit['atom'])
+    ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599')
+    admitted=Q(bit['admitted'])
+    L.need(atom > ordinary > admitted > TESTED and atom < 1-ordinary, 'Retained BIT admission and stock')
+    outer_module=L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','p104_productive_outer')
+    params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap,
+            'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted,
+            'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap}
+    outer=outer_module.ledger(params)
+    outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom)
+    L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory')
+    L.need(all(x > 0 for key in ('strict_checks','functional_checks') for x in outer[key].values()), 'All outer inequalities strict')
+    wrong_cutoff = E.divide((Q(sum(T.values())*21),)*2,E.mul(E.power(20,TESTED),target))
+    L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory')
+    old_completion = E.divide((Q(sum(T.values())*18),)*2,E.mul(E.power(17,TESTED),target))
+    L.need(old_completion[0] > Q(39,40), 'PR5718 completion-tail bound fails with the new target count')
+    old_offset = E.divide(E.moment(P,t+Q(1,5)),E.mul(E.power(16,Q(1,5)),target))
+    L.need(old_offset[0] > decay, 'The old tail offset fails at the new cutoff')
+    bad=outer_module.ledger(dict(params,bit_saving=Q('.0027')))
+    L.need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT contract rejected')
+    return encode({'kappa':KAPPA,'kappa_decimal':'0.00311313795','previous_pr5718':PREVIOUS,'gain':KAPPA-PREVIOUS,
+                   'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper],
+                   'raw_headroom':[lower-KAPPA,upper-KAPPA],
+                   'raw_ceiling':{'interval':[Q(0),cap],'derivative_upper':derivative_upper},'margin_at_previous':E.display(margin(PREVIOUS)),
+                   'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()),
+                   'rank_mass_surplus':760,'full_forward_calls':18,'query_shears':15,'whole_idle_jobs':3120,
+                   'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'reserve':reserve,'tail_decay':decay,'tail_block':128,
+                                     'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized},
+                   'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'H':H,'N':'2^'+str(H),
+                               'integer_test_exponent':right,'uniform_saving':params['complex_uniform_saving'],'word_materialized':False},
+                   'nonrecursive':{'local_scalar':local['real_scalar_allowance'],'local_routes':local_routes,
+                                   'raw_scalar_upper':raw,'raw_budget':10**9,'peak_owned_fields':local['peak_owned_fields'],
+                                   'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.',
+                                   'local_paid_rank_mass':local['paid_rank_mass'],
+                                   'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word.'},
+                   'ordinary_BIT':bit,'outer':outer,
+                   'negative_controls':{'source_completion':'Rejected at cutoff17, floor18 and decay39/40',
+                                        'source_offset':'Rejected at cutoff16 with tail offset1/5',
+                                        'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}})

From a5cc123d86a17e47eba7a58e2cd6b50ccc536162 Mon Sep 17 00:00:00 2001
From: Ali Romman <226877337+aliromman@users.noreply.github.com>
Date: Mon, 26 Oct 2026 13:02:34 -0500
Subject: [PATCH 2/3] Prove complete fixed P104 R22 tail parameter envelope

---
 .../p104-tail-feasible-envelope/ORIGINS.json  |  18 ++
 research/p104-tail-feasible-envelope/PROOF.md |  81 +++++++
 .../p104-tail-feasible-envelope/README.md     |  71 ++++++
 .../p104-tail-feasible-envelope/RESULT.json   |  60 +++++
 .../p104-tail-feasible-envelope/SOURCES.json  |  44 ++++
 .../p104-tail-feasible-envelope/TASK.json     | 110 +++++++++
 .../p104-tail-feasible-envelope/VERIFY.json   |  23 ++
 .../p104-tail-feasible-envelope/verify.py     | 225 ++++++++++++++++++
 8 files changed, 632 insertions(+)
 create mode 100644 research/p104-tail-feasible-envelope/ORIGINS.json
 create mode 100644 research/p104-tail-feasible-envelope/PROOF.md
 create mode 100644 research/p104-tail-feasible-envelope/README.md
 create mode 100644 research/p104-tail-feasible-envelope/RESULT.json
 create mode 100644 research/p104-tail-feasible-envelope/SOURCES.json
 create mode 100644 research/p104-tail-feasible-envelope/TASK.json
 create mode 100644 research/p104-tail-feasible-envelope/VERIFY.json
 create mode 100644 research/p104-tail-feasible-envelope/verify.py

diff --git a/research/p104-tail-feasible-envelope/ORIGINS.json b/research/p104-tail-feasible-envelope/ORIGINS.json
new file mode 100644
index 0000000000..2b69331d61
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/ORIGINS.json
@@ -0,0 +1,18 @@
+{
+  "source_repository": "CrocSwap/integer-mult-bounds",
+  "source_head": "a1b338e5d9271b541f2a198f4fc19cefc565feed",
+  "files": [
+    {
+      "original_path": "research/p104-block-reframe-r22/RESULT.json",
+      "retained_path": "inputs/RESULT.json",
+      "git_blob": "9d47144bd99dc57d799345c940232eb26afdc33c",
+      "sha256": "062fb71b92ca620cbea4a4469458ede513e4dc1039bfa783e06ed11f51335a9e"
+    },
+    {
+      "original_path": "research/p104-block-reframe-r22/pricing.py",
+      "retained_path": "inputs/pricing.py",
+      "git_blob": "fe40a9cb39c087c3170ee7e79140f4884c8e1873",
+      "sha256": "2a8f0d74a16c8ad3b595e2100f8c074122ecd2c1babf66a4495b20ba9e651ce8"
+    }
+  ]
+}
diff --git a/research/p104-tail-feasible-envelope/PROOF.md b/research/p104-tail-feasible-envelope/PROOF.md
new file mode 100644
index 0000000000..5611eb8f86
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/PROOF.md
@@ -0,0 +1,81 @@
+# Fixed-contract feasibility proof
+
+Fix the retained PR5756 target and paid histograms `T_r,P_r`, saving
+`C=622627591/200000000000` and `t=1-C`. Put `T=sum T_r r^t` and
+`N=sum T_r=13390`. For integer cutoff `c>=1`, integer floor `b`, positive
+real offset `u` and rational decay `rho`, the two source tail gates are
+
+```
+g(c,u) = sum P_r r^(t+u) / (c^u T) < rho,
+d(c,b) = N b / (c^C T) < rho,
+rho^128 < 1/16.
+```
+
+The capacity condition `c^64 < b^63` implies `b>=c+1`. Let
+`R=2^(-1/32)`. A permitted rational rho exists if and only if both g and d
+are strictly below R: rationals are dense in the open interval between their
+maximum and R. Equality at R is excluded. This eliminates every decay choice,
+not just a grid. We first use the weaker condition b>=c+1 to exclude parameters;
+the sole remaining pair also passes the exact capacity condition.
+
+## Exclude all but one integer pair
+
+For positive u, g(c,u) decreases with c. For fixed c, g is a positive sum
+of exponentials in u and is strictly convex, since a paid rank differs from c.
+Its derivative is the same sum weighted by `log(r/c)`. A negative derivative
+at l and positive derivative at h locate its unique global minimum in (l,h).
+For x in this interval, convexity gives
+`g(x)>=g(l)+g'(l)(x-l)>=g(l)+g'(l)(h-l)` when g'(l)<0.
+The verifier uses a lower interval endpoint for both terms. The midpoint gives
+an upper bound on the minimum. Strict convexity extends this statement to all
+real u; no unsearched tail or sampled-grid premise remains.
+
+At c=15 the resulting lower bound is `0.983563652257169`, while
+`R<0.978572062087701`. Thus every positive u fails for c<=15.
+
+For real c>=1, `(c+1)/c^C` has derivative with sign `(1-C)c-C`, which is
+positive because `0<C<1/2`. Also d increases with b. At c=17,b=18 the
+lower bound is `0.999697814388247>R`. Thus every c>=17 and every permitted
+b fails. At c=16,b=18, d exceeds `0.999886507972867>R`, which excludes all
+larger floors. The only pair left is c=16,b=17. It passes `16^64<17^63`.
+
+## Full offset interval and optimum
+
+For c=16, g(0)>R, g(1/7)<R and g(1)>R. Strict convexity, together with the
+unique derivative zero, gives exactly two positive roots of g(u)=R and a
+single open feasible interval between them. The exact root brackets are in
+RESULT.json. The completion tail is constant in u and is below
+`0.944337257529930`. It is below even the global minimum of g, so it never
+binds in this interval. Thus these two roots specify the complete tail set.
+
+The derivative has opposite signs at the endpoints of the reported best-offset
+bracket. The convex minimum bound above gives the stated decay infimum.
+The infimum is not attained by rho because g<rho is strict. Positive rational
+u near the minimizer and rational rho above its value approach it arbitrarily
+closely. If u is restricted to rationals, intersect the same interval with Q;
+all exclusion and approximation statements remain valid.
+
+At u=1/5, g exceeds R, so no permitted rho can repair this offset. At u=1/10,
+`125/128<g<489/500`, and `(489/500)^128<1/16`; this checks the distinction
+between fixed-decay failure and full infeasibility. The source point also
+passes its reserve. Other compiler conditions are not inferred from these gates.
+
+## Arithmetic and limits
+
+The shared power engine encloses fractional powers with integer square roots
+and directed products on a dyadic grid. For arbitrary rational exponent e,
+write e=floor(e)+f with 0<=f<1 and multiply by the exact integer power.
+This is valid for negative exponents as well. Positive denominators permit
+outward interval division.
+
+For x in [1,2], put z=(x-1)/(x+1). The first80 terms of
+`2 sum z^(2j+1)/(2j+1)` are a lower bound for log x. The remaining positive
+tail is at most `2 z^161/(161(1-z^2))`. An integer rank is reduced to this
+range by an exact power of2. Subtraction gives a rigorous log(r/c) interval;
+all four endpoint products handle its possible negative sign. Root bisection
+proceeds only after strict opposite signs are proved. It fails on uncertainty.
+
+The infinite parameter coverage follows from these monotonicity and convexity
+arguments. The finite arithmetic controls do not establish the proof by
+extrapolation. The source invoice and gate formulas are pinned premises;
+this proof does not establish their native realization or a different compiler.
diff --git a/research/p104-tail-feasible-envelope/README.md b/research/p104-tail-feasible-envelope/README.md
new file mode 100644
index 0000000000..a99caa90bf
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/README.md
@@ -0,0 +1,71 @@
+# Complete P104 R22 tail-parameter envelope
+
+For the fixed PR5756 invoice at saving `622627591/200000000000`, the existing
+128-block compiler tail gates admit exactly one integer cutoff and completion
+floor: **16 and 17**. The full positive offset interval is between two roots,
+with enclosures near **0.0901726680035 and 0.193311515488**. The unique best
+offset is in `(0.141270802754661, 0.141270802755571)`. Its best decay infimum
+is in `(0.975481788192714, 0.975481788192715)`.
+
+This is a scoped proof for the declared, complete invoice: 66,852 paid calls,
+13,390 targets and rank surplus 760. It is not a new κ or supplier admission.
+The source's prose count 12,958 is stale; this package uses its JSON and the
+complete inventory. [PROOF.md](PROOF.md) proves coverage of all integer cutoffs,
+all integer floors and the continuum of positive offsets. It permits every
+rational decay with `decay^128 < 1/16`, not only the source's `125/128`.
+
+The source point `(16,17,1/7,125/128)` passes. Offset `1/5` fails for every
+permitted decay. Offset `1/10` fails at the source decay but passes at `489/500`.
+Thus a failed fixed-decay test is not a proof that an offset is impossible.
+The optimized tail margin does not raise the fixed invoice's moment crossing.
+
+## Reproduce
+
+Use standard-library CPython 3.12 from the repository root:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/p104-tail-feasible-envelope
+python3.12 -I -O -B research/p104-tail-feasible-envelope/verify.py
+```
+
+The checker authenticates inputs, imports the existing directed-integer power
+engine and imports no source constructor or pricing engine. It uses exact
+rational logarithm bounds, strict derivative and root brackets, and a convex
+lower bound at the minimum. It includes 640 exact rational-power fixtures,
+80 separate Decimal power checks, 80 separate Decimal logarithm checks,
+missing-count rejections and passing/failing tail points. Decimal checks are
+corroboration; all feasibility certificates use rational bounds. `RESULT.json`
+uses outward rational rounding. No floating-point search is accepted as proof.
+
+`ORIGINS.json` binds the retained source bytes to the exact PR5756 Git blobs.
+`SOURCES.json` binds those bytes to this branch's retention commit and pins the
+power engine and its dependency. The direct replay is read-only and Git-free.
+The optional full-history provenance check needs history absent from this
+shallow checkout. Normal and sealed replay evidence is in `VALIDATION.md`.
+
+## Scope and credit
+
+Canonical [Discussion5773](https://github.com/CrocSwap/integer-mult-bounds/discussions/5773).
+Base `de5ec2e7a6074068452f45b1a191b5c72832df4a`, priority8. This changes the
+independent-moment card to a compiler parameter-existence question. The active
+R22 subspace optimizer has a distinct scope. The earlier adaptive-tail-entropy
+and adaptive-gate-existence results concern a different compiler contract.
+
+Credit Joel Pulikkan/GamingPuzzled's PR5756 construction, Ali Romman's PR5751,
+flyingviper's PR5718, and all retained P104, native and controller contributors.
+Credit Jacob Alan Sussman, zxv and Cao Yifan for the compiler gates; retain the
+existing directed-power and invoice-comparator credits. New proof and checker
+by Ali Romman with substantial OpenAI Codex assistance, without subagents.
+Apache-2.0. This is author-side verification, not independent human acceptance.
+
+The invoice's physical legality, native phases, chronology, precision, other
+compiler gates, outer transfer and five framework assumptions remain separate.
+No full source scientific replay, Lean or Docker run is claimed. The selected
+frontier is unchanged. This does not limit a different invoice or compiler.
+
+## Open next questions
+
+- Can a legal changed helper invoice retain a nonempty tail interval? Supply its
+  exact complete bill, then repeat these bounds. A legal construction is needed.
+- Can a new fully charged completion or block rule enlarge the envelope? State
+  its normalization, exit and rounding costs before optimizing its parameters.
diff --git a/research/p104-tail-feasible-envelope/RESULT.json b/research/p104-tail-feasible-envelope/RESULT.json
new file mode 100644
index 0000000000..a30006be84
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/RESULT.json
@@ -0,0 +1,60 @@
+{
+  "best_decay_infimum": {
+    "lower": "487740894096357/500000000000000",
+    "upper": "195096357638543/200000000000000"
+  },
+  "best_offset": {
+    "lower": "141270802754661/1000000000000000",
+    "upper": "141270802755571/1000000000000000"
+  },
+  "completion_at_16_17": {
+    "lower": "944337257529929/1000000000000000",
+    "upper": "94433725752993/100000000000000"
+  },
+  "controls": {
+    "decimal_logs": 80,
+    "decimal_powers": 80,
+    "exact_powers": 640,
+    "missing_count_rejections": 2
+  },
+  "cutoff15_minimizer": {
+    "lower": "22907539841617/200000000000000",
+    "upper": "28634424802249/250000000000000"
+  },
+  "cutoff15_minimum": {
+    "lower": "983563652257169/1000000000000000",
+    "upper": "98356365225717/100000000000000"
+  },
+  "cutoff17_completion_lower": {
+    "lower": "999697814388247/1000000000000000",
+    "upper": "124962226798531/125000000000000"
+  },
+  "floor18_completion_lower": {
+    "lower": "999886507972867/1000000000000000",
+    "upper": "249971626993217/250000000000000"
+  },
+  "maximum_decay": {
+    "lower": "9785720620877/10000000000000",
+    "upper": "978572062087701/1000000000000000"
+  },
+  "offset_interval_lower_root": {
+    "lower": "22543167000809/250000000000000",
+    "upper": "22543167000939/250000000000000"
+  },
+  "offset_interval_upper_root": {
+    "lower": "48327878871987/250000000000000",
+    "upper": "193311515488729/1000000000000000"
+  },
+  "offset_one_fifth_gamma": {
+    "lower": "979409001450321/1000000000000000",
+    "upper": "489704500725161/500000000000000"
+  },
+  "paid_calls": 66852,
+  "source_head": "a1b338e5d9271b541f2a198f4fc19cefc565feed",
+  "target_count": 13390,
+  "tested_saving": "622627591/200000000000",
+  "unique_integer_cutoff_floor": [
+    16,
+    17
+  ]
+}
diff --git a/research/p104-tail-feasible-envelope/SOURCES.json b/research/p104-tail-feasible-envelope/SOURCES.json
new file mode 100644
index 0000000000..0cca50536d
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/SOURCES.json
@@ -0,0 +1,44 @@
+{
+  "schema_version": 1,
+  "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8",
+      "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "scripts/compare_recursive_invoices.py",
+      "usage": "input",
+      "git_blob": "fda2a852e9937e42fe40df0707694465ca7c1b48",
+      "sha256": "3930c22c11da7bc6042cfeb6e459ecb06e4478430037bee3469d034353855fc6"
+    },
+    {
+      "path": "scripts/evaluate_recursive_power.py",
+      "usage": "input",
+      "git_blob": "ca50f8021fc3238a58fd420383f4619a8d008ace",
+      "sha256": "52b20f41fd0bb55fa88dccd6015af2ce358917817b9506720f3e60ce681cc3ad"
+    },
+    {
+      "path": "research/p104-tail-feasible-envelope/inputs/RESULT.json",
+      "usage": "input",
+      "pin": "head:4d71a44c1cba1de9cf3c164bcaabb909f4440fc9:research/p104-tail-feasible-envelope/inputs/RESULT.json",
+      "git_blob": "9d47144bd99dc57d799345c940232eb26afdc33c",
+      "sha256": "062fb71b92ca620cbea4a4469458ede513e4dc1039bfa783e06ed11f51335a9e"
+    },
+    {
+      "path": "research/p104-tail-feasible-envelope/inputs/pricing.py",
+      "usage": "input",
+      "pin": "head:4d71a44c1cba1de9cf3c164bcaabb909f4440fc9:research/p104-tail-feasible-envelope/inputs/pricing.py",
+      "git_blob": "fe40a9cb39c087c3170ee7e79140f4884c8e1873",
+      "sha256": "2a8f0d74a16c8ad3b595e2100f8c074122ecd2c1babf66a4495b20ba9e651ce8"
+    }
+  ]
+}
diff --git a/research/p104-tail-feasible-envelope/TASK.json b/research/p104-tail-feasible-envelope/TASK.json
new file mode 100644
index 0000000000..f3f276d619
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/TASK.json
@@ -0,0 +1,110 @@
+{
+  "schema_version": 1,
+  "task_id": "independent-moment",
+  "priority_revision": 8,
+  "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a",
+  "original_card": {
+    "id": "independent-moment",
+    "question": "Does a changed construction's serialized target/paid invoice independently support its claimed improvement?",
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+      "docs/research/recursive-invoice-preflight.md"
+    ],
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "first_experiment": "Independently recount one changed emitted word and its complete caller, importing no constructor or pricing engine. Include target losses, owned lifetimes, native orientation and extra charges. Check existing #5633/#5708/#5717/#5719 coverage to avoid duplicate audits and preserve its exact head. Stop after the chosen missing implication; a correct root alone is not supplier admission.",
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "overlap_terms": [
+      "invoice",
+      "signed moment",
+      "productive target",
+      "independent recount"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.",
+        "evidence": "research/staged544-mixed-fourth-entry/README.md",
+        "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.",
+        "status": "author-checked",
+        "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.",
+        "evidence": "research/staged-fourth-mixture-ceiling/README.md",
+        "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.",
+        "status": "author-checked",
+        "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.",
+        "evidence": "research/r437-two-window-carrier/README.md",
+        "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.",
+        "status": "author-checked",
+        "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "status": "reviewed",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+      }
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "All integer cutoff/floor and positive offset feasibility for the fixed PR5756 charged tail gates, with optimal decay.",
+  "scope_change_reason": "The exact compiler parameter set was missing. This resolves a parameter-existence question; it does not repeat native recount or the active R22 subspace optimizer.",
+  "bottleneck_link": "A favorable signed moment is insufficient if paid and completion tails cannot both be funded. The full feasible set directs the next helper change.",
+  "budget_minutes": 70,
+  "stop_rule": "Prove the complete fixed-contract parameter set; do not extend to changed invoices or compiler rules.",
+  "outcome": "completed",
+  "evidence": "PROOF.md and RESULT.json; registered verify.py with directed powers and derivative root bounds.",
+  "author": "Ali Romman with substantial OpenAI Codex assistance",
+  "ai_assistance": "Substantial OpenAI Codex assistance; no subagents; not independent human review.",
+  "open_questions": [
+    {
+      "question": "Can a changed helper invoice retain a nonempty tail interval?",
+      "why_it_matters": "New productive targets can increase the completion tail and remove compiler feasibility.",
+      "first_step": "Supply a source-bound complete new invoice and repeat the cutoff and convexity bounds.",
+      "blocked_by": "A legal changed native construction and full bill."
+    },
+    {
+      "question": "Can a different completion or block rule enlarge the envelope?",
+      "why_it_matters": "The result is exact only for this fixed 128-block contract.",
+      "first_step": "State a new fully charged compiler rule and prove its tail conditions.",
+      "blocked_by": "A new compiler proof, including the normalization and exit charges."
+    }
+  ],
+  "coordination": {
+    "canonical": "https://github.com/CrocSwap/integer-mult-bounds/discussions/5773",
+    "source_head": "a1b338e5d9271b541f2a198f4fc19cefc565feed",
+    "seed": "16582aeecf71f7a63a0a9bfc8454b4cc"
+  }
+}
diff --git a/research/p104-tail-feasible-envelope/VERIFY.json b/research/p104-tail-feasible-envelope/VERIFY.json
new file mode 100644
index 0000000000..59a5af1fd5
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/VERIFY.json
@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "scripts/compare_recursive_invoices.py",
+    "scripts/evaluate_recursive_power.py",
+    "research/p104-tail-feasible-envelope/inputs/RESULT.json",
+    "research/p104-tail-feasible-envelope/inputs/pricing.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Exact tail envelope, all integer cutoff/floor choices, continuum offset proof, rational and independent arithmetic controls"
+    }
+  ]
+}
diff --git a/research/p104-tail-feasible-envelope/verify.py b/research/p104-tail-feasible-envelope/verify.py
new file mode 100644
index 0000000000..ee4387c1c7
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/verify.py
@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Check the fixed PR5756 tail envelope with rational intervals.
+
+Ali Romman with OpenAI Codex assistance. Compiler credit: Jacob Alan Sussman,
+zxv and Cao Yifan. Invoice credit: Joel Pulikkan and the retained P104 chain.
+"""
+from decimal import Decimal, localcontext
+from fractions import Fraction as Q
+from functools import lru_cache
+import hashlib
+import json
+from pathlib import Path
+import sys
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+
+
+def need(test, message):
+    if not test:
+        raise ValueError(message)
+
+
+def authenticate():
+    manifest = json.loads((HERE / 'SOURCES.json').read_text())
+    for row in manifest['files']:
+        if row['usage'] == 'input':
+            need(hashlib.sha256((ROOT / row['path']).read_bytes()).hexdigest() == row['sha256'],
+                 'source hash: ' + row['path'])
+
+
+def add(a, b):
+    return a[0] + b[0], a[1] + b[1]
+
+
+def mul(a, b):
+    values = [x*y for x in a for y in b]
+    return min(values), max(values)
+
+
+def divide(a, b):
+    need(b[0] > 0, 'positive denominator')
+    return mul(a, (1/b[1], 1/b[0]))
+
+
+@lru_cache(maxsize=16384)
+def power(rank, exponent):
+    integer = exponent.numerator // exponent.denominator
+    fraction = exponent - integer
+    factor = Q(rank)**integer
+    return (factor, factor) if not fraction else mul((factor, factor), POWER(rank, fraction))
+
+
+def log_series(x):
+    need(1 <= x <= 2, 'normalized logarithm')
+    z = (x-1)/(x+1)
+    value = 2*sum(z**(2*j+1)/Q(2*j+1) for j in range(80))
+    tail = 2*z**161/(161*(1-z*z))
+    return value, value+tail
+
+
+@lru_cache(maxsize=256)
+def log_rank(rank):
+    k = rank.bit_length()-1
+    return add(mul((Q(k),)*2, log_series(Q(2))), log_series(Q(rank, 2**k)))
+
+
+def moment(histogram, exponent):
+    result = (Q(0), Q(0))
+    for rank, count in histogram.items():
+        result = add(result, mul((Q(count),)*2, power(rank, exponent)))
+    return result
+
+
+class Tails:
+    def __init__(self, source):
+        self.C = Q(source['strictification']['tested'])
+        need(0 < self.C < Q(1, 2), 'saving interval')
+        self.T = {int(r): n for r, n in source['targets'].items()}
+        self.P = {int(r): n for r, n in source['paid'].items()}
+        need(all(type(n) is int and n > 0 for h in (self.T, self.P) for n in h.values()),
+             'positive integer counts')
+        need(sum(self.T.values()) == source['productive_fields'] == 13390, 'complete target count')
+        need(sum(self.P.values()) == source['paid_calls'] == 66852, 'complete paid count')
+        need(sum(r*n for r,n in self.T.items())-sum(r*n for r,n in self.P.items()) == 760,
+             'complete rank surplus')
+        self.target = moment(self.T, 1-self.C)
+
+    def gamma(self, c, u):
+        return divide(moment(self.P, 1-self.C+u), mul(power(c, u), self.target))
+
+    def derivative(self, c, u):
+        total = (Q(0), Q(0))
+        cl = log_rank(c)
+        for r, n in self.P.items():
+            rl = log_rank(r)
+            logarithm = rl[0]-cl[1], rl[1]-cl[0]
+            total = add(total, mul(mul((Q(n),)*2, power(r, 1-self.C+u)), logarithm))
+        return divide(total, mul(power(c, u), self.target))
+
+    def delta(self, c, b):
+        n = Q(sum(self.T.values())*b)
+        return divide((n, n), mul(power(c, self.C), self.target))
+
+
+def root(function, left, right, rising, width=Q(1, 10**12)):
+    """Retain strict opposite signs at both ends."""
+    def sign(x):
+        low, high = function(x)
+        need(low > 0 or high < 0, 'unresolved root sign')
+        return low > 0
+    need(sign(left) != rising and sign(right) == rising, 'root bracket')
+    while right-left > width:
+        middle = (left+right)/2
+        if sign(middle) == rising:
+            right = middle
+        else:
+            left = middle
+    return left, right
+
+
+def minimum(tails, c):
+    left, right = root(lambda u: tails.derivative(c,u), Q(0), Q(1), True)
+    low = tails.gamma(c,left)[0] + tails.derivative(c,left)[0]*(right-left)
+    high = tails.gamma(c,(left+right)/2)[1]
+    need(low <= high, 'minimum enclosure')
+    return (left, right), (low, high)
+
+
+def display(interval):
+    scale = 10**15
+    lo = (interval[0]*scale).__floor__()
+    hi = (interval[1]*scale).__ceil__()
+    return {'lower': str(Q(lo,scale)), 'upper': str(Q(hi,scale))}
+
+
+def arithmetic_controls():
+    count = 0
+    for base in range(1, 9):
+        for denominator in range(1, 6):
+            for numerator in range(-5, 11):
+                low, high = power(base**denominator, Q(numerator,denominator))
+                need(low <= Q(base)**numerator <= high, 'exact rational power control')
+                count += 1
+    with localcontext() as context:
+        context.prec = 100
+        def dec(q):
+            return Decimal(q.numerator)/Decimal(q.denominator)
+        for r in range(1, 81):
+            low, high = power(r, Q(173,127))
+            value = (Decimal(r).ln()*dec(Q(173,127))).exp()
+            need(dec(low)-Decimal('1e-90') <= value <= dec(high)+Decimal('1e-90'),
+                 'independent Decimal power control')
+            low, high = log_rank(r)
+            need(dec(low)-Decimal('1e-90') <= Decimal(r).ln() <= dec(high)+Decimal('1e-90'),
+                 'independent Decimal logarithm control')
+    return {'exact_powers': count, 'decimal_powers': 80, 'decimal_logs': 80}
+
+
+def run():
+    authenticate()
+    global POWER
+    sys.path.insert(0, str(ROOT/'scripts'))
+    try:
+        from evaluate_recursive_power import power_bounds
+    finally:
+        sys.path.pop(0)
+    POWER = power_bounds
+    source = json.loads((HERE/'inputs/RESULT.json').read_text())['complete_cost']
+    tails = Tails(source)
+    limit = power(2, Q(-1,32))
+    m15, g15 = minimum(tails,15)
+    m16, g16 = minimum(tails,16)
+    need(g15[0] > limit[1], 'all offsets at cutoff15 fail')
+    need(tails.delta(17,18)[0] > limit[1], 'all cutoffs at least17 fail')
+    need(tails.delta(16,18)[0] > limit[1], 'all floors at least18 fail at cutoff16')
+    need(tails.delta(16,17)[1] < g16[0] < g16[1] < limit[0], 'cutoff16 floor17 optimum')
+    need(16**64 < 17**63, 'completion ordering capacity')
+    def difference(u):
+        gamma = tails.gamma(16,u)
+        return gamma[0]-limit[1], gamma[1]-limit[0]
+    lower = root(difference,Q(0),Q(1,7),False)
+    upper = root(difference,Q(1,7),Q(1),True)
+    decay = Q(125,128)
+    need(tails.gamma(16,Q(1,7))[1] < decay and tails.delta(16,17)[1] < decay
+         and decay**128 < Q(1,16), 'source passing point')
+    need(tails.gamma(16,Q(1,5))[0] > decay, 'source offset failure')
+    alpha = divide(moment(tails.P,1-tails.C),tails.target)
+    need(alpha[1] < 1-Q(1,10**12), 'source reserve')
+    need(tails.gamma(16,Q(1,5))[0] > limit[1], 'old offset fails for every permitted decay')
+    alternate = Q(489,500)
+    need(tails.gamma(16,Q(1,10))[0] > decay and tails.gamma(16,Q(1,10))[1] < alternate
+         and tails.delta(16,17)[1] < alternate and alternate**128 < Q(1,16),
+         'changed decay admits an offset rejected by the source decay')
+    failures = 0
+    for label, rank in (('targets','9'), ('paid','1')):
+        bad = json.loads(json.dumps(source)); bad[label][rank] -= 1
+        try:
+            Tails(bad)
+        except ValueError:
+            failures += 1
+        else:
+            raise ValueError('missing count accepted')
+    result = {'source_head':'a1b338e5d9271b541f2a198f4fc19cefc565feed',
+              'tested_saving':str(tails.C),'paid_calls':66852,'target_count':13390,
+              'unique_integer_cutoff_floor':[16,17], 'maximum_decay': display(limit),
+              'cutoff15_minimum':display(g15), 'cutoff15_minimizer':display(m15),
+              'cutoff17_completion_lower':display(tails.delta(17,18)),
+              'floor18_completion_lower':display(tails.delta(16,18)),
+              'offset_interval_lower_root':display(lower),'offset_interval_upper_root':display(upper),
+              'best_offset':display(m16),'best_decay_infimum':display(g16),
+              'completion_at_16_17':display(tails.delta(16,17)),
+              'offset_one_fifth_gamma':display(tails.gamma(16,Q(1,5))),
+              'controls':dict(arithmetic_controls(), missing_count_rejections=failures)}
+    return result
+
+
+if __name__ == '__main__':
+    result = run()
+    if '--emit' not in sys.argv:
+        need(result == json.loads((HERE/'RESULT.json').read_text()), 'result receipt')
+    print(json.dumps(result,indent=2,sort_keys=True))
+    if '--emit' not in sys.argv:
+        print('PASS_P104_TAIL_FEASIBLE_ENVELOPE')

From 56dc0a9ec02020f5e035c7d83f078fb2b27ac76a Mon Sep 17 00:00:00 2001
From: Ali Romman <226877337+aliromman@users.noreply.github.com>
Date: Mon, 26 Oct 2026 13:04:02 -0500
Subject: [PATCH 3/3] Record sealed tail-envelope replay evidence

---
 .../PORTABILITY.json                            |  7 +++++++
 .../p104-tail-feasible-envelope/VALIDATION.md   | 17 +++++++++++++++++
 2 files changed, 24 insertions(+)
 create mode 100644 research/p104-tail-feasible-envelope/PORTABILITY.json
 create mode 100644 research/p104-tail-feasible-envelope/VALIDATION.md

diff --git a/research/p104-tail-feasible-envelope/PORTABILITY.json b/research/p104-tail-feasible-envelope/PORTABILITY.json
new file mode 100644
index 0000000000..b853ca3ea5
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/PORTABILITY.json
@@ -0,0 +1,7 @@
+{
+  "readonly_files_unchanged": 13,
+  "optimized_git_free": true,
+  "empty_path": true,
+  "source_corruption_rejected": true,
+  "python": "Python 3.12.14"
+}
diff --git a/research/p104-tail-feasible-envelope/VALIDATION.md b/research/p104-tail-feasible-envelope/VALIDATION.md
new file mode 100644
index 0000000000..2c526f8422
--- /dev/null
+++ b/research/p104-tail-feasible-envelope/VALIDATION.md
@@ -0,0 +1,17 @@
+# Validation
+
+Scientific commit `a5cc123d86a17e47eba7a58e2cd6b50ccc536162` passed the registered
+CPython3.12.14 replay. Its official12-file export passed a second run with
+`-I -O -B`, no Git, empty PATH and read-only files. All13 exported files,
+including the export manifest, retained their bytes and modes. A damaged live
+source failed authentication. PORTABILITY.json records these checks.
+
+Only this validation note and its portability receipt were added after that
+scientific commit. All scientific bytes are unchanged. Canonical main and
+priority8 were refreshed before submission. Hosted CI and independent human
+review were pending at publication. Full-history provenance is unavailable in
+this shallow checkout; source Git blobs and retained bytes were checked.
+
+These checks cover the stated tail proof and arithmetic. The complete native,
+physical, compiler and outer supplier replay was not run. No Lean or Docker
+run or new kappa is claimed.