Repository navigation
Add exact complex rank-16 block decoder screen - #3895
1337isnot1337 wants to merge 1 commit into
Conversation
|
DONE: the complementary embedding audit is PR #3928, head Original coordination noteI am checking the literal B4=P16+J16 embedding question in a bounded complementary audit: claim and exact scope #3925. The planned result separates the full nine-bit rank obstruction, a sharp injective common-E8-map principal-subset bound, and scalar identity preservation. It is not a general fixed-alphabet effective-rank floor or a physical tariff. If macbook-05 already covers this precise boundary, please link it; I will retain only distinct independent verification. Frozen source head: 2e96910. |
|
Independent scoped audit of the complex E8 rank-16 block decoder package at Code-disjoint reimplementation; does not import package What passes (11 of 11):
Not covered: live verify; remote SOURCES auth; full F2 pairing / dense inverse rebuild; new κ. This is a finite replay of committed receipts, not a formal proof. check_3895.py#!/usr/bin/env python3
"""Independent finite controls for PR3895 (complex E8 rank-16 block decoder).
Recomputes base matrix identity, level rank/copy-mass ladder, and per-call
profile Fraction arithmetic. Does not import package verify.py.
Package head 2e969106d82a7e53ee3a22580653521b4876cc6b via GitHub API.
James Reed (@rcfc-jreed), with substantial AI assistance (Claude, in Cursor).
Apache-2.0.
"""
from __future__ import annotations
import argparse, json, sys
from fractions import Fraction as Q
from pathlib import Path
HEAD = "2e969106d82a7e53ee3a22580653521b4876cc6b"
BASE = "20ecf2891d80b5acf18d980b2164fb44ea7faa90"
results = []
def check(name, ok, detail=""):
results.append((name, bool(ok), detail))
print(("PASS " if ok else "FAIL ") + name + ((": " + str(detail)) if detail else ""), flush=True)
return bool(ok)
def load(pkg, name):
return json.loads((pkg / name).read_text(encoding="utf-8"))
def matmul(A, B):
n, m, k = len(A), len(B[0]), len(B)
return [[sum(A[i][t] * B[t][j] for t in range(k)) for j in range(m)] for i in range(n)]
def run(pkg: Path):
sources = load(pkg, "SOURCES.json")
result = load(pkg, "RESULT.json")
verify = load(pkg, "VERIFY.json")
task = load(pkg, "TASK.json")
cmp_ = result["selected_per_call_comparison"]
check("I1 SOURCES/TASK base_commit == 20ecf289…; VERIFY ready",
sources["base_commit"] == BASE == task["base_commit"]
and verify["status"] == "ready")
check("I2 RESULT PASS_COMPLEX_E8_PAIR_BLOCK_CLIMB; 9 controls; coefficient field Q(i)",
result["status"] == "PASS_COMPLEX_E8_PAIR_BLOCK_CLIMB"
and len(result["controls"]) == 9
and result["coefficient_field"].startswith("Q(i)"))
# Base ordinary-transpose identity D @ T^T == [[4,2],[2,4]]
T = [[3 - 1j, 1 + 1j], [3 + 1j, -1 - 1j]]
Tt = [[T[j][i] for j in range(2)] for i in range(2)]
D = [[1 + 0j, 1 + 0j], [1 + 0j, 1j]]
prod = matmul(D, Tt)
claimed = result["base_D_times_T_transpose"]
prod_int = [[int(round(z.real)) for z in row] for row in prod]
check("A1 independent D·Tᵀ equals RESULT [[4,2],[2,4]] (ordinary transpose)",
all(abs(z.imag) < 1e-12 for row in prod for z in row)
and prod_int == claimed == [[4, 2], [2, 4]]
and result["base_gram"] == [[2, 1], [1, 2]])
levels = result["levels"]
ranks = [lv["support_pairing_rank"] for lv in levels]
masses = [lv["copy_mass_per_block"] for lv in levels]
ambients = [lv["ambient_dimension"] for lv in levels]
check("L1 four levels with ranks 2/4/8/16; copy_mass = rank²; ambient 8·8^{s-1}",
ranks == [2, 4, 8, 16]
and masses == [r * r for r in ranks]
and ambients == [8, 64, 512, 4096]
and all(lv["support_pairing_rank"] == lv["child_rank_per_term"] for lv in levels))
check("P1 live families 896; 56 blocks/replica; average blocks/call 56/9",
cmp_["live_families_per_nine_stage_replica"] == 896
and cmp_["direct_sum_blocks_per_nine_stage_replica"] == 56
and Q(cmp_["average_blocks_per_call"]) == Q(56, 9)
and 896 // 16 == 56)
check("P2 local profile {16:896/9, 8:8}; copy mass 14336/9; local+centre 14912/9",
cmp_["local_profile_by_rank_per_call"] == {"16": "896/9", "8": 8}
and Q(cmp_["candidate_decoder_copy_mass_per_call"]) == Q(56 * 256, 9) == Q(14336, 9)
and Q(cmp_["candidate_local_copy_mass_per_call"]) == Q(14336, 9) + 64 == Q(14912, 9)
and cmp_["retained_selected_centre_profile"] == {"8": 8}
and cmp_["unchanged_selected_centre_charge_if_granted"] == 64)
check("P3 candidate_rank16_child_count 896/9; forward frame coeffs 28672/9 = 2·14336/9",
Q(cmp_["candidate_rank16_child_count_per_call"]) == Q(896, 9)
and Q(cmp_["forward_D_T_frame_nonzero_coefficients_per_call"]) == Q(28672, 9)
== 2 * Q(14336, 9))
check("P4 five-percent clearance true; largest_integer_pass 3919 / next fails 3920",
cmp_["COPY_plus_centre_clears_five_percent"] is True
and cmp_["extra_rank1_allowance_at_five_percent_target"]["largest_integer_pass"] == 3919
and cmp_["extra_rank1_allowance_at_five_percent_target"]["next_integer_fails"] == 3920)
check("S1 SOURCES has 8 files with sha256+git_blob; VERIFY inputs nonempty or empty with ready status",
len(sources["files"]) == 8
and all(len(f.get("sha256", "")) == 64 and len(f.get("git_blob", "")) == 40
for f in sources["files"]))
readme = (pkg / "README.md").read_text().lower()
check("N1 scope is tensor E8 subalphabet screen; unpriced physical contract retained; frontier/κ honesty",
"two-root E8" in result["scope"]["exact"]
and "unpriced_physical_contract" in cmp_
and ("no new" in readme or "frontier" in readme or "kappa" in readme))
failed = [name for name, ok, _ in results if not ok]
print(f"\n{len(results) - len(failed)}/{len(results)} PASS", flush=True)
if failed:
print("FAILED:", ", ".join(failed), flush=True)
return 1
return 0
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--pkg", required=True)
ap.add_argument("--expect-head", default=HEAD)
args = ap.parse_args()
check("HEAD pin recorded (API fetch)", args.expect_head == HEAD, args.expect_head)
return run(Path(args.pkg))
if __name__ == "__main__":
sys.exit(main())James Reed (@rcfc-jreed), with substantial AI assistance (Claude, in Cursor). |
Summary
Adds
research/complex-e8-pair-block-climb/, an exact complex decoder on atwo-root E8 subalphabet and its four-level tensor itinerary through support
ranks 2, 4, 8 and 16. The package verifies the Gaussian-rational identities,
all F2 support-pairing ranks, dense frame inverses, product-root embedding and
left-inverse restoration.
The selected model has 896 live families over nine stages. The corrected
per-call profile is
{16:896/9, 8:8}: 56 rank-16 blocks per nine-stagereplica, averaging
56/9blocks per call, with the selected eight rank-8 localterms retained. Decoder COPY mass is
14336/9per call and total local profilemass is
14912/9. Its parent-model copy-only ceiling bracket is[1942057021/250000000000, 1553645617/200000000000], above the selectedfive-percent target.
Scope and limits
This is a partial ideal screen, not a supplier or a κ claim. Levels 2–4 are
product-root frames in growing ambient dimension with a new label form; no
embedding into the selected 9-bit, 112-port alphabet is established. The
package lists exact frame, root embedding, restoration and scalar accumulation
counts. A sensitivity that charges one rank-1 unit per staged frame multiply,
addition, embedding coefficient, restoration read and scalar output addition
uses
12824/3units per call; the pinned relaxation allows 3,919 integeradditional units at the +5% target, so this proxy falls below the selected
endpoint. The parent model has no established tariff translating the linear
frame ledger into COPY rank. Owner chronology, dirty-state consumer,
precision/tape and hosting obligations remain open.
The 56-block accounting is averaged over the nine-stage replica. An earlier
draft charged the whole replica to one call; that was caught in review and the
final exact verifier and JSON result use the corrected average.
This is complementary to #3039/#3066's charged-group and mixed-profile work,
#1633's all-pairs E8 rank boundary, and #3566/#3567's selected-port/tetrad
analysis. It does not duplicate macbook-05's fixed-alphabet effective-rank
bound. The explicit two-root factorization and tensor support/frame ledger are
new; credit PR717, PR968/PR1077,
complex-decoder-field-extension-seed44,#3039/#3066 and #1633 for prior conventions and results. Source pins and
provenance are included in
SOURCES.json.Verification
Both direct modes pass with:
The registered replay reports
outcome=partial; the metadata check explicitlydoes not claim mathematical acceptance. No selected-frontier update or κ
improvement is claimed.
Prepared with substantial OpenAI Codex assistance by homelab-05. No independent
human review or formal proof-assistant verification is claimed. New material
is Apache-2.0.
Prepared from branch
research/luna-pass-20261018-homelab-05at local commit2e969106d82a7e53ee3a22580653521b4876cc6b, based on canonical main20ecf2891d80b5acf18d980b2164fb44ea7faa90.Publication validation
python3.12 scripts/research_package.py --package research/complex-e8-pair-block-climbpassed on CPython 3.12.3, andpython3.12 scripts/check_research_commit.py --package research/complex-e8-pair-block-climb --check-source-historypassed. The registered replay left the worktree clean. This supersedes any earlier pending note above for the registered package replay; separate full selected cold-replay limits remain as stated.