rns-engine 0.11.0__tar.gz → 0.11.2__tar.gz

{rns_engine-0.11.0 → rns_engine-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rns_engine
-Version: 0.11.0
+Version: 0.11.2
 Summary: Exact RNS engine with session/cache API.
 Author: Evan Wesley
 License-Expression: AGPL-3.0-only

{rns_engine-0.11.0 → rns_engine-0.11.2}/pyproject.toml

@@ -11,7 +11,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rns_engine"
-version = "0.11.0"
+version = "0.11.2"
 description = "Exact RNS engine with session/cache API."
 readme = "README.md"
 requires-python = ">=3.10,<3.15"
@@ -74,4 +74,4 @@ archs = ["x86_64"]
 environment = {PIP_ONLY_BINARY = "numpy"}
 
 [tool.cibuildwheel.windows]
-archs = ["AMD64"]
+archs = ["AMD64"]

{rns_engine-0.11.0 → rns_engine-0.11.2}/src/rns_engine/__init__.py

@@ -116,7 +116,7 @@ from .pre_cuda import (
     run_pre_cuda_readiness,
 )
 from .g4_results import g4_results
-from .g4_benchmark import g4_benchmark
+from .g4_trust import g4_benchmark
 
 
 try:
@@ -180,4 +180,4 @@ def info():
     print("  Bridge APIs   : weighted signed INT32 accumulation with range receipts")
     print("  Planning APIs : local/global capacity + exact Mersenne rail-set search")
     print("  Pre-CUDA APIs : seven-rail oracle + exact shared-scale GEMM fixtures")
-    print("  G4 APIs       : frozen Series 1 evidence + Tesla T4 reproduction benchmark")
+    print("  G4 APIs       : frozen Series 1 evidence + Tesla T4 reproduction benchmark")

{rns_engine-0.11.0 → rns_engine-0.11.2}/src/rns_engine/g4_results.py

@@ -34,29 +34,31 @@ def _pct(value: float) -> str:
 
 
 def _print_integer(campaign: dict, stream: TextIO) -> None:
-    print("[Exact integer / NVIDIA FP16-input cuBLASLt]", file=stream)
+    print("=== G4 INTEGERS vs NVIDIA FP16 cuBLASLt ===", file=stream)
+    print("Frozen Series 1 integer test — separate from the rational test below.", file=stream)
     print(
-        f"Exact wins: {campaign['exact_wins']} / {campaign['declared_shapes']} "
+        f"G4 exact integers faster: {campaign['exact_wins']} / {campaign['declared_shapes']} "
         f"({_pct(campaign['exact_win_rate'])})",
         file=stream,
     )
-    print(f"NVIDIA wins: {campaign['floating_wins']}", file=stream)
-    print("Exact replay before + after timing: PASS on all 1,024 shapes", file=stream)
-    print(f"Median speedup among exact wins: {campaign['exact_win_speedup_median']:.3f}x", file=stream)
-    print(f"Best exact-win speedup: {campaign['best_exact_win_speedup']:.3f}x", file=stream)
+    print(f"NVIDIA FP16 faster: {campaign['floating_wins']} / {campaign['declared_shapes']}", file=stream)
+    print("Integer exactness: replay before + after timing PASS on all 1,024 shapes", file=stream)
+    print(f"Median integer speedup among G4 wins: {campaign['exact_win_speedup_median']:.3f}x", file=stream)
+    print(f"Best integer G4 speedup: {campaign['best_exact_win_speedup']:.3f}x", file=stream)
 
 
 def _print_rational(campaign: dict, stream: TextIO) -> None:
-    print("[Exact rational / NVIDIA FP16]", file=stream)
+    print("=== G4 RATIONALS vs NVIDIA FP16 cuBLASLt ===", file=stream)
+    print("Frozen Series 1 rational test — separate from the integer test above.", file=stream)
     print(
-        f"Certified exact wins: {campaign['certified_exact_wins']} / {campaign['target_shapes']} "
+        f"G4 exact rationals faster (certified): {campaign['certified_exact_wins']} / {campaign['target_shapes']} "
         f"({_pct(campaign['certified_exact_win_rate'])})",
         file=stream,
     )
-    print(f"Remaining unresolved at archive freeze: {campaign['remaining_unresolved']}", file=stream)
-    print("Certified winners: non-integer inputs PASS | range proof PASS | FP16 value-set proof PASS", file=stream)
-    print(f"Median certified speedup: {campaign['certified_speedup_median']:.3f}x", file=stream)
-    print(f"Best certified speedup: {campaign['best_certified_speedup']:.3f}x", file=stream)
+    print(f"Rational shapes unresolved at archive freeze: {campaign['remaining_unresolved']}", file=stream)
+    print("Certified rational winners: non-integer inputs PASS | range proof PASS | FP16 value-set proof PASS", file=stream)
+    print(f"Median rational speedup among certified G4 wins: {campaign['certified_speedup_median']:.3f}x", file=stream)
+    print(f"Best certified rational G4 speedup: {campaign['best_certified_speedup']:.3f}x", file=stream)
 
 
 def g4_results(
@@ -97,6 +99,7 @@ def g4_results(
     if display:
         out = stream if stream is not None else sys.stdout
         print("=== G4 SERIES 1 — TESLA T4 RESULTS ===", file=out)
+        print("Two separate tests are reported below. Do not combine their scores.", file=out)
         print(file=out)
         if selected in ("all", "integer_fp16_input_clean_sweep"):
             _print_integer(evidence["campaigns"]["integer_fp16_input_clean_sweep"], out)
@@ -106,9 +109,11 @@ def g4_results(
             _print_rational(evidence["campaigns"]["dynamic_exact_rational"], out)
         if selected == "all":
             print(file=out)
-            print("91.60% integer and 84.96% rational are separate benchmark results.", file=out)
+            print("INTEGER RESULT:  938 / 1024 = 91.60%", file=out)
+            print("RATIONAL RESULT: 870 / 1024 = 84.96%", file=out)
+            print("These are separate benchmark results against NVIDIA FP16 cuBLASLt.", file=out)
 
     return result
 
 
-__all__ = ["g4_results"]
+__all__ = ["g4_results"]

rns_engine-0.11.2/src/rns_engine/g4_trust.py

@@ -0,0 +1,356 @@
+"""Human-readable, cryptographically committed trust receipt for G4 replay runs."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import hashlib
+import json
+import os
+import platform
+import re
+import subprocess
+import sys
+from importlib.metadata import PackageNotFoundError, version as distribution_version
+from typing import TextIO
+
+from .g4_benchmark import (
+    _BLOCKS,
+    _BOOTSTRAP_REPETITIONS,
+    _PROMOTION,
+    _REQUIRED_WINS,
+    _box,
+    _runtime_metadata,
+    g4_benchmark as _core_g4_benchmark,
+)
+
+_TRUST_SCHEMA = "RNS-ENGINE-G4S1-TRUST-PACK-1"
+
+_LIVE_REPORT_REPLACEMENTS = (
+    ("EXACTNESS - FRESH RUN", "G4 RATIONALS - EXACTNESS - FRESH RUN"),
+    (
+        "SPEED - FRESH RUN DIRECTLY AGAINST NVIDIA FP16",
+        "G4 RATIONALS - SPEED vs NVIDIA FP16 - FRESH RUN",
+    ),
+    ("REPRODUCIBILITY", "G4 RATIONALS - REPRODUCIBILITY"),
+    ("Exact rational calculations correct:", "G4 rational calculations correct:"),
+    ("Exact rational faster:", "G4 RATIONALS faster than NVIDIA FP16:"),
+    ("NVIDIA FP16 faster:", "NVIDIA FP16 faster than G4 RATIONALS:"),
+    ("Too close to call:", "G4 RATIONALS / NVIDIA FP16 statistical ties:"),
+    ("Median speedup when exact wins:", "Median speedup when G4 RATIONALS win:"),
+    (
+        "Same winner/tie result as original:",
+        "RATIONAL winner/tie classification matches original RATIONAL benchmark:",
+    ),
+)
+
+
+class _RationalLiveReportStream:
+    """Relabel the existing live report without touching benchmark math or progress output."""
+
+    def __init__(self, target: TextIO):
+        self._target = target
+
+    @staticmethod
+    def _replace(text: str) -> str:
+        for old, new in _LIVE_REPORT_REPLACEMENTS:
+            text = text.replace(old, new)
+        return text
+
+    def _rewrite_line(self, line: str) -> str:
+        newline = "\n" if line.endswith("\n") else ""
+        body = line[:-1] if newline else line
+        if body.startswith("| ") and body.endswith(" |"):
+            inner_width = len(body) - 4
+            content = body[2:-2].rstrip()
+            content = self._replace(content)
+            return "| " + content[:inner_width].ljust(inner_width) + " |" + newline
+        return self._replace(body) + newline
+
+    def write(self, text: str) -> int:
+        rewritten = "".join(self._rewrite_line(line) for line in text.splitlines(keepends=True))
+        return self._target.write(rewritten)
+
+    def flush(self) -> None:
+        self._target.flush()
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")
+
+
+def _canonical_json_bytes(value: object) -> bytes:
+    return json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=True,
+        allow_nan=False,
+    ).encode("utf-8")
+
+
+def _sha256_json(value: object) -> str:
+    return hashlib.sha256(_canonical_json_bytes(value)).hexdigest()
+
+
+def _package_version() -> str:
+    try:
+        return distribution_version("rns_engine")
+    except PackageNotFoundError:
+        return "0+unknown"
+
+
+def _environment_name() -> str:
+    if (
+        "google.colab" in sys.modules
+        or os.environ.get("COLAB_RELEASE_TAG")
+        or os.environ.get("COLAB_BACKEND_VERSION")
+        or os.environ.get("COLAB_GPU")
+    ):
+        return "Google Colab"
+    return platform.platform()
+
+
+def _current_cuda_version() -> str:
+    try:
+        proc = subprocess.run(
+            ["nvidia-smi"],
+            text=True,
+            capture_output=True,
+            check=False,
+            timeout=10,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return "unavailable"
+    if proc.returncode != 0:
+        return "unavailable"
+    match = re.search(r"CUDA Version:\s*([0-9.]+)", proc.stdout)
+    return match.group(1) if match else "unavailable"
+
+
+def _gpu_state_snapshot() -> dict:
+    command = [
+        "nvidia-smi",
+        "--query-gpu=pstate,temperature.gpu,power.draw,clocks.current.sm,clocks.current.memory",
+        "--format=csv,noheader,nounits",
+    ]
+    try:
+        proc = subprocess.run(
+            command,
+            text=True,
+            capture_output=True,
+            check=False,
+            timeout=10,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired) as exc:
+        return {"available": False, "error": type(exc).__name__}
+    if proc.returncode != 0:
+        return {
+            "available": False,
+            "error": proc.stderr.strip() or f"nvidia-smi exit {proc.returncode}",
+        }
+    rows = [line.strip() for line in proc.stdout.splitlines() if line.strip()]
+    if len(rows) != 1:
+        return {"available": False, "error": f"expected one GPU row, got {len(rows)}"}
+    parts = [part.strip() for part in rows[0].split(",")]
+    if len(parts) != 5:
+        return {"available": False, "error": f"unexpected GPU state row: {rows[0]}"}
+    return {
+        "available": True,
+        "pstate": parts[0],
+        "temperature_c": parts[1],
+        "power_w": parts[2],
+        "sm_clock_mhz": parts[3],
+        "memory_clock_mhz": parts[4],
+    }
+
+
+def _format_gpu_state(snapshot: dict) -> str:
+    if snapshot.get("available") is not True:
+        return "unavailable"
+    return (
+        f"{snapshot['pstate']} | {snapshot['temperature_c']} C | {snapshot['power_w']} W | "
+        f"SM {snapshot['sm_clock_mhz']} MHz | MEM {snapshot['memory_clock_mhz']} MHz"
+    )
+
+
+def _build_cuda_summary(build_nvcc: str) -> str:
+    match = re.search(r"release\s+([0-9.]+),\s+V([0-9.]+)", build_nvcc)
+    if match:
+        return f"CUDA {match.group(1)} / nvcc V{match.group(2)}"
+    for line in reversed(build_nvcc.splitlines()):
+        if line.strip():
+            return line.strip()
+    return "unavailable"
+
+
+def _print_test_scope(stream: TextIO) -> None:
+    _box(
+        "G4 SERIES 1 - TWO SEPARATE TESTS",
+        [
+            "G4 INTEGERS  vs NVIDIA FP16 cuBLASLt: frozen result 938 / 1024 (91.60%)",
+            "G4 RATIONALS vs NVIDIA FP16 cuBLASLt: frozen result 870 / 1024 (84.96%)",
+            "",
+            "LIVE BENCHMARK BELOW: G4 RATIONALS vs NVIDIA FP16 ONLY.",
+            "g4_benchmark() does not rerun the integer benchmark; the integer score is context only.",
+        ],
+        stream,
+        width=112,
+    )
+
+
+def _add_species_labels(result: dict) -> None:
+    result["live_test"] = "G4_RATIONALS_vs_NVIDIA_FP16_cuBLASLt"
+    summary = result.setdefault("summary", {})
+    if "frozen_decision_matches" in summary:
+        summary["rational_frozen_decision_matches"] = summary["frozen_decision_matches"]
+
+
+def _make_trust_pack(
+    result: dict,
+    *,
+    started_utc: str,
+    completed_utc: str,
+    environment: str,
+    package_version: str,
+    current_cuda: str,
+    gpu_before: dict,
+    gpu_after: dict,
+) -> dict:
+    meta = _runtime_metadata()
+    rows = result["rows"]
+    rows_sha256 = _sha256_json(rows)
+    exact_rows = sum(bool(row.get("exact_replay_passed")) for row in rows)
+
+    receipt = {
+        "schema": _TRUST_SCHEMA,
+        "series": result.get("series"),
+        "campaign": result.get("campaign"),
+        "live_test": result.get("live_test", "G4_RATIONALS_vs_NVIDIA_FP16_cuBLASLt"),
+        "mode": result.get("mode"),
+        "started_utc": started_utc,
+        "completed_utc": completed_utc,
+        "package": {
+            "name": "rns_engine",
+            "version": package_version,
+            "release_tag": f"v{package_version}",
+        },
+        "environment": {
+            "name": environment,
+            "python": platform.python_version(),
+            "platform": platform.platform(),
+            "current_cuda_reported_by_nvidia_smi": current_cuda,
+        },
+        "gpu": result.get("gpu", {}),
+        "gpu_state_before": gpu_before,
+        "gpu_state_after": gpu_after,
+        "protocol": {
+            "comparison": "G4 exact rational GEMM vs NVIDIA FP16 cuBLASLt",
+            "paired_timing_blocks_per_shape": _BLOCKS,
+            "bootstrap_resamples_per_shape": _BOOTSTRAP_REPETITIONS,
+            "bootstrap_confidence_interval": 0.95,
+            "promotion_threshold": _PROMOTION,
+            "required_exact_block_wins": _REQUIRED_WINS,
+            "fail_closed_on_runtime_error": True,
+            "fail_closed_on_exactness_failure": True,
+        },
+        "exactness": {
+            "rows_exact": exact_rows,
+            "rows_total": len(rows),
+            "runtime_errors": int(result.get("summary", {}).get("runtime_errors", 0)),
+            "exact_replay_failures": int(
+                result.get("summary", {}).get("exact_replay_failures", 0)
+            ),
+        },
+        "runtime": {
+            "binary_sha256": result["runtime"]["binary_sha256"],
+            "payload_sha256": result["runtime"]["payload_sha256"],
+            "source_archive_sha256": result["runtime"]["source_archive_sha256"],
+            "public_runtime_source_sha256": meta.get("public_runtime_source_sha256"),
+            "build_nvcc": result["runtime"]["build_nvcc"],
+        },
+        "timing_seconds": result.get("timing_seconds", {}),
+        "summary": result.get("summary", {}),
+        "result_rows_sha256": rows_sha256,
+    }
+    receipt_sha256 = _sha256_json(receipt)
+    return {**receipt, "run_receipt_sha256": receipt_sha256}
+
+
+def _print_trust_pack(trust: dict, stream: TextIO) -> None:
+    gpu = trust["gpu"]
+    package = trust["package"]
+    exactness = trust["exactness"]
+    runtime = trust["runtime"]
+    protocol = trust["protocol"]
+    environment = trust["environment"]
+
+    _box(
+        "TRUST PACK - G4 RATIONAL RUN RECEIPT",
+        [
+            "Live test: G4 RATIONALS vs NVIDIA FP16 cuBLASLt",
+            f"Environment: {environment['name']} | rns_engine {package['version']} | release {package['release_tag']}",
+            f"Python: {environment['python']} | CUDA reported by NVIDIA: {environment['current_cuda_reported_by_nvidia_smi']}",
+            f"GPU: {gpu.get('name', 'unknown')} | compute capability {gpu.get('compute_capability', 'unknown')} | driver {gpu.get('driver_version', 'unknown')}",
+            f"Replay build toolchain: {_build_cuda_summary(runtime['build_nvcc'])}",
+            f"GPU state before: {_format_gpu_state(trust['gpu_state_before'])}",
+            f"GPU state after:  {_format_gpu_state(trust['gpu_state_after'])}",
+            "",
+            f"Protocol: {protocol['paired_timing_blocks_per_shape']} paired timing blocks/shape | {protocol['bootstrap_resamples_per_shape']:,} bootstrap resamples/shape | 95% CI",
+            f"Rational exactness gate: {exactness['rows_exact']} / {exactness['rows_total']} exact | runtime errors {exactness['runtime_errors']} | exactness failures {exactness['exact_replay_failures']}",
+            "",
+            f"Replay binary SHA-256:   {runtime['binary_sha256']}",
+            f"Replay payload SHA-256:  {runtime['payload_sha256']}",
+            f"Source archive SHA-256:   {runtime['source_archive_sha256']}",
+            f"All result rows SHA-256:  {trust['result_rows_sha256']}",
+            f"Run receipt SHA-256:      {trust['run_receipt_sha256']}",
+            "",
+            f"Started UTC: {trust['started_utc']} | Completed UTC: {trust['completed_utc']}",
+        ],
+        stream,
+        width=112,
+    )
+
+
+def g4_benchmark(
+    mode: str = "quick",
+    *,
+    display: bool = True,
+    stream: TextIO | None = None,
+) -> dict:
+    """Run the public rational G4 benchmark and append a cryptographic trust receipt."""
+    out = stream if stream is not None else sys.stdout
+    started_utc = _utc_now()
+    environment = _environment_name()
+    package_version = _package_version()
+    current_cuda = _current_cuda_version()
+    gpu_before = _gpu_state_snapshot()
+
+    if display:
+        _print_test_scope(out)
+        print(file=out)
+
+    live_out = _RationalLiveReportStream(out) if display else out
+    result = _core_g4_benchmark(mode, display=display, stream=live_out)
+    _add_species_labels(result)
+
+    gpu_after = _gpu_state_snapshot()
+    completed_utc = _utc_now()
+    trust = _make_trust_pack(
+        result,
+        started_utc=started_utc,
+        completed_utc=completed_utc,
+        environment=environment,
+        package_version=package_version,
+        current_cuda=current_cuda,
+        gpu_before=gpu_before,
+        gpu_after=gpu_after,
+    )
+    result["trust_pack"] = trust
+
+    if display:
+        print(file=out)
+        _print_trust_pack(trust, out)
+
+    return result
+
+
+__all__ = ["g4_benchmark"]

{rns_engine-0.11.0 → rns_engine-0.11.2}/src/rns_engine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rns_engine
-Version: 0.11.0
+Version: 0.11.2
 Summary: Exact RNS engine with session/cache API.
 Author: Evan Wesley
 License-Expression: AGPL-3.0-only

{rns_engine-0.11.0 → rns_engine-0.11.2}/src/rns_engine.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/rns_engine/engine.py
 src/rns_engine/exact_gemm.py
 src/rns_engine/g4_benchmark.py
 src/rns_engine/g4_results.py
+src/rns_engine/g4_trust.py
 src/rns_engine/lane_plan.py
 src/rns_engine/pre_cuda.py
 src/rns_engine/rail_planning.py
@@ -71,6 +72,8 @@ tests/test_cuda_contract.py
 tests/test_exact_gemm.py
 tests/test_g4_benchmark.py
 tests/test_g4_results.py
+tests/test_g4_species_labels.py
+tests/test_g4_trust.py
 tests/test_packaging.py
 tests/test_pre_cuda.py
 tests/test_pre_cuda_assets.py

{rns_engine-0.11.0 → rns_engine-0.11.2}/tests/test_g4_results.py

@@ -28,15 +28,19 @@ def test_g4_results_keeps_integer_and_rational_claims_distinct():
     assert rational["all_certified_fp16_value_set_proved"] is True
 
 
-def test_g4_results_report_labels_both_percentages():
+def test_g4_results_report_labels_both_species_and_percentages():
     stream = io.StringIO()
     g4_results(stream=stream)
     text = stream.getvalue()
-    assert "938 / 1024 (91.60%)" in text
-    assert "870 / 1024 (84.96%)" in text
+    assert "G4 INTEGERS vs NVIDIA FP16 cuBLASLt" in text
+    assert "G4 RATIONALS vs NVIDIA FP16 cuBLASLt" in text
+    assert "G4 exact integers faster: 938 / 1024 (91.60%)" in text
+    assert "G4 exact rationals faster (certified): 870 / 1024 (84.96%)" in text
+    assert "INTEGER RESULT:  938 / 1024 = 91.60%" in text
+    assert "RATIONAL RESULT: 870 / 1024 = 84.96%" in text
     assert "separate benchmark results" in text
 
 
 def test_g4_results_bad_campaign_rejected():
     with pytest.raises(ValueError):
-        g4_results("series2", display=False)
+        g4_results("series2", display=False)

rns_engine-0.11.2/tests/test_g4_species_labels.py

@@ -0,0 +1,109 @@
+from copy import deepcopy
+from io import StringIO
+
+import rns_engine.g4_trust as trust
+
+
+def _result():
+    return {
+        "schema": "RNS-ENGINE-G4S1-LIVE-BENCHMARK-2",
+        "series": 1,
+        "campaign": "dynamic_exact_rational_vs_fp16",
+        "mode": "full",
+        "gpu": {"name": "Tesla T4", "compute_capability": "7.5", "driver_version": "580.82.07"},
+        "runtime": {
+            "binary_sha256": "a" * 64,
+            "payload_sha256": "b" * 64,
+            "source_archive_sha256": "c" * 64,
+            "build_nvcc": "Cuda compilation tools, release 12.8, V12.8.93",
+            "config_provenance": {},
+        },
+        "timing_seconds": {"gpu_test": 1.0, "result_verification": 1.0, "total": 2.0},
+        "summary": {
+            "shapes_run": 2,
+            "runtime_errors": 0,
+            "exact_replay_failures": 0,
+            "live_exact_wins": 1,
+            "live_floating_wins": 1,
+            "live_statistical_ties": 0,
+            "frozen_decision_matches": 2,
+        },
+        "rows": [
+            {"shape_id": "A", "exact_replay_passed": True, "live_decision": "EXACT_WIN"},
+            {"shape_id": "B", "exact_replay_passed": True, "live_decision": "FLOATING_WIN"},
+        ],
+    }
+
+
+def _snapshot():
+    return {
+        "available": True,
+        "pstate": "P0",
+        "temperature_c": "45",
+        "power_w": "38.50",
+        "sm_clock_mhz": "1590",
+        "memory_clock_mhz": "5001",
+    }
+
+
+def _fake_core(mode, *, display, stream):
+    if display:
+        trust._box(
+            "EXACTNESS - FRESH RUN",
+            ["Exact rational calculations correct: 2 / 2", "Result: PASS"],
+            stream,
+        )
+        trust._box(
+            "SPEED - FRESH RUN DIRECTLY AGAINST NVIDIA FP16",
+            [
+                "Exact rational faster: 1 / 2  (50.00%)",
+                "NVIDIA FP16 faster:    1 / 2  (50.00%)",
+                "Too close to call:     0 / 2  (0.00%)",
+                "Median speedup when exact wins: 1.400x",
+                "Median speedup including rational bookkeeping: 1.350x",
+            ],
+            stream,
+        )
+        trust._box(
+            "REPRODUCIBILITY",
+            [
+                "Same winner/tie result as original: 2 / 2  (100.00%)",
+                "Validated replay binary SHA-256: " + "a" * 64,
+                "Total elapsed: 00:02",
+            ],
+            stream,
+        )
+    return deepcopy(_result())
+
+
+def test_live_report_is_explicitly_rational(monkeypatch):
+    monkeypatch.setattr(trust, "_core_g4_benchmark", _fake_core)
+    monkeypatch.setattr(trust, "_gpu_state_snapshot", _snapshot)
+    monkeypatch.setattr(trust, "_environment_name", lambda: "Google Colab")
+    monkeypatch.setattr(trust, "_package_version", lambda: "0.11.2")
+    monkeypatch.setattr(trust, "_current_cuda_version", lambda: "12.8")
+    times = iter(["2026-08-09T06:00:00Z", "2026-08-09T06:10:00Z"])
+    monkeypatch.setattr(trust, "_utc_now", lambda: next(times))
+
+    output = StringIO()
+    result = trust.g4_benchmark("full", display=True, stream=output)
+    text = output.getvalue()
+
+    assert result["live_test"] == "G4_RATIONALS_vs_NVIDIA_FP16_cuBLASLt"
+    assert result["summary"]["rational_frozen_decision_matches"] == 2
+    assert "G4 INTEGERS  vs NVIDIA FP16 cuBLASLt" in text
+    assert "G4 RATIONALS vs NVIDIA FP16 cuBLASLt" in text
+    assert "LIVE BENCHMARK BELOW: G4 RATIONALS vs NVIDIA FP16 ONLY." in text
+
+    assert "G4 RATIONALS - EXACTNESS - FRESH RUN" in text
+    assert "G4 rational calculations correct: 2 / 2" in text
+    assert "G4 RATIONALS - SPEED vs NVIDIA FP16 - FRESH RUN" in text
+    assert "G4 RATIONALS faster than NVIDIA FP16: 1 / 2" in text
+    assert "NVIDIA FP16 faster than G4 RATIONALS:" in text
+    assert "G4 RATIONALS / NVIDIA FP16 statistical ties:" in text
+    assert "G4 RATIONALS - REPRODUCIBILITY" in text
+    assert "RATIONAL winner/tie classification matches original RATIONAL benchmark:" in text
+
+    assert "Same winner/tie result as original:" not in text
+    assert "Too close to call:" not in text
+    assert "TRUST PACK - G4 RATIONAL RUN RECEIPT" in text

rns_engine-0.11.2/tests/test_g4_trust.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from io import StringIO
+
+import rns_engine.g4_trust as trust
+
+
+def _fake_result() -> dict:
+    return {
+        "schema": "RNS-ENGINE-G4S1-LIVE-BENCHMARK-2",
+        "series": 1,
+        "campaign": "dynamic_exact_rational_vs_fp16",
+        "mode": "full",
+        "gpu": {
+            "name": "Tesla T4",
+            "compute_capability": "7.5",
+            "driver_version": "580.82.07",
+        },
+        "runtime": {
+            "binary_sha256": "a" * 64,
+            "payload_sha256": "b" * 64,
+            "source_archive_sha256": "c" * 64,
+            "build_nvcc": "Cuda compilation tools, release 12.8, V12.8.93",
+            "config_provenance": {},
+        },
+        "timing_seconds": {
+            "gpu_test": 12.5,
+            "result_verification": 3.0,
+            "total": 15.5,
+        },
+        "summary": {
+            "shapes_run": 2,
+            "runtime_errors": 0,
+            "exact_replay_failures": 0,
+            "live_exact_wins": 1,
+            "live_floating_wins": 1,
+            "live_statistical_ties": 0,
+        },
+        "rows": [
+            {"shape_id": "A", "exact_replay_passed": True, "live_decision": "EXACT_WIN"},
+            {"shape_id": "B", "exact_replay_passed": True, "live_decision": "FLOATING_WIN"},
+        ],
+    }
+
+
+def _snapshot() -> dict:
+    return {
+        "available": True,
+        "pstate": "P0",
+        "temperature_c": "45",
+        "power_w": "38.50",
+        "sm_clock_mhz": "1590",
+        "memory_clock_mhz": "5001",
+    }
+
+
+def test_trust_pack_hashes_all_rows_and_commits_to_receipt():
+    result = _fake_result()
+    pack = trust._make_trust_pack(
+        result,
+        started_utc="2026-08-09T06:00:00Z",
+        completed_utc="2026-08-09T06:10:00Z",
+        environment="Google Colab",
+        package_version="0.11.1",
+        current_cuda="12.8",
+        gpu_before=_snapshot(),
+        gpu_after=_snapshot(),
+    )
+
+    assert pack["schema"] == "RNS-ENGINE-G4S1-TRUST-PACK-1"
+    assert pack["package"]["release_tag"] == "v0.11.1"
+    assert pack["exactness"] == {
+        "rows_exact": 2,
+        "rows_total": 2,
+        "runtime_errors": 0,
+        "exact_replay_failures": 0,
+    }
+    assert len(pack["result_rows_sha256"]) == 64
+    assert len(pack["run_receipt_sha256"]) == 64
+
+    changed = _fake_result()
+    changed["rows"][0]["live_decision"] = "STATISTICAL_TIE"
+    changed_pack = trust._make_trust_pack(
+        changed,
+        started_utc="2026-08-09T06:00:00Z",
+        completed_utc="2026-08-09T06:10:00Z",
+        environment="Google Colab",
+        package_version="0.11.1",
+        current_cuda="12.8",
+        gpu_before=_snapshot(),
+        gpu_after=_snapshot(),
+    )
+    assert changed_pack["result_rows_sha256"] != pack["result_rows_sha256"]
+    assert changed_pack["run_receipt_sha256"] != pack["run_receipt_sha256"]
+
+
+def test_public_wrapper_adds_and_prints_trust_pack(monkeypatch):
+    monkeypatch.setattr(trust, "_core_g4_benchmark", lambda *args, **kwargs: deepcopy(_fake_result()))
+    monkeypatch.setattr(trust, "_gpu_state_snapshot", _snapshot)
+    monkeypatch.setattr(trust, "_environment_name", lambda: "Google Colab")
+    monkeypatch.setattr(trust, "_package_version", lambda: "0.11.1")
+    monkeypatch.setattr(trust, "_current_cuda_version", lambda: "12.8")
+
+    timestamps = iter(["2026-08-09T06:00:00Z", "2026-08-09T06:10:00Z"])
+    monkeypatch.setattr(trust, "_utc_now", lambda: next(timestamps))
+
+    output = StringIO()
+    result = trust.g4_benchmark("full", display=True, stream=output)
+    text = output.getvalue()
+
+    assert "trust_pack" in result
+    assert "TRUST PACK - G4 RATIONAL RUN RECEIPT" in text
+    assert "Environment: Google Colab | rns_engine 0.11.1 | release v0.11.1" in text
+    assert "Replay binary SHA-256:   " + "a" * 64 in text
+    assert "Replay payload SHA-256:  " + "b" * 64 in text
+    assert "Source archive SHA-256:   " + "c" * 64 in text
+    assert result["trust_pack"]["result_rows_sha256"] in text
+    assert result["trust_pack"]["run_receipt_sha256"] in text