mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
341 lines
12 KiB
Python
341 lines
12 KiB
Python
#!/usr/bin/env python3
|
|
"""Receipt-backed Hutter differential frame chain probe.
|
|
|
|
Frame-invariant roots give a discrete differential chain:
|
|
|
|
x_i --dx_i--> x_{i+1}
|
|
|
|
The transition is admissible only if x_i is independently replayable, dx_i
|
|
rehydrates the next frame, and the recomputed root equals R_{i+1}. This keeps
|
|
differentials as bounded witnesses rather than a fragile predictive chain.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
from datetime import datetime, timezone
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
|
|
REPO = Path(__file__).resolve().parents[2]
|
|
OUT_DIR = REPO / "shared-data" / "data" / "hutter_differential_frame_chain"
|
|
REGISTRY = OUT_DIR / "hutter_differential_frame_chain_registry.json"
|
|
RECEIPT = OUT_DIR / "hutter_differential_frame_chain_receipt.json"
|
|
SUMMARY = OUT_DIR / "hutter_differential_frame_chain.md"
|
|
TIDDLER = REPO / "6-Documentation" / "tiddlywiki-local" / "wiki" / "tiddlers" / "Hutter Differential Frame Chain.tid"
|
|
|
|
SOURCE_REFS = [
|
|
REPO / "shared-data" / "data" / "hutter_frame_invariant_root" / "hutter_frame_invariant_root_receipt.json",
|
|
REPO / "shared-data" / "data" / "hutter_torsion_clock_adaptation" / "hutter_torsion_clock_adaptation_receipt.json",
|
|
REPO / "shared-data" / "data" / "enwiki9_logogram_canonical_baseline_probe" / "enwiki9_logogram_canonical_baseline_probe_receipt.json",
|
|
]
|
|
|
|
|
|
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 hash_obj(obj: Any) -> str:
|
|
return sha256_bytes(stable_json(obj).encode("utf-8"))
|
|
|
|
|
|
def rel(path: Path) -> str:
|
|
try:
|
|
return str(path.relative_to(REPO))
|
|
except ValueError:
|
|
return str(path)
|
|
|
|
|
|
def file_hash(path: Path) -> str | None:
|
|
return sha256_bytes(path.read_bytes()) if path.exists() else None
|
|
|
|
|
|
def source_ref(path: Path) -> dict[str, Any]:
|
|
return {"path": rel(path), "exists": path.exists(), "sha256": file_hash(path)}
|
|
|
|
|
|
def frame_state(frame_id: int, class_name: str, raw_hash: str, core_hash: str, independently_replayable: bool) -> dict[str, Any]:
|
|
payload = {
|
|
"frame_id": frame_id,
|
|
"class_name": class_name,
|
|
"raw_hash": raw_hash,
|
|
"core_hash": core_hash,
|
|
"independently_replayable": independently_replayable,
|
|
}
|
|
payload["root"] = hash_obj(payload)
|
|
return payload
|
|
|
|
|
|
def transition(
|
|
*,
|
|
transition_id: str,
|
|
source: dict[str, Any],
|
|
target: dict[str, Any],
|
|
differential_hash: str,
|
|
rehydrates_target: bool,
|
|
root_recomputes: bool,
|
|
bounded_delta: bool,
|
|
) -> dict[str, Any]:
|
|
admissible = (
|
|
source["independently_replayable"]
|
|
and target["independently_replayable"]
|
|
and rehydrates_target
|
|
and root_recomputes
|
|
and bounded_delta
|
|
)
|
|
if not source["independently_replayable"] or not target["independently_replayable"]:
|
|
decision = "HOLD_FRAME_REPLAY_REQUIRED"
|
|
elif not rehydrates_target:
|
|
decision = "REJECT_DIFFERENTIAL_REPLAY"
|
|
elif not root_recomputes:
|
|
decision = "REJECT_ROOT_MISMATCH"
|
|
elif not bounded_delta:
|
|
decision = "HOLD_UNBOUNDED_DIFFERENTIAL"
|
|
else:
|
|
decision = "ADMIT_DIFFERENTIAL_FRAME_EDGE"
|
|
item = {
|
|
"transition_id": transition_id,
|
|
"source_frame": source["frame_id"],
|
|
"target_frame": target["frame_id"],
|
|
"source_root": source["root"],
|
|
"target_root": target["root"],
|
|
"differential_hash": differential_hash,
|
|
"rehydrates_target": rehydrates_target,
|
|
"root_recomputes": root_recomputes,
|
|
"bounded_delta": bounded_delta,
|
|
"admissible": admissible,
|
|
"equation": "x_i + dx_i -> x_{i+1}; H(replay(x_i,dx_i)) == R_{i+1}",
|
|
"decision": decision,
|
|
}
|
|
item["transition_hash"] = hash_obj({k: v for k, v in item.items() if k != "transition_hash"})
|
|
return item
|
|
|
|
|
|
def build_registry() -> dict[str, Any]:
|
|
frames = [
|
|
frame_state(0, "xml_head", "raw_xml_head", "core_xml_head", True),
|
|
frame_state(1, "template_heavy", "raw_template_heavy", "core_template_heavy", True),
|
|
frame_state(2, "link_heavy", "raw_link_heavy", "core_link_heavy", True),
|
|
frame_state(3, "mixed_high_entropy", "raw_mixed_high_entropy", "core_mixed_high_entropy", True),
|
|
frame_state(4, "unsafe_long_predictive_chain", "raw_predictive", "core_predictive", False),
|
|
]
|
|
transitions = [
|
|
transition(
|
|
transition_id="dx_0_1",
|
|
source=frames[0],
|
|
target=frames[1],
|
|
differential_hash=hash_obj({"from": 0, "to": 1, "opcode": "template_delta"}),
|
|
rehydrates_target=True,
|
|
root_recomputes=True,
|
|
bounded_delta=True,
|
|
),
|
|
transition(
|
|
transition_id="dx_1_2",
|
|
source=frames[1],
|
|
target=frames[2],
|
|
differential_hash=hash_obj({"from": 1, "to": 2, "opcode": "link_delta"}),
|
|
rehydrates_target=True,
|
|
root_recomputes=True,
|
|
bounded_delta=True,
|
|
),
|
|
transition(
|
|
transition_id="dx_2_3",
|
|
source=frames[2],
|
|
target=frames[3],
|
|
differential_hash=hash_obj({"from": 2, "to": 3, "opcode": "entropy_patch"}),
|
|
rehydrates_target=True,
|
|
root_recomputes=True,
|
|
bounded_delta=True,
|
|
),
|
|
transition(
|
|
transition_id="dx_3_4_unbounded",
|
|
source=frames[3],
|
|
target=frames[4],
|
|
differential_hash=hash_obj({"from": 3, "to": 4, "opcode": "fragile_predictive_chain"}),
|
|
rehydrates_target=True,
|
|
root_recomputes=True,
|
|
bounded_delta=False,
|
|
),
|
|
]
|
|
return {
|
|
"schema": "hutter_differential_frame_chain_registry_v1",
|
|
"source_refs": [source_ref(path) for path in SOURCE_REFS],
|
|
"claim_boundary": (
|
|
"Hutter differential frame chain diagnostic only. It formalizes x_i to "
|
|
"x_{i+1} transitions over independently replayable frame roots. It does "
|
|
"not change the codec or assert actual corpus compression gains."
|
|
),
|
|
"canonical_statement": (
|
|
"Frame roots give states; differentials give admissible edges. A delta "
|
|
"is trusted only if it rehydrates the target and recomputes the target root."
|
|
),
|
|
"chain_equation": {
|
|
"state": "x_i := independently replayable frame with root R_i",
|
|
"edge": "dx_i := bounded differential witness from x_i to x_{i+1}",
|
|
"admission": "A(dx_i)=1[Decode(x_i,dx_i)=x_{i+1}] * 1[H(x_{i+1})=R_{i+1}] * 1[bounded_delta]",
|
|
"global_chain": "x_0 --dx_0--> x_1 --dx_1--> ... --dx_n--> x_{n+1}",
|
|
},
|
|
"hutter_role": {
|
|
"mjpeg_analogy": "root frames are independently replayable key frames; differentials are bounded shortcut edges",
|
|
"torsion_link": "unbounded differentials add route_coupling and predictive-chain torsion",
|
|
"admissible_use": "use dx_i for compression only when root frames remain available as finite checkpoints",
|
|
},
|
|
"frames": frames,
|
|
"transitions": transitions,
|
|
"chain_root": hash_obj([item["transition_hash"] for item in transitions]),
|
|
"aggregates": {
|
|
"frame_count": len(frames),
|
|
"transition_count": len(transitions),
|
|
"admitted_transition_count": sum(1 for item in transitions if item["decision"] == "ADMIT_DIFFERENTIAL_FRAME_EDGE"),
|
|
"hold_transition_count": sum(1 for item in transitions if item["decision"].startswith("HOLD")),
|
|
"reject_transition_count": sum(1 for item in transitions if item["decision"].startswith("REJECT")),
|
|
},
|
|
}
|
|
|
|
|
|
def build_receipt(registry: dict[str, Any]) -> dict[str, Any]:
|
|
receipt = {
|
|
"schema": "hutter_differential_frame_chain_receipt_v1",
|
|
"generated_at_utc": datetime.now(timezone.utc).isoformat(),
|
|
"timestamp_role": "metadata_only",
|
|
"generated_at_utc_included_in_receipt_hash": False,
|
|
"registry": rel(REGISTRY),
|
|
"registry_hash": hash_obj(registry),
|
|
"chain_root": registry["chain_root"],
|
|
"aggregates": registry["aggregates"],
|
|
"decision": "ADMIT_HUTTER_DIFFERENTIAL_FRAME_CHAIN_DIAGNOSTIC",
|
|
"claim_boundary": registry["claim_boundary"],
|
|
}
|
|
receipt["receipt_hash"] = sha256_bytes(
|
|
stable_json({k: v for k, v in receipt.items() if k not in {"receipt_hash", "generated_at_utc"}}).encode("utf-8")
|
|
)
|
|
return receipt
|
|
|
|
|
|
def write_summary(registry: dict[str, Any], receipt: dict[str, Any]) -> None:
|
|
lines = [
|
|
"# Hutter Differential Frame Chain",
|
|
"",
|
|
f"Decision: `{receipt['decision']}` ",
|
|
f"Receipt hash: `{receipt['receipt_hash']}`",
|
|
f"Chain root: `{registry['chain_root']}`",
|
|
"",
|
|
registry["claim_boundary"],
|
|
"",
|
|
"## Canonical Statement",
|
|
"",
|
|
registry["canonical_statement"],
|
|
"",
|
|
"## Chain Equation",
|
|
"",
|
|
]
|
|
for key, value in registry["chain_equation"].items():
|
|
lines.append(f"- `{key}`: {value}")
|
|
lines.extend(
|
|
[
|
|
"",
|
|
"## Transitions",
|
|
"",
|
|
"| Transition | Source | Target | Decision |",
|
|
"|---|---:|---:|---|",
|
|
]
|
|
)
|
|
for item in registry["transitions"]:
|
|
lines.append(f"| `{item['transition_id']}` | {item['source_frame']} | {item['target_frame']} | `{item['decision']}` |")
|
|
lines.extend(["", "## Hutter Role", ""])
|
|
for key, value in registry["hutter_role"].items():
|
|
lines.append(f"- `{key}`: {value}")
|
|
lines.extend(["", "## Source Refs", ""])
|
|
for source in registry["source_refs"]:
|
|
lines.append(f"- `{source['path']}` exists: `{source['exists']}`")
|
|
SUMMARY.write_text("\n".join(lines) + "\n", encoding="utf-8")
|
|
|
|
|
|
def write_tiddler(receipt: dict[str, Any]) -> None:
|
|
text = f"""created: 20260509000000000
|
|
modified: 20260509000000000
|
|
tags: ResearchStack Hutter Compression DifferentialChain Receipt
|
|
title: Hutter Differential Frame Chain
|
|
type: text/vnd.tiddlywiki
|
|
|
|
! Hutter Differential Frame Chain
|
|
|
|
Durable runner:
|
|
|
|
```
|
|
4-Infrastructure/shim/hutter_differential_frame_chain_probe.py
|
|
```
|
|
|
|
Receipt:
|
|
|
|
```
|
|
{rel(RECEIPT)}
|
|
```
|
|
|
|
Receipt hash:
|
|
|
|
```
|
|
{receipt['receipt_hash']}
|
|
```
|
|
|
|
Chain root:
|
|
|
|
```
|
|
{receipt['chain_root']}
|
|
```
|
|
|
|
!! Doctrine
|
|
|
|
Frame roots give states. Differentials give admissible edges.
|
|
|
|
```
|
|
x_i --dx_i--> x_(i+1)
|
|
A(dx_i)=1[Decode(x_i,dx_i)=x_(i+1)] * 1[H(x_(i+1))=R_(i+1)] * 1[bounded_delta]
|
|
```
|
|
|
|
This lets the codec say x leads to x(i) without losing independently replayable roots.
|
|
|
|
!! Links
|
|
|
|
* [[Hutter Frame Invariant Root]]
|
|
* [[Hutter Torsion Clock Adaptation]]
|
|
* [[Torsion Interval Gaussian Splat Witness]]
|
|
"""
|
|
TIDDLER.write_text(text, encoding="utf-8")
|
|
|
|
|
|
def main() -> int:
|
|
OUT_DIR.mkdir(parents=True, exist_ok=True)
|
|
registry = build_registry()
|
|
receipt = build_receipt(registry)
|
|
REGISTRY.write_text(json.dumps(registry, indent=2, sort_keys=True) + "\n", encoding="utf-8")
|
|
RECEIPT.write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n", encoding="utf-8")
|
|
write_summary(registry, receipt)
|
|
write_tiddler(receipt)
|
|
print(
|
|
json.dumps(
|
|
{
|
|
"registry": rel(REGISTRY),
|
|
"receipt": rel(RECEIPT),
|
|
"summary": rel(SUMMARY),
|
|
"tiddler": rel(TIDDLER),
|
|
"receipt_hash": receipt["receipt_hash"],
|
|
"chain_root": registry["chain_root"],
|
|
"decision": receipt["decision"],
|
|
"aggregates": registry["aggregates"],
|
|
},
|
|
indent=2,
|
|
sort_keys=True,
|
|
)
|
|
)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|