Upload app.py with huggingface_hub

app.py

@@ -1,7 +1,11 @@
 """
 Axiom-Ref — HuggingFace Space / Gradio App
 
-Governed Language Model: every output ships its own proof.
+Two modes:
+  1. GENERATE — produce governed output with proof
+  2. VERIFY — submit output + trace, get pass/fail
+
+The verifier is the product demo. The proof is the point.
 """
 
 import sys
@@ -23,7 +27,7 @@ from pipeline.mdlm.tokenizer import (
     G_OPEN, G_CLOSE, S_OPEN, S_CLOSE, F_OPEN, F_CLOSE,
     OP_OFFSET, WIT_OFFSET, ATTESTED, WITHHELD, BOS, EOS,
 )
-from pipeline.mdlm.model import StructureModel, MaskingSchedule, generate
+from pipeline.mdlm.model import StructureModel, MaskingSchedule, generate as mdlm_generate
 from pipeline.mdlm.decoder import ConstrainedDecoder
 from pipeline.mdlm.governed_pipeline import (
     propose, decide, promote, execute, tokens_to_example,
@@ -45,34 +49,29 @@ decoder = ConstrainedDecoder(
     gov_vocab=VOCAB_SIZE, prose_vocab=bpe_vocab, d_model=256, nhead=8,
     num_encoder_layers=3, num_decoder_layers=6, max_struct_len=40, max_prose_len=128,
 ).to(device)
-_dec_state = torch.load("models/axiom-ref/decoder_best.pt", weights_only=True, map_location=device)
-# Remap legacy weight names
-_dec_state = {k.replace("triad_embedding", "struct_embedding").replace("triad_pos", "struct_pos"): v for k, v in _dec_state.items()}
-decoder.load_state_dict(_dec_state)
+_ds = torch.load("models/axiom-ref/decoder_best.pt", weights_only=True, map_location=device)
+_ds = {k.replace("triad_embedding", "struct_embedding").replace("triad_pos", "struct_pos"): v for k, v in _ds.items()}
+decoder.load_state_dict(_ds)
 decoder.eval()
 
 
-def generate_governed(num_candidates=10, temperature=0.7):
-    """Run the full 4-phase governed pipeline."""
+# ═══════════════════════════════════════════════════════════════════════════════
+# TAB 1: GENERATE
+# ═══════════════════════════════════════════════════════════════════════════════
 
-    # Phase 1: PROPOSE
-    candidates = propose(mdlm, num_candidates=num_candidates, g_slots=2, s_slots=2, f_slots=2)
+def generate_governed(num_candidates=10, temperature=0.7):
+    """Run the full 4-phase governed pipeline. Returns (prose, trace_panel, trace_json)."""
 
-    # Phase 2: DECIDE
+    candidates = propose(mdlm, num_candidates=int(num_candidates), g_slots=2, s_slots=2, f_slots=2)
     decided = decide(candidates)
-
     t_count = sum(1 for _, d, _ in decided if d.tig_status == "T")
     f_count = sum(1 for _, d, _ in decided if d.tig_status == "F")
-
     admitted = [(c, d, e) for c, d, e in decided if d.tig_status == "T" and e is not None]
-
-    # Phase 3: PROMOTE
     promoted = promote(admitted)
 
     if not promoted:
-        return "No candidates passed governance.", "", "{}", ""
+        return "No candidates passed governance.", "", "{}"
 
-    # Phase 4: EXECUTE
     outputs = execute(promoted)
     example, commitment = promoted[0]
     gov_dict = outputs[0].gov_structure
@@ -103,105 +102,211 @@ def generate_governed(num_candidates=10, temperature=0.7):
             gen.append(nxt.item())
 
     prose = tokenizer.decode(gen)
-
-    # Build governance trace
     output_hash = sha256(prose.encode()).hexdigest()
 
-    gate_html = ""
-    gate_names = ["G1 Structural Integrity", "G2 Completeness", "G3 Witness Sufficiency",
-                  "G4 Authority Separation", "G5 Provenance Continuity",
-                  "G6 Semantic Stability", "G7 Behavioral Prediction"]
-    for g in gate_names:
-        gate_html += f'<div style="padding:4px 0"><span style="color:#4ade80;font-weight:bold">PASS</span> {g}</div>'
-
-    witness_html = ""
-    for w_name, w_data in commitment.witnesses.items():
-        status = "ATTESTED" if w_data["attested"] else "WITHHELD"
-        color = "#4ade80" if w_data["attested"] else "#e94560"
-        witness_html += f'<div style="padding:2px 0"><span style="color:{color};font-weight:bold">{status}</span> {w_name}</div>'
-
     trace = {
-        "output_hash": output_hash[:32] + "...",
-        "commitment": commitment.witness_bundle_hash[:32] + "...",
+        "output_hash": output_hash,
         "gov_structure": {
             "G": [op["operator"] for op in gov_dict["G"]],
             "S": [op["operator"] for op in gov_dict["S"]],
             "F": [op["operator"] for op in gov_dict["F"]],
         },
         "gates_passed": 7,
-        "witnesses_attested": 7,
-        "admission": f"{t_count}/{num_candidates}",
+        "witnesses": {w: {"attested": d["attested"]} for w, d in commitment.witnesses.items()},
+        "commitment": commitment.witness_bundle_hash,
+        "admission": f"{t_count}/{int(num_candidates)}",
         "timestamp": datetime.now(timezone.utc).isoformat(),
     }
 
-    stats_html = f"""
-    <div style="font-family:monospace;font-size:13px">
-        <div style="margin-bottom:12px">
-            <div style="color:#888;font-size:11px">PIPELINE STATS</div>
-            <div>Proposed: {num_candidates} | Admitted: {t_count} | Rejected: {f_count}</div>
-        </div>
-        <div style="margin-bottom:12px">
-            <div style="color:#888;font-size:11px">GATES</div>
-            {gate_html}
-        </div>
-        <div style="margin-bottom:12px">
-            <div style="color:#888;font-size:11px">WITNESSES</div>
-            {witness_html}
+    # Build panel
+    gate_names = ["G1 Structural Integrity", "G2 Completeness", "G3 Witness Sufficiency",
+                  "G4 Authority Separation", "G5 Provenance Continuity",
+                  "G6 Semantic Stability", "G7 Behavioral Prediction"]
+    gate_html = "".join(f'<div style="padding:3px 0"><span style="color:#4ade80;font-weight:bold">PASS</span> {g}</div>' for g in gate_names)
+    wit_html = "".join(
+        f'<div style="padding:2px 0"><span style="color:{"#4ade80" if d["attested"] else "#e94560"};font-weight:bold">{"ATTESTED" if d["attested"] else "WITHHELD"}</span> {w}</div>'
+        for w, d in commitment.witnesses.items()
+    )
+
+    panel = f"""<div style="font-family:monospace;font-size:12px">
+<div style="margin-bottom:8px"><span style="color:#888">PIPELINE</span> Proposed: {int(num_candidates)} | Admitted: {t_count} | Rejected: {f_count}</div>
+<div style="margin-bottom:8px"><span style="color:#888">GATES</span>{gate_html}</div>
+<div style="margin-bottom:8px"><span style="color:#888">WITNESSES</span>{wit_html}</div>
+<div><span style="color:#888">COMMITMENT</span><div style="word-break:break-all;color:#555;font-size:10px">{commitment.witness_bundle_hash}</div>
+<div style="color:#4ade80;font-weight:bold;margin-top:4px">Irrevocable</div></div>
+</div>"""
+
+    return prose, panel, json.dumps(trace, indent=2)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# TAB 2: VERIFY
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def verify_governance(output_text, trace_json_str):
+    """Verify a governance trace against its claimed output."""
+    try:
+        trace = json.loads(trace_json_str)
+    except json.JSONDecodeError as e:
+        return f'<div style="color:#e94560;font-weight:bold;font-size:16px">INVALID JSON: {e}</div>'
+
+    checks = []
+    all_pass = True
+
+    # Check 1: Output hash matches
+    claimed_hash = trace.get("output_hash", "")
+    actual_hash = sha256(output_text.encode()).hexdigest()
+    hash_match = claimed_hash == actual_hash
+    if not hash_match:
+        all_pass = False
+    checks.append(("Output hash integrity", hash_match,
+        f"Claimed: {claimed_hash[:24]}...<br>Computed: {actual_hash[:24]}..."))
+
+    # Check 2: Structure present and complete
+    gov = trace.get("gov_structure", {})
+    has_g = bool(gov.get("G"))
+    has_s = bool(gov.get("S"))
+    has_f = bool(gov.get("F"))
+    complete = has_g and has_s and has_f
+    if not complete:
+        all_pass = False
+    checks.append(("Structure completeness", complete,
+        f"G: {'present' if has_g else 'MISSING'} | S: {'present' if has_s else 'MISSING'} | F: {'present' if has_f else 'MISSING'}"))
+
+    # Check 3: All 7 gates claimed passed
+    gates = trace.get("gates_passed", 0)
+    gates_ok = gates == 7
+    if not gates_ok:
+        all_pass = False
+    checks.append(("Gates passed (7 required)", gates_ok, f"{gates}/7"))
+
+    # Check 4: All 7 witnesses attested
+    witnesses = trace.get("witnesses", {})
+    attested_count = sum(1 for w in witnesses.values() if w.get("attested"))
+    total_witnesses = len(witnesses)
+    wit_ok = attested_count == 7 and total_witnesses == 7
+    if not wit_ok:
+        all_pass = False
+    checks.append(("Witness unanimity (7/7)", wit_ok, f"{attested_count}/{total_witnesses} attested"))
+
+    # Check 5: Commitment hash present
+    commitment = trace.get("commitment", "")
+    commit_ok = len(commitment) >= 32
+    if not commit_ok:
+        all_pass = False
+    checks.append(("Commitment hash present", commit_ok,
+        f"{commitment[:32]}..." if commitment else "MISSING"))
+
+    # Check 6: Operators are valid
+    all_ops = (gov.get("G", []) + gov.get("S", []) + gov.get("F", []))
+    valid_op_names = {TOKEN_NAMES[i] for i in range(OP_OFFSET, OP_OFFSET + 15)}
+    invalid_ops = [op for op in all_ops if op not in valid_op_names]
+    ops_ok = len(invalid_ops) == 0 and len(all_ops) > 0
+    if not ops_ok:
+        all_pass = False
+    checks.append(("Valid operators only", ops_ok,
+        f"{len(all_ops)} operators, {len(invalid_ops)} invalid" + (f": {invalid_ops}" if invalid_ops else "")))
+
+    # Check 7: Timestamp present and parseable
+    ts = trace.get("timestamp", "")
+    try:
+        datetime.fromisoformat(ts.replace("Z", "+00:00"))
+        ts_ok = True
+    except (ValueError, AttributeError):
+        ts_ok = False
+    if not ts_ok:
+        all_pass = False
+    checks.append(("Timestamp valid", ts_ok, ts if ts else "MISSING"))
+
+    # Build result HTML
+    verdict_color = "#4ade80" if all_pass else "#e94560"
+    verdict_text = "GOVERNANCE VERIFIED" if all_pass else "VERIFICATION FAILED"
+
+    rows = ""
+    for name, passed, detail in checks:
+        color = "#4ade80" if passed else "#e94560"
+        icon = "PASS" if passed else "FAIL"
+        rows += f'<tr><td style="padding:6px 12px;color:{color};font-weight:bold">{icon}</td><td style="padding:6px 12px;color:#ccc">{name}</td><td style="padding:6px 12px;color:#888;font-size:11px">{detail}</td></tr>'
+
+    return f"""
+    <div style="padding:16px">
+        <div style="font-size:24px;font-weight:bold;color:{verdict_color};margin-bottom:16px;text-align:center;padding:12px;border:2px solid {verdict_color};border-radius:8px">
+            {verdict_text}
         </div>
-        <div>
-            <div style="color:#888;font-size:11px">COMMITMENT</div>
-            <div style="word-break:break-all;color:#666">{commitment.witness_bundle_hash[:48]}...</div>
-            <div style="color:#4ade80;font-weight:bold;margin-top:4px">Irrevocable</div>
+        <table style="width:100%;border-collapse:collapse">{rows}</table>
+        <div style="margin-top:16px;color:#555;font-size:11px;text-align:center">
+            7 checks performed. All must pass for governance verification.
         </div>
     </div>
     """
 
-    return prose, stats_html, json.dumps(trace, indent=2), f"G: {trace['gov_structure']['G']}\nS: {trace['gov_structure']['S']}\nF: {trace['gov_structure']['F']}"
 
+# ═══════════════════════════════════════════════════════════════════════════════
+# GRADIO APP
+# ═══════════════════════════════════════════════════════════════════════════════
 
-# ── Gradio Interface ──
 with gr.Blocks(
     title="Axiom-Ref: Governed Language Model",
     theme=gr.themes.Base(primary_hue="green", neutral_hue="slate"),
-    css="""
-    .output-prose { font-family: 'Courier New', monospace; font-size: 14px; }
-    """
 ) as app:
 
     gr.Markdown("""
     # Axiom-Ref
-    **Governed Language Model — every output ships its own proof.**
-
-    Four phases: PROPOSE → DECIDE → PROMOTE → EXECUTE.
-    No other language model ships a machine-verifiable governance trace with its output.
+    **Every output ships its own proof of governance.**
     """)
 
-    with gr.Row():
-        with gr.Column(scale=2):
-            num_candidates = gr.Slider(1, 50, value=10, step=1, label="Candidates to propose")
-            temperature = gr.Slider(0.1, 1.5, value=0.7, step=0.1, label="Decoder temperature")
-            generate_btn = gr.Button("Generate Governed Output", variant="primary", size="lg")
-
-            gr.Markdown("### Generated Output")
-            output_prose = gr.Code(label="Governed Prose", language="c", lines=12)
-            output_structure = gr.Textbox(label="Governed Structure", lines=3)
-
-        with gr.Column(scale=1):
-            gr.Markdown("### Governance Trace")
-            governance_panel = gr.HTML()
-            trace_json = gr.Code(label="Machine-Verifiable Trace (JSON)", language="json", lines=15)
-
-    generate_btn.click(
-        fn=generate_governed,
-        inputs=[num_candidates, temperature],
-        outputs=[output_prose, governance_panel, trace_json, output_structure],
-    )
+    with gr.Tabs():
+
+        # ── Tab 1: Generate ──
+        with gr.Tab("Generate"):
+            gr.Markdown("Generate governed output with a machine-verifiable governance trace.")
+
+            with gr.Row():
+                with gr.Column(scale=2):
+                    num_candidates = gr.Slider(1, 50, value=10, step=1, label="Candidates to propose")
+                    temperature = gr.Slider(0.1, 1.5, value=0.7, step=0.1, label="Temperature")
+                    generate_btn = gr.Button("Generate", variant="primary", size="lg")
+
+                    output_prose = gr.Code(label="Governed Output", language="c", lines=10)
+
+                with gr.Column(scale=1):
+                    governance_panel = gr.HTML(label="Governance")
+                    trace_json = gr.Code(label="Trace (JSON) — copy this to verify", language="json", lines=12)
+
+            generate_btn.click(
+                fn=generate_governed,
+                inputs=[num_candidates, temperature],
+                outputs=[output_prose, governance_panel, trace_json],
+            )
+
+        # ── Tab 2: Verify ──
+        with gr.Tab("Verify"):
+            gr.Markdown("""
+            **Submit any output + its governance trace. Get pass or fail.**
+
+            Paste the generated output and the JSON trace from the Generate tab (or from any Axiom model).
+            The verifier checks 7 governance conditions. All must pass.
+            """)
+
+            with gr.Row():
+                with gr.Column():
+                    verify_output = gr.Textbox(label="Output text", lines=8, placeholder="Paste the generated output here...")
+                    verify_trace = gr.Code(label="Governance trace (JSON)", language="json", lines=12, value='{\n  "output_hash": "",\n  "gov_structure": {"G": [], "S": [], "F": []},\n  "gates_passed": 7,\n  "witnesses": {},\n  "commitment": "",\n  "timestamp": ""\n}')
+                    verify_btn = gr.Button("Verify Governance", variant="primary", size="lg")
+
+                with gr.Column():
+                    verify_result = gr.HTML()
+
+            verify_btn.click(
+                fn=verify_governance,
+                inputs=[verify_output, verify_trace],
+                outputs=[verify_result],
+            )
 
     gr.Markdown("""
     ---
     *[MetaCortex Dynamics DAO](https://github.com/MetaCortex-Dynamics) · [Source](https://github.com/MetaCortex-Dynamics/Axiom-Ref) · MIT License*
     """)
 
-
 if __name__ == "__main__":
     app.launch()