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

#!/usr/bin/env python3
"""Bridge math logograms into Rainbow Raccoon Compiler projections.

This consumes the existing math logogram surface receipt and runs each compiled
sample through the RRC manifold/type-witness boundary as a LogogramProjection.
The bridge is deliberately receipt-only: it does not prove the mathematics in a
logogram.  It verifies that the projection surface is declared, bounded, and
auditable enough to be a candidate object for later Lean/proof work.
"""

from __future__ import annotations

import hashlib
import importlib.util
import json
import sys
from pathlib import Path
from typing import Any


REPO = Path(__file__).resolve().parents[2]
SHIM = REPO / "4-Infrastructure" / "shim"
LOGOGRAM_RECEIPT = SHIM / "math_logogram_surface_receipt.json"
RRC_RECEIPT = SHIM / "rainbow_raccoon_compiler_receipt.json"
OUT = SHIM / "rrc_logogram_projection_bridge_receipt.json"
CURRICULUM = SHIM / "rrc_logogram_projection_bridge_curriculum.jsonl"


def load_rrc_module() -> Any:
    path = SHIM / "rainbow_raccoon_compiler.py"
    spec = importlib.util.spec_from_file_location("rainbow_raccoon_compiler", path)
    if spec is None or spec.loader is None:
        raise RuntimeError(f"cannot load RRC module from {path}")
    module = importlib.util.module_from_spec(spec)
    sys.modules[spec.name] = module
    spec.loader.exec_module(module)
    return module


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


def sha256_text(text: str) -> str:
    return hashlib.sha256(text.encode("utf-8")).hexdigest()


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


def file_digest(path: Path) -> dict[str, Any]:
    data = path.read_bytes()
    return {
        "path": str(path.relative_to(REPO)),
        "bytes": len(data),
        "sha256": sha256_bytes(data),
    }


def load_json(path: Path) -> dict[str, Any]:
    return json.loads(path.read_text(encoding="utf-8"))


def sample_projection_payload(sample: dict[str, Any]) -> dict[str, Any]:
    return {
        "id": sample["id"],
        "kind": sample["kind"],
        "source_hash": sample["source_hash"],
        "canonical_hash": sample["canonical_hash"],
        "cell_hash": sample["cell_hash"],
        "token_count": sample["token_count"],
        "token_kind_counts": sample["token_kind_counts"],
        "surface_payload_hex": sample["surface_payload_hex"],
        "surface_payload_len": sample["surface_payload_len"],
        "substitution_receipt": sample["substitution_receipt"],
        "compression_metrics": sample["compression_metrics"],
        "semantic_regime": sample["semantic_regime"],
        "projection": {
            "source_space": "latex_or_symbolic_logogram",
            "canonical_space": "deterministic_surface1_cells",
            "payload_space": "bounded_glyph_payload_16_bytes",
            "receipt_space": "substitution_receipt_plus_rrc_witness",
        },
        "decoder_declared": "canonical cells + glyph payload + source residual boundary",
        "scale_band_declared": "surface_payload_len <= 16 bytes; token_count finite; no math proof claim",
    }


def tear_repair_witness(sample: dict[str, Any]) -> dict[str, Any] | None:
    """Create a repair lane for semantic tearing without merging the torn mass."""
    if sample.get("semantic_regime") != "horrible_manifold_tearing":
        return None
    source = str(sample.get("source", ""))
    canonical = str(sample.get("canonical", ""))
    boundary = {
        "regime": sample["semantic_regime"],
        "source_hash": sample["source_hash"],
        "canonical_hash": sample["canonical_hash"],
        "cell_hash": sample["cell_hash"],
        "trigger_terms": [
            term
            for term in ["torsion", "contradiction", "tear", ">", "max"]
            if term in source or term in canonical
        ],
    }
    detached_mass_id = "detached_mass:" + sha256_text(stable_json(boundary))[:16]
    witness = {
        "schema": "rrc.logogram_tear_repair.v1",
        "repair_status": "isolated_not_merged",
        "repair_rule": "quarantine torn binding; preserve boundary and residual; refuse tokenbook merge",
        "contradiction_witness_hash": sha256_text(stable_json(boundary)),
        "tear_boundary_hash": sha256_text(sample["cell_hash"] + ":" + sample["semantic_regime"]),
        "detached_mass_id": detached_mass_id,
        "origin_block": {
            "sample_id": sample["id"],
            "source_hash": sample["source_hash"],
            "canonical_hash": sample["canonical_hash"],
        },
        "residual_lane": {
            "kind": "semantic_boundary_residual",
            "payload_hex": sample["surface_payload_hex"],
            "payload_len": sample["surface_payload_len"],
            "merge_admissible": False,
            "projection_lane": "quarantine_projection",
        },
    }
    witness["repair_receipt_hash"] = sha256_text(stable_json(witness))
    return witness


def compile_sample(rrc: Any, sample: dict[str, Any]) -> dict[str, Any]:
    payload = sample_projection_payload(sample)
    obj = rrc.RRCObject(
        object_id=f"rrc_logogram_{sample['id']}",
        label=f"Logogram projection: {sample['id']}",
        kind="logogram_projection",
        payload=json.dumps(payload, sort_keys=True, ensure_ascii=True),
        source_path="4-Infrastructure/shim/math_logogram_surface_receipt.json",
    )
    compiled = rrc.compile_object(obj)
    repair = tear_repair_witness(sample)
    payload_bound_ok = sample["surface_payload_len"] <= 16
    type_ok = compiled["type_witness"]["status"] == "CANDIDATE"
    merge_safe = sample["semantic_regime"] != "horrible_manifold_tearing"
    repaired_tear = repair is not None
    compiled["logogram_projection"] = {
        "sample_id": sample["id"],
        "semantic_regime": sample["semantic_regime"],
        "canonical_hash": sample["canonical_hash"],
        "cell_hash": sample["cell_hash"],
        "payload_hex": sample["surface_payload_hex"],
        "payload_len": sample["surface_payload_len"],
        "hash16": sample["substitution_receipt"]["hash16"],
        "projection_admissible": type_ok and payload_bound_ok and (merge_safe or repaired_tear),
        "merge_admissible": type_ok and payload_bound_ok and merge_safe,
        "projection_lane": "normal_projection" if merge_safe else "quarantine_projection",
        "tear_repair_witness": repair,
        "hold_reason": None,
    }
    if not compiled["logogram_projection"]["projection_admissible"]:
        reasons = []
        if compiled["type_witness"]["status"] != "CANDIDATE":
            reasons.extend(compiled["type_witness"]["missing_or_weak_axes"])
        if sample["surface_payload_len"] > 16:
            reasons.append("payload_exceeds_16_byte_surface")
        if sample["semantic_regime"] == "horrible_manifold_tearing" and repair is None:
            reasons.append("semantic_regime_horrible_manifold_tearing_without_repair_witness")
        compiled["logogram_projection"]["hold_reason"] = reasons
    compiled["invariant_receipt"]["receipt_hash"] = sha256_text(stable_json(compiled))
    return compiled


def build_receipt() -> dict[str, Any]:
    rrc = load_rrc_module()
    logogram = load_json(LOGOGRAM_RECEIPT)
    base_rrc = load_json(RRC_RECEIPT) if RRC_RECEIPT.exists() else {}
    compiled = [compile_sample(rrc, sample) for sample in logogram.get("samples", [])]
    receipt = {
        "schema": "rrc_logogram_projection_bridge_v1",
        "claim_state": "projection_bridge_not_math_proof",
        "source_artifacts": [
            file_digest(LOGOGRAM_RECEIPT),
            file_digest(SHIM / "math_logogram_surface_builder.py"),
            file_digest(SHIM / "rainbow_raccoon_compiler.py"),
        ]
        + ([file_digest(RRC_RECEIPT)] if RRC_RECEIPT.exists() else []),
        "upstream_rrc_receipt_hash": base_rrc.get("receipt_hash"),
        "primary_read": (
            "Logograms become RRC projection objects by binding canonical cell hashes, "
            "bounded glyph payloads, substitution receipts, and semantic regimes to a "
            "LogogramProjection type witness."
        ),
        "projection_equation": (
            "P_logogram(source) = (canonical_hash, cell_hash, glyph_payload_16, "
            "semantic_regime, substitution_receipt, rrc_type_witness)"
        ),
        "compiled_logograms": compiled,
        "counts": {
            "sample_count": len(compiled),
            "candidate_count": sum(1 for item in compiled if item["type_witness"]["status"] == "CANDIDATE"),
            "hold_count": sum(1 for item in compiled if item["type_witness"]["status"] == "HOLD"),
            "projection_admissible_count": sum(
                1 for item in compiled if item["logogram_projection"]["projection_admissible"]
            ),
            "merge_admissible_count": sum(
                1 for item in compiled if item["logogram_projection"]["merge_admissible"]
            ),
            "repaired_tear_count": sum(
                1
                for item in compiled
                if item["logogram_projection"].get("tear_repair_witness") is not None
            ),
        },
        "failure_rules": [
            "A logogram projection is not a proof of the source equation.",
            "A payload over 16 bytes is HOLD for this Surface-1 bridge.",
            "A horrible_manifold_tearing regime may enter quarantine projection only with a residual/contradiction witness.",
            "A repaired tear is never merge-admissible without a separate proof receipt.",
            "A missing RRC witness or weak projection axis is HOLD.",
        ],
        "next_steps": [
            "Add a declared residual lane for logograms that need more than 16 payload bytes.",
            "Map admissible logograms into the E1/E2 route classifier as symbolic-feature tokens.",
            "Create a Lean RRCShape.LogogramProjection witness gate.",
            "Use semantic regime HOLDs to prevent unsafe tokenbook merges.",
        ],
    }
    receipt["receipt_hash"] = sha256_text(stable_json(receipt))
    return receipt


def write_curriculum(receipt: dict[str, Any]) -> None:
    rows = []
    for item in receipt["compiled_logograms"]:
        rows.append(
            {
                "prompt": {
                    "task": "rrc_logogram_projection",
                    "sample_id": item["logogram_projection"]["sample_id"],
                    "canonical_hash": item["logogram_projection"]["canonical_hash"],
                    "semantic_regime": item["logogram_projection"]["semantic_regime"],
                },
                "completion": {
                    "shape": item["nearest_lawful_shape"]["shape"],
                    "status": item["type_witness"]["status"],
                    "projection_admissible": item["logogram_projection"]["projection_admissible"],
                    "receipt_hash": item["invariant_receipt"]["receipt_hash"],
                },
            }
        )
    CURRICULUM.write_text(
        "\n".join(stable_json(row) for row in rows) + "\n",
        encoding="utf-8",
    )


def main() -> None:
    receipt = build_receipt()
    OUT.write_text(json.dumps(receipt, indent=2, sort_keys=True), encoding="utf-8")
    write_curriculum(receipt)
    print(
        json.dumps(
            {
                "receipt": str(OUT.relative_to(REPO)),
                "curriculum": str(CURRICULUM.relative_to(REPO)),
                "receipt_hash": receipt["receipt_hash"],
                **receipt["counts"],
            },
            indent=2,
            sort_keys=True,
        )
    )


if __name__ == "__main__":
    main()