Research-Stack/4-Infrastructure/shim/fractal_go_t16_pist_bridge.py

#!/usr/bin/env python3
"""Compile the fractal-Go-on-T16 idea into the existing PIST bundle prior.

The tiddler already selected ``pist_nd_bundle`` over Go tiles as the native
topology witness primitive.  This receipt keeps that decision: fractal Go is
useful as a rule-language prior, but the serializable route primitive remains
a sparse PIST bundle packet with exact residual repair.
"""

from __future__ import annotations

import hashlib
import json
import zipfile
from pathlib import Path
from typing import Any


REPO = Path(__file__).resolve().parents[2]
SHIM = REPO / "4-Infrastructure" / "shim"
TIDDLER = (
    REPO
    / "6-Documentation"
    / "tiddlywiki-local"
    / "wiki"
    / "tiddlers"
    / "Decision Diagram Compression Tuning Prior.tid"
)
OUT = SHIM / "fractal_go_t16_pist_bridge_receipt.json"
CURRICULUM_OUT = SHIM / "fractal_go_t16_pist_bridge_curriculum.jsonl"
ARCHIVE = Path("/home/allaun/Documents/ingest/ChatGPT-Batch-2026-05-08.zip")
REFINEMENT_MEMBER = "ChatGPT-16D_Torus_with_Go_Tiles.json"
GENERATED_SECTION = "!! Fractal Go T16 PIST Bridge"

GENERATED_AT = "2026-05-08T00:00:00+00:00"


def stable_json(obj: Any) -> str:
    return json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=True)


def sha256_bytes(data: bytes) -> str:
    return hashlib.sha256(data).hexdigest()


def rel(path: Path) -> str:
    return str(path.relative_to(REPO))


def tiddler_source_surface() -> str:
    """Read the source tiddler without this generated bridge section."""
    text = TIDDLER.read_text(encoding="utf-8")
    kept: list[str] = []
    skipping = False
    for line in text.splitlines():
        if line.strip() == GENERATED_SECTION:
            skipping = True
            continue
        if skipping and line.startswith("!! "):
            skipping = False
        if not skipping:
            kept.append(line)
    return "\n".join(kept) + "\n"


def source_evidence() -> dict[str, Any]:
    text = tiddler_source_surface()
    markers = [
        "16D torus should use nD PIST rather than Go tiles",
        "pist_nd_bundle",
        "Do not simulate a full 16D torus board",
        "Store sparse active PIST bundle packets",
        "T16 = (S1)^16",
        "Percolating the 16D Hypercube",
    ]
    hits = []
    for lineno, line in enumerate(text.splitlines(), start=1):
        for marker in markers:
            if marker in line:
                hits.append({"line": lineno, "marker": marker, "text": line.strip()})
    return {
        "source_tiddler": rel(TIDDLER),
        "source_sha256": sha256_bytes(text.encode("utf-8")),
        "generated_section_excluded": GENERATED_SECTION,
        "markers": markers,
        "hits": hits,
    }


def archive_evidence() -> dict[str, Any]:
    archive_bytes = ARCHIVE.read_bytes()
    with zipfile.ZipFile(ARCHIVE) as zf:
        names = zf.namelist()
        raw = zf.read(REFINEMENT_MEMBER)
    chat = json.loads(raw.decode("utf-8"))
    body = "\n\n".join(str(message.get("content", "")) for message in chat.get("messages", []))
    markers = [
        "16D torus",
        "fractal Go",
        "goxel",
        "liberties",
        "capture",
        "ko",
        "territory",
        "AMMR",
        "O-AMMR",
        "G16 = (T16, Sigma, N, F, R, Pi)",
        "|Omega| = b^(m^16)",
        "Do not simulate the full torus",
    ]
    marker_hits = [marker for marker in markers if marker.lower() in body.lower()]
    return {
        "archive_path": str(ARCHIVE),
        "archive_sha256": sha256_bytes(archive_bytes),
        "member_count": len(names),
        "member_names": names,
        "refinement_member": REFINEMENT_MEMBER,
        "refinement_sha256": sha256_bytes(raw),
        "title": chat.get("title"),
        "timestamp": chat.get("timestamp"),
        "url": chat.get("url"),
        "message_count": len(chat.get("messages", [])),
        "marker_hits": marker_hits,
        "extracted_model": {
            "compact_space": "T16 = (S1)^16",
            "rule_language": "fractal_go_goxel_automaton",
            "native_packet": "sparse_pist_bundle_packet",
            "explosion_guard": "materialize active goxel packets only",
            "claim_boundary": "proposal/pruning prior until exact residual decode/hash/byte count closes",
        },
    }


SELF_FOLDED_CANDIDATES = [
    {
        "id": "sixteen_orthoplex",
        "role": "axis_pinched_basis",
        "useful_as": "sharp sparse axis carrier / signed basis proposal",
        "not_useful_as": "full route payload or proof of byte compression",
        "verdict": "proposal_feature",
    },
    {
        "id": "barnes_wall_lambda_16",
        "role": "dense_owner_lattice",
        "useful_as": "future deterministic owner quantizer or packing diagnostic in 16D",
        "not_useful_as": "serializable lattice payload without measured overhead",
        "verdict": "diagnostic_until_receipted",
    },
    {
        "id": "calabi_yau_8_complex",
        "role": "continuous_topological_fold_metaphor",
        "useful_as": "language for compactification / cycle bookkeeping",
        "not_useful_as": "finite compression primitive in this stack",
        "verdict": "background_only",
    },
    {
        "id": "sixteen_cube",
        "role": "active_frontier_reference",
        "useful_as": "65536-state activation/card prior and hypercube reachability check",
        "not_useful_as": "full materialized 16D board",
        "verdict": "frontier_model_only",
    },
]

GO_TO_PIST_COMPILATION = [
    {
        "go_term": "placement",
        "compiled_role": "open_sparse_bundle_packet",
        "receipt_field": "active_bundle_id",
    },
    {
        "go_term": "liberties",
        "compiled_role": "admissible_continuation_count",
        "receipt_field": "liberty_count",
    },
    {
        "go_term": "capture",
        "compiled_role": "residual_or_void_collapse",
        "receipt_field": "capture_receipt_id",
    },
    {
        "go_term": "territory",
        "compiled_role": "deterministic_owner_region",
        "receipt_field": "owner_route_id",
    },
    {
        "go_term": "ko",
        "compiled_role": "no_repeat_invalid_trace",
        "receipt_field": "ko_trace_hash",
    },
    {
        "go_term": "fractal_scale",
        "compiled_role": "pist_shell_base_and_offset",
        "receipt_field": "shell_k_offset_t",
    },
]

EQUATIONS = [
    {
        "id": "FG0_torus_phase_space",
        "equation": "T16 = (S1)^16; theta_i == theta_i + 2*pi",
        "meaning": "Use compact cyclic phase space so boundary failure becomes recurrence or capture, not infinity.",
    },
    {
        "id": "FG1_tile_state",
        "equation": "sigma_i = (occupancy, chi, kappa, rho, lambda_mode, epsilon_budget, q, scale)",
        "meaning": "Treat a Go tile as a bounded diagnostic state packet, not as payload.",
    },
    {
        "id": "FG2_sparse_automaton",
        "equation": "G16 = (T16, Sigma, N, F, R, Pi)",
        "meaning": "Fractal Go is a compact recursive admissibility automaton over toroidal phase space.",
    },
    {
        "id": "FG3_liberties",
        "equation": "L(G_i) = {n in N(i) | A(n) == admissible}",
        "meaning": "Liberties measure admissible continuation rather than board-game freedom.",
    },
    {
        "id": "FG4_capture",
        "equation": "|L(G_i)| == 0 -> residual_lane or void_receipt or archive_packet or shadow_projection",
        "meaning": "Capture is topological cleanup: collapse unstable state into a bounded receipt path.",
    },
    {
        "id": "FG5_multiscale_update",
        "equation": "sigma_i^k(t+1) = F(N_i^k, P_down(sigma^(k+1)), P_up(sigma^(k-1)), Phi)",
        "meaning": "Fine tiles supply detail; coarse tiles enforce law; projections must be receipted.",
    },
    {
        "id": "FG6_state_explosion_guard",
        "equation": "|Omega| = b^(m^16); materialize(active_packets) only",
        "meaning": "Never store or search the full 16D board.",
    },
    {
        "id": "FG7_pist_compilation",
        "equation": "GoTile_i^k -> PistBundlePacket(shell_k, offset_t, fiber_vector_hash, phase, residual_budget, receipt_hash)",
        "meaning": "The native implementation target is sparse PIST bundle packets.",
    },
]


def build_receipt() -> dict[str, Any]:
    receipt: dict[str, Any] = {
        "schema": "fractal_go_t16_pist_bridge_v1",
        "generated_at": GENERATED_AT,
        "archive_evidence": archive_evidence(),
        "source_evidence": source_evidence(),
        "primary_decision": {
            "name": "compile_fractal_go_to_sparse_pist_bundle",
            "statement": (
                "Use fractal Go as a rule-language prior for liberties, capture, "
                "territory, ko, and multiscale admissibility; keep PIST bundle "
                "packets as the serializable route primitive."
            ),
            "native_primitive": "pist_nd_bundle",
            "rejected_native_primitive": "full_fractal_go_t16_board",
        },
        "self_folded_shape_verdicts": SELF_FOLDED_CANDIDATES,
        "go_to_pist_compilation": GO_TO_PIST_COMPILATION,
        "equations": EQUATIONS,
        "candidate_dd_state_extension": [
            "t16_phase_key",
            "goxel_packet_id",
            "tile_occupancy_class",
            "chirality_class",
            "curvature_class",
            "density_mass_class",
            "spectral_mode_class",
            "liberty_count",
            "capture_receipt_id",
            "ko_trace_hash",
            "fractal_scale_k",
            "pist_shell_k",
            "pist_offset_t",
            "fiber_vector_hash",
            "owner_route_id",
            "residual_lane_id",
            "byte_rehydration_hash",
        ],
        "candidate_dd_edges": [
            "open_sparse_goxel_packet",
            "compute_toroidal_neighbor_liberties",
            "capture_zero_liberty_region",
            "route_territory_to_owner",
            "reject_ko_trace_repeat",
            "project_fractal_scale_to_pist_bundle",
            "emit_exact_residual_lane",
            "close_with_rehydration_hash",
        ],
        "promotion_rule": [
            "fractal_go_layer_only_proposes_or_prunes_routes",
            "full_t16_board_is_never_materialized",
            "zero_liberty_capture_emits_bounded_receipt",
            "ko_trace_hash_prevents_recursive_invalid_loops",
            "pist_bundle_packet_fits_witness_budget",
            "exact_residual_lane_restores_source_bytes",
            "decoded_hash_matches_source",
            "measured_total_bytes_beats_incumbent",
        ],
        "failure_rule": [
            "full_board_materialization -> NaN0",
            "capture_without_residual_or_void_receipt -> fail_closed",
            "ko_repeat_without_trace_hash -> NaN0",
            "continuous_shape_claim_without_finite_packet -> diagnostic_only",
            "witness_bytes_exceed_remaining_margin -> prune",
        ],
        "claim_boundary": (
            "This receipt compiles a conceptual fractal-Go/T16 state machine into "
            "the existing sparse PIST bundle discipline. It is not a compression "
            "result and does not promote a route without exact decode/hash/byte "
            "measurement."
        ),
    }
    preimage = {key: value for key, value in receipt.items() if key != "receipt_hash"}
    receipt["receipt_hash"] = sha256_bytes(stable_json(preimage).encode("utf-8"))
    return receipt


def curriculum_lines(receipt: dict[str, Any]) -> list[dict[str, Any]]:
    lines: list[dict[str, Any]] = []
    for item in receipt["self_folded_shape_verdicts"]:
        lines.append({"type": "shape_verdict", **item})
    for item in receipt["go_to_pist_compilation"]:
        lines.append({"type": "compilation_rule", **item})
    for item in receipt["equations"]:
        lines.append({"type": "equation", **item})
    return lines


def main() -> None:
    receipt = build_receipt()
    OUT.write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n", encoding="utf-8")
    lines = curriculum_lines(receipt)
    CURRICULUM_OUT.write_text(
        "".join(json.dumps(line, sort_keys=True) + "\n" for line in lines),
        encoding="utf-8",
    )
    print(json.dumps({
        "receipt": rel(OUT),
        "curriculum": rel(CURRICULUM_OUT),
        "receipt_hash": receipt["receipt_hash"],
        "curriculum_records": len(lines),
        "decision": receipt["primary_decision"]["name"],
    }, indent=2, sort_keys=True))


if __name__ == "__main__":
    main()