Theoria: Rewrite-Acceptability Verification over Informal Reasoning States
arXiv:2607.01223v1 Announce Type: new Abstract: When should an AI system's answer be trusted? Formal proof assistants offer certainty but cannot reach most of the problem distribution; scalar LLM judges offer coverage but produce opaque scores that cannot be audited after the fact and are subject...
Theoria: Bridging the Trust Gap Between Formal Proofs and LLM Judgments
The paper introduces Theoria, a framework that addresses a fundamental tension in AI verification: formal proof assistants provide mathematical certainty but are too brittle and expensive for most real-world problems, while LLM-based judges offer broad coverage but produce unverifiable, opaque scores. Theoria proposes a middle ground—"rewrite-acceptability verification over informal reasoning states"—meaning it evaluates whether an AI's reasoning can be rewritten into a form that a human (or another system) would accept as valid, without requiring full formal proof.
This is not another attempt to make LLMs generate formal proofs. Instead, Theoria treats the AI's natural language reasoning as a candidate that must pass through a verification layer: can this chain of thought be reconstructed into a coherent, auditable argument? The key innovation is that verification happens over informal reasoning states—the messy, human-readable steps an LLM produces—rather than requiring translation into a formal language like Lean or Coq. This preserves coverage while introducing a mechanism for post-hoc auditability.
Why This Matters
The AI industry is currently caught between two inadequate trust mechanisms. On one side, formal verification tools (like those used in critical systems) demand structured inputs and cannot scale to open-ended tasks. On the other, LLM-as-judge approaches produce a single confidence score that tells you nothing about why an answer might be wrong. Theoria's approach is significant because it creates an intermediate category: verifiable informal reasoning. This allows practitioners to audit an AI's logic after the fact without requiring formal proof expertise.
The implications are particularly acute for regulated industries—healthcare, legal, finance—where decisions must be explainable and contestable. A scalar "trust score" from an LLM judge is insufficient for regulatory compliance; Theoria's rewrite-acceptability verification provides a structured artifact that can be reviewed by human auditors.
Implications for AI Practitioners
First, Theoria suggests a shift in evaluation strategy: instead of asking "is this answer correct?", practitioners should ask "can this reasoning be acceptably rewritten?" This changes how we design prompts and chain-of-thought pipelines—prioritizing reasoning that is reconstructible over reasoning that is merely plausible.
Second, the framework implies a new role for human-in-the-loop systems. Rather than having humans verify every output, Theoria allows humans to verify the rewriteability of reasoning states, which is a more tractable task. This could reduce the cost of human oversight by an order of magnitude.
Third, for teams building LLM-based agents, Theoria points toward a verification layer that sits between the model's output and the downstream action. This layer would reject outputs whose reasoning cannot be acceptably rewritten, effectively creating a safety filter that is more robust than perplexity-based or sentiment-based checks.
Key Takeaways
- Theoria introduces a verification paradigm that sits between formal proofs and scalar LLM judges, enabling auditability without sacrificing coverage
- The framework evaluates whether an AI's reasoning can be reconstructed into an acceptable form, not whether it is formally correct
- For practitioners, this means prioritizing "reconstructible reasoning" in prompt design and building verification layers that check for rewrite-acceptability before acting on LLM outputs
- The approach is particularly relevant for regulated domains where explainability and post-hoc auditability are non-negotiable requirements