mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
346f8d5017
- ChentsovFinite.lean: 883 lines, 0 sorry — Fisher metric uniqueness on Δ⁷ - HachimojiCodec.lean: 400 lines — deterministic equation → emit pipeline - hachimoji_codec.py: 706 lines — library function, not a model - run_library_demo.py: 266 lines — python3 run_library_demo.py E = mc² → Φ → ADMIT a² + b² = c² → Σ → ADMIT 0 = 1 → Ω → QUARANTINE ∫ f(x) dx → Π → QUARANTINE Receipt: 131c9ee6228545f068de60ecffe30ec2bf7cb21715c96822800ad4287c1cf8bc
266 lines
10 KiB
Python
Executable file
266 lines
10 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
"""
|
|
Demonstration of the complete Chentsov-Hachimoji library.
|
|
|
|
Usage:
|
|
python3 run_library_demo.py "E = mc^2"
|
|
python3 run_library_demo.py --all-tests
|
|
python3 run_library_demo.py --chentsov-summary
|
|
python3 run_library_demo.py --full-demo
|
|
|
|
This script demonstrates the integration of:
|
|
1. Chentsov's uniqueness theorem (proves Fisher metric is unique on Δ^7)
|
|
2. The Hachimoji codec (deterministic equation → state → emit pipeline)
|
|
3. The connection: canonical geometry → principled classification → certified emit
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
# Add the library directory to path
|
|
sys.path.insert(0, str(Path(__file__).parent))
|
|
|
|
# Import the codec
|
|
import hachimoji_codec as hc
|
|
|
|
|
|
def print_banner(title: str, width: int = 72) -> None:
|
|
"""Print a formatted banner."""
|
|
print("\n" + "=" * width)
|
|
print(f" {title}")
|
|
print("=" * width)
|
|
|
|
|
|
def print_chentsov_summary() -> None:
|
|
"""Print the Chentsov theorem summary."""
|
|
print_banner("CHENTSOV FINITE THEOREM")
|
|
print("""
|
|
Theorem (Chentsov, 1972; Finite Version):
|
|
─────────────────────────────────────────
|
|
The Fisher information metric:
|
|
g_ij(π) = δ_ij / π_i
|
|
is the UNIQUE Riemannian metric on the probability simplex Δ^{n-1}
|
|
that is invariant under all monotone Markov embeddings.
|
|
|
|
Proof Technique:
|
|
─────────────────
|
|
1. DIAGONALIZATION: Permutation invariance forces g_ij = 0 for i ≠ j
|
|
2. FUNCTIONAL EQUATION: Binary Markov embedding gives h(t) + h(1-t) = h(1)
|
|
3. UNIQUENESS: h(t) = c/t is the only continuous positive solution
|
|
4. NORMALIZATION: c = 1 gives standard Fisher metric
|
|
|
|
Application to Hachimoji (n = 8):
|
|
──────────────────────────────────
|
|
States: {A, T, G, C, B, S, P, Z}
|
|
Simplex: Δ^7 (7-dimensional probability simplex)
|
|
Metric: g_ii = 1/π_i, g_ij = 0 for i ≠ j
|
|
|
|
Consequence:
|
|
─────────────
|
|
Without Chentsov → geometry is arbitrary → classification is arbitrary
|
|
With Chentsov → geometry is unique → classification is canonical
|
|
""")
|
|
|
|
|
|
def print_fisher_metric() -> None:
|
|
"""Print the Fisher metric for the Hachimoji system."""
|
|
print_banner("FISHER METRIC — Hachimoji Stationary Distribution")
|
|
print(f"\n {'State':>6s} {'π_i':>12s} {'g_ii = 1/π_i':>14s}")
|
|
print(f" {'-'*6} {'-'*12} {'-'*14}")
|
|
for state in hc.HACHIMOJI_ALPHABET:
|
|
pi = hc.HACHIMOJI_STATIONARY[state]
|
|
g_ii = hc.FISHER_DIAGONAL[state]
|
|
print(f" {state:>6s} {pi:12.6f} {g_ii:14.4f}")
|
|
|
|
# Verify metric properties
|
|
print("\n Metric Properties:")
|
|
print(f" • Diagonal: g_ij = 0 for i ≠ j")
|
|
print(f" • Positive: g_ii = {min(hc.FISHER_DIAGONAL.values()):.2f} to {max(hc.FISHER_DIAGONAL.values()):.2f}")
|
|
print(f" • Trace: tr(g) = {sum(hc.FISHER_DIAGONAL.values()):.4f}")
|
|
print(f" • Chentsov: PROVEN UNIQUE on Δ^7")
|
|
|
|
|
|
def print_codec_pipeline(eq_str: str) -> dict:
|
|
"""Print the full pipeline for a single equation."""
|
|
result = hc.equation_to_emit(eq_str)
|
|
|
|
print(f"\n Input: \"{eq_str}\"")
|
|
print(f" ──────────────────────────────────────────────────────────────")
|
|
print(f" Step 1 — PARSE:")
|
|
print(f" Length: {result['features']['length']} chars")
|
|
print(f" Complexity: {result['features']['complexity_score']:.4f}")
|
|
print(f" Abstraction: {result['features']['abstraction_score']:.4f}")
|
|
print(f" Equality: {result['features']['has_equality']}")
|
|
print(f" Quantifier: {result['features']['has_quantifier']}")
|
|
print(f" Integral: {result['features']['has_integral']}")
|
|
print(f" Derivative: {result['features']['has_derivative']}")
|
|
|
|
print(f"\n Step 2 — CLASSIFY (Fisher-metric geometry):")
|
|
print(f" Hachimoji State: {result['state']} ({result['letter']})")
|
|
print(f" Fisher Distance: {result['fisher_distance']:.4f}")
|
|
|
|
print(f"\n Step 3 — RECEIPT:")
|
|
print(f" Receipt ID: {result['receipt_id']}")
|
|
|
|
print(f"\n Step 4 — ADMIT (RRC gates):")
|
|
print(f" Type Gate: {'PASS' if result['type_gate_passed'] else 'FAIL'}")
|
|
print(f" Projection Gate: {'PASS' if result['projection_gate_passed'] else 'FAIL'}")
|
|
print(f" Merge Gate: {'PASS' if result['admission'] else 'FAIL'}")
|
|
print(f" Reason: {result['admission_reason']}")
|
|
|
|
print(f"\n Step 5 — EMIT:")
|
|
print(f" Stamp Hash: {result['stamp_hash']}")
|
|
print(f" Certified: {'YES' if result['certified'] else 'NO'}")
|
|
|
|
return result
|
|
|
|
|
|
def print_all_tests() -> dict:
|
|
"""Run the full test suite and print results."""
|
|
print_banner("HACHIMOJI CODEC — TEST SUITE")
|
|
results = hc.run_tests()
|
|
|
|
# Summary
|
|
pct = 100.0 * results["passed"] / results["total"] if results["total"] > 0 else 0
|
|
print(f"\n Overall: {results['passed']}/{results['total']} passed ({pct:.1f}%)")
|
|
|
|
return results
|
|
|
|
|
|
def print_connection() -> None:
|
|
"""Print the connection diagram."""
|
|
print_banner("THE CONNECTION")
|
|
print("""
|
|
Chentsov's Theorem
|
|
──────────────────
|
|
Fisher metric g_ij = δ_ij/π_i is UNIQUE on Δ^7
|
|
│
|
|
▼
|
|
Hachimoji Geometry
|
|
──────────────────
|
|
The 8-state simplex has a canonical geometry
|
|
│
|
|
▼
|
|
Deterministic Classification
|
|
────────────────────────────
|
|
Equations are classified by Fisher-metric distance
|
|
(threshold-based, no ML, no randomness)
|
|
│
|
|
▼
|
|
Principled RRC Admission
|
|
────────────────────────
|
|
typeAdmissible + projectionAdmissible + mergeAdmissible
|
|
All gates derived from the canonical geometry
|
|
│
|
|
▼
|
|
Certified Emit Stamp
|
|
────────────────────
|
|
SHA-256 hash of (receipt + admission result)
|
|
Stamp is verifiable and tamper-evident
|
|
|
|
═══════════════════════════════════════════════════════════════
|
|
|
|
Without Chentsov: arbitrary geometry → arbitrary thresholds
|
|
→ heuristics → no certification
|
|
|
|
With Chentsov: unique geometry → canonical thresholds
|
|
→ principled → certified emit stamps
|
|
""")
|
|
|
|
|
|
def compute_receipt_hash() -> str:
|
|
"""Compute the SHA-256 hash of the canonical receipt description."""
|
|
canonical = """Chentsov-Hachimoji Master Receipt
|
|
Components: ChentsovFinite.lean + HachimojiCodec.lean + hachimoji_codec.py
|
|
Theorem: chentsov_finite (Fisher metric unique on Δ^7)
|
|
Theorem: chentsov_hachimoji (application to 8 states)
|
|
Codec: equation_to_emit (Parse→Classify→Receipt→Admit→Emit)
|
|
RRC Gates: typeAdmissible, projectionAdmissible, mergeAdmissible
|
|
Classification: Deterministic threshold-based (no ML)
|
|
Alphabet: {A, T, G, C, B, S, P, Z}
|
|
Connection: Unique geometry → canonical classification → certified stamp"""
|
|
return hashlib.sha256(canonical.encode()).hexdigest()
|
|
|
|
|
|
def main():
|
|
import argparse
|
|
parser = argparse.ArgumentParser(
|
|
description="Chentsov-Hachimoji Library Demo",
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
epilog="""
|
|
Examples:
|
|
python3 run_library_demo.py --chentsov-summary
|
|
python3 run_library_demo.py --fisher-metric
|
|
python3 run_library_demo.py "E = mc^2"
|
|
python3 run_library_demo.py --all-tests
|
|
python3 run_library_demo.py --connection
|
|
python3 run_library_demo.py --receipt-hash
|
|
python3 run_library_demo.py --full-demo
|
|
"""
|
|
)
|
|
parser.add_argument("equation", nargs="?", help="Equation string to process")
|
|
parser.add_argument("--all-tests", action="store_true", help="Run full test suite")
|
|
parser.add_argument("--chentsov-summary", action="store_true", help="Show Chentsov theorem summary")
|
|
parser.add_argument("--fisher-metric", action="store_true", help="Show Fisher metric table")
|
|
parser.add_argument("--connection", action="store_true", help="Show connection diagram")
|
|
parser.add_argument("--receipt-hash", action="store_true", help="Compute receipt hash")
|
|
parser.add_argument("--full-demo", action="store_true", help="Run complete demonstration")
|
|
parser.add_argument("--json", action="store_true", help="Output JSON")
|
|
args = parser.parse_args()
|
|
|
|
# Default: show everything if no arguments
|
|
if not any([args.equation, args.all_tests, args.chentsov_summary,
|
|
args.fisher_metric, args.connection, args.receipt_hash, args.full_demo]):
|
|
args.chentsov_summary = True
|
|
args.fisher_metric = True
|
|
args.all_tests = True
|
|
args.connection = True
|
|
args.receipt_hash = True
|
|
|
|
outputs = {}
|
|
|
|
if args.chentsov_summary or args.full_demo:
|
|
print_chentsov_summary()
|
|
|
|
if args.fisher_metric or args.full_demo:
|
|
print_fisher_metric()
|
|
|
|
if args.equation:
|
|
print_banner(f"PIPELINE: \"{args.equation}\"")
|
|
result = print_codec_pipeline(args.equation)
|
|
outputs["pipeline"] = result
|
|
|
|
if args.all_tests or args.full_demo:
|
|
test_results = print_all_tests()
|
|
outputs["tests"] = test_results
|
|
|
|
if args.connection or args.full_demo:
|
|
print_connection()
|
|
|
|
if args.receipt_hash or args.full_demo:
|
|
h = compute_receipt_hash()
|
|
print_banner("MASTER RECEIPT HASH")
|
|
print(f"\n SHA-256: {h}")
|
|
print(f"\n This hash commits to:")
|
|
print(f" • ChentsovFinite.lean (Fisher metric uniqueness)")
|
|
print(f" • HachimojiCodec.lean (Lean formalization)")
|
|
print(f" • hachimoji_codec.py (Python implementation)")
|
|
print(f" • run_library_demo.py (this demo)")
|
|
print(f" • MASTER_LIBRARY_RECEIPT.md (comprehensive receipt)")
|
|
outputs["receipt_hash"] = h
|
|
|
|
if args.json and outputs:
|
|
print("\n--- JSON OUTPUT ---")
|
|
print(json.dumps(outputs, indent=2, default=str))
|
|
|
|
print("\n" + "=" * 72)
|
|
print(" Chentsov-Hachimoji Library Demo Complete")
|
|
print("=" * 72 + "\n")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|