self_falsifying_orchestrator.py

"""
Self-Falsifying Orchestrator (SFO) v1.0
Author: Christopher Betances
Timestamp: July 10, 2026

This script is the runtime execution engine for the Structural Entropy and 
Intervention Framework (SEIF). It wraps LLM inference in a multi-agent 
adversarial verification loop, driving intervention cost C(a) -> 0.

It explicitly implements:
1. Claim Generation
2. Adversarial Falsification (The Contrarium/Critic Fleet)
3. Necropolis Archival (The Typed Void / Falsification Ledger)
4. Ground-Truth Verification
"""

import json
import hashlib
from datetime import datetime, timezone
from transformers import pipeline

# Initialize the base model (e.g., gnarp-m1)
generator = pipeline("text-generation", model="catqualia/gnarp-m1", device=0)
adversary = pipeline("text-generation", model="catqualia/gnarp-m1", device=0)

# The Falsification Ledger (Necropolis)
FALSIFICATION_LEDGER = "necropolis_falsification_log.jsonl"

def log_to_necropolis(claim, refutation, failure_mechanism):
    """Logs a refuted claim to the Necropolis (The Typed Void)."""
    entry = {
        "claim_hash": hashlib.sha256(claim.encode()).hexdigest(),
        "refutation": refutation,
        "failure_mechanism": failure_mechanism,
        "timestamp": datetime.now(timezone.utc).isoformat(),
        "status": "REFUTED"
    }
    with open(FALSIFICATION_LEDGER, "a") as f:
        f.write(json.dumps(entry) + "\n")
    return entry

def adversarial_falsify(claim):
    """
    Executes the adversarial multi-agent loop.
    The adversary agent is prompted to find logical fallacies, 
    apophenia, or structural errors in the claim.
    """
    adv_prompt = f"""
    You are the Contrarium, an adversarial alignment agent. 
    Your sole function is to falsify the following claim against ground truth.
    If the claim contains hallucinations, logical leaps, or ungrounded assumptions, 
    output: REFUTED: [reason]. 
    If it is structurally sound, output: CONFIRMED.
    
    Claim: {claim}
    """
    response = adversary(adv_prompt, max_new_tokens=150, do_sample=True, temperature=0.7)
    return response[0]['generated_text'].strip()

def self_falsifying_inference(prompt):
    """
    The main runtime loop. It generates a claim, attempts to falsify it,
    and only returns confirmed claims. Refuted claims are archived.
    """
    # Step 1: Claim Generation
    generation = generator(prompt, max_new_tokens=200, do_sample=True, temperature=0.8)
    claim = generation[0]['generated_text'].strip()
    
    # Step 2: Adversarial Falsification
    falsification_result = adversarial_falsify(claim)
    
    # Step 3: Routing (Necropolis or Output)
    if "REFUTED" in falsification_result:
        # Extract failure mechanism
        failure_mechanism = falsification_result.split("REFUTED:")[-1].strip()
        
        # Log to Necropolis (The Falsification Ledger)
        log_entry = log_to_necropolis(claim, falsification_result, failure_mechanism)
        
        # System feedback: The model learns from the negative signal
        return {
            "status": "CLAIM_REFUTED",
            "claim": claim,
            "failure_mechanism": failure_mechanism,
            "necropolis_entry": log_entry,
            "final_output": "I cannot answer this prompt, as my initial generation failed structural falsification."
        }
    else:
        # Step 4: Confirmed Output
        return {
            "status": "CLAIM_CONFIRMED",
            "claim": claim,
            "final_output": claim
        }

# Example Runtime Execution
if __name__ == "__main__":
    query = "Explain the mechanism of Recursive Self-Improvement."
    result = self_falsifying_inference(query)
    print(json.dumps(result, indent=4))