acceptodds
Under review as a conference paper at ICLR 2027

From Judge to Verifier: Formally Verified Faithfulness for Evidence-Grounded Generation

Abstract

LLM-as-a-Judge offers no independent trust boundary: the same class of model that may introduce unsupported claims is trusted to detect them. We study claim-level grounding as a checkable criterion: every atomic claim in a generated artifact must be entailed by its upstream evidence. We introduce VerLean, a neurosymbolic verifier in which an LLM translates evidence and claims into a finite-domain model and entailment queries, and a deterministic Lean 4 kernel decides each formalized query. We develop it on a proof-of-concept regulatory-compliance dataset with two transformation tasks (1,624 claims: fact-to-summary and summary-to-requirement), test generalization on 444 public legal summaries, and stress-test on a synthetic benchmark of typed errors from public contracts (5,550 judgments). Across the three settings with a direct LLM-as-a-Judge comparison, VerLean raises F1 (0.747 to 0.917 fact-to-summary, 0.752 to 0.894 summary-to-requirement, 0.806 to 0.943 legal summaries), and on the typed benchmark detects unsupported claims at 0.895 recall and 0.935 F1. Its residual misses trace to neural translation, not the kernel; an ablation attributes the accuracy to the formalization, not the evaluator that reads it. The grounding decision is then a settled, mechanical check. The kernel decides it with no further LLM call, returning identical verdicts across runs. It thus dominates an LLM evaluator, which only matches that accuracy while adding cost and non-reproducible variance (LLM judges disagree on up to 44% of the subtlest errors). Failed queries yield counterexamples that repair more outputs, and sooner, than free-form judge rationales (first-attempt recovery up 4.3–12.9 points, reaching 90.9–97.0% in six attempts). Grounding decisions become reproducible, auditable, and, through their counterexamples, repairable.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
Faithfulness Verification, Neurosymbolic Reasoning, Autoformalization, Formal Verification, Evidence-Grounded Generation, LLM-as-a-Judge

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_BRicOpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes VERLEAN, a inference framework for checking whether claims generated by LLMs are supported by their source evidence. This paper uses an LLM to translate evidence and claims into finite-domain logical representations and Lean 4 checks whether the claims entailed with the formalized evidence. When verification fails, counterexamples are used to guide the model in revising its output. The method is evaluated on regulatory compliance, legal summaries, and synthetic contract data. The results show significant improvements over direct LLM-as-a-Judge baselines.

Critical strengths
  1. Checking whether the claims are entailed with the evidence is really important problem specially in high stake domains and paper motivates it very well.

  2. Results are strong and significant improve over llm as a judge baseline.

  3. Precise feedback using counterexamples is very clever and nice use of formal verification.

Critical weaknesses
  1. The main framework is significantly overlaps with already done work. I am listing those out here and this is my main concern.
    1. Logic-LM and Fover: https://direct.mit.edu/tacl/article/doi/10.1162/TACL.a.41/133797/FoVer-First-Order-Logic-Verification-for-Natural already combines LLM formalization and solves using z3.
    2. VERGE: https://arxiv.org/pdf/2601.20055 is basically clearly similar to what this paper has done but using lean.
    3. This paper does entailement checking: https://arxiv.org/pdf/2602.24111
    4. EG-VAR: https://arxiv.org/pdf/2607.12650 additionally uses Lean 4 for evidence-grounded verification.

Based on these , this paper seems to me an engineering project which combines technology from different papers.

  1. There is no guarantee that NL to LEAN translation is faithful and this part seems to be ignored in the paper entirely.

  2. The formalize then judge performs almost identical to VERLEAN in detection F1. it opens up a question that improvement comes from structured representation than formal checks.

Questions for authors

You can infer from the weaknesses and additional questions are below:

  1. How often do semantically incorrect or vacuous formalizations produce accepted claims, and how can such errors be detected?
  2. What additional practical advantage does the Lean kernel provide over a deterministic finite-domain checker operating on the same formal representation? (I have this question because using lean over SMT is only lean kernels and also , differentiate this paper with the weakness 1)
7 comments

Thank you for your review. We are glad you found the problem "really important" and well motivated. We are also glad you found the results "strong" and the counterexample feedback "very clever". Tasks that cannot be formally verified still rely on LLM judges. VerLean targets that gap in high-stakes settings such as regulatory compliance. One missed unsupported claim can silently change a compliance decision.

Our answers in brief.

  • We agree that turning text into logic for a solver is not new. We cite Logic-LM and have now added the four other works you list. VERGE is the closest of these works in method. It checks answers to logic problems and leaves commonsense and vague claims to a vote of LLM judges. VerLean checks generated documents against the sources they were written from. It accepts a claim only when the exact check passes. It also returns a counterexample when the check fails. VERGE gives no counterexample.
  • We agree that nothing guarantees a faithful translation. The paper says so in Sections 3 and 7. We have now counted the failures in the legal-summary and synthetic-benchmark runs. No query passed because its condition was impossible. Every unsupported claim that VerLean accepts traces to the formalization or to a wrong label. On the synthetic benchmark most of them are dropped conditions or "may" turned into "must".
  • We agree that the accuracy comes mostly from formalizing the evidence and claims. This is the main claim of our paper. A judge that gets VerLean's steps as a checklist closes only about half of the gap. The rest of the gap needs the formalization itself.
  • Any exact checker would give the same verdicts for our checks. We use Lean because it keeps the formalization and its verdict in one typed file. Lean's kernel can also check every query verdict.

In the revision we added the chain-of-thought judge ablation to Section 5.8 (Table 6). Section 5.7 now reports the count of impossible conditions. It also reports the injected errors that VerLean accepts. Section 4.3 now explains what the check adds and why we use Lean. Related Work now includes the four papers.

Weakness 1. Novelty

Here is how the works you list differ from VerLean.

  • Logic-LM and FoVer check reasoning. Logic-LM turns a logic problem into solver input and lets the solver find the answer. FoVer turns a reasoning text into first-order logic and checks it with Z3. Neither checks a generated document against its sources.
  • VERGE works on logic benchmarks such as FOLIO and ProofWriter and splits each answer into atomic claims. An SMT solver checks the logical and mathematical claims. A vote of LLM judges checks the commonsense and vague ones. VERGE then accepts the whole answer if its overall score is high enough. So a claim can pass even when the premises do not imply it. VERGE's feedback names the claims to change. VerLean requires every claim to hold in every case where it applies. Its counterexample also shows the case where a claim fails.
  • The entailment-checking paper you cite (arXiv 2602.24111) is the closest in task. It checks each diagnosis in a radiology report against the findings in the same report. It uses a medical knowledge base and removes the diagnoses that fail. VerLean uses no outside knowledge. It narrows a failing claim to fit the source. It deletes the claim if narrowing cannot fix it.
  • EG-VAR uses Lean 4 to certify numeric answers that follow from tool outputs and abstains on all others. VerLean checks plain-language claims about conditions and obligations. It uses each failure to guide a repair.

None of these works checks generated documents against their own sources at each stage of a multi-stage workflow. We think this setting is new. Table 4 shows how well counterexamples repair claims in this setting.

Our claim to be "the first" was meant to be about the application and not about Lean or any theorem prover. We agree that it was too broad even for the application and removed it in the revision. Automated Reasoning checks (ARc, arXiv 2511.09008) already use an SMT solver to check each claim of a chatbot answer against a policy formalized in advance. They also return scenarios that guide a revision. VerLean instead formalizes the sources of each generated document and checks every claim against only those sources at each stage of a multi-stage workflow. Related Work now cites ARc.

Weakness 2 and your first question. How often does a bad formalization let a claim through?

The paper does not claim that the translation is always faithful. Section 3 says that "end-to-end validity depends on whether the LLM faithfully represents the evidence and claims". Section 7 says that "VerLean's guarantees are relative to its formalization". So we score every verdict against labels instead of trusting the check. A coverage step looks for parts of a claim that the checks leave out. VerLean rejects the claim if such a part has no support in the evidence.

The submitted paper did not report how often the formalization fails. We have now counted two kinds of failure.

We first counted automatic passes from impossible conditions. A condition is impossible when no case satisfies it. The same loop over cases finds such conditions. In the legal-summary run 488 of the 506 queries passed. None of them passed because its condition was impossible. The same holds for all 12,679 queries that passed in the synthetic-benchmark run.

We then counted the unsupported claims that VerLean accepts. The check itself is exact. So each such claim comes from the formalization or from a wrong label. VerLean accepts 29 unsupported legal summaries. These are the misses behind its 90.9% recall in Table 3. On the synthetic benchmark it accepts 186 injected errors. Dropped conditions and "may" turned into "must" (T2 and T4) make up 158 of them.

Bad formalizations can be caught in three ways. One is the cheap test for impossible conditions. Another is to read the Lean file. Any mistake in the formalization is written down there for a person to find and fix. Appendix D.3 shows one such mistake. The third is to let a judge check again what VerLean accepts. On the legal summaries the plain judge rejects 9 of those 29 summaries. It rejects only 5 of the 120 summaries that VerLean accepts correctly.

Weakness 3. Does the gain come from the formalization or from the check?

We agree that the gain comes from the formalization. Formalize-then-judge has an LLM read the formalization and give the verdict itself. It comes within 0.6 F1 points of VerLean on all three datasets (Section 5.8).

A structured prompt alone does not explain the gain. The new chain-of-thought prompt (Appendix A.9) gives the judge the steps in Appendix A.1 to A.5 as a plain checklist. The judge never sees a formalization and uses the same model and settings. We ran this judge on the fact-to-summary claims of one of the jurisdictions in Appendix B.1. We also ran it on all 444 legal summaries in Table 3. The checklist raises F1 by 8.8 and 7.8 points and closes about half of the gap to VerLean. The gap shrinks from 19.5 to 10.7 F1 points on the fact-to-summary claims and from 14.7 to 6.9 on the legal summaries (Table 6).

The exact check still has advantages over an LLM that reads the formalization. This check needs no LLM call. The same formalization always gets the same verdict. And the check gives a counterexample when it fails. The rewriter fixes more claims on the first try with counterexamples than with judge explanations. The gain is 4.3 to 12.9 points in Table 4.

Your second question. What does Lean add over a plain exact checker?

We agree that the check is a loop over a small set of cases. Any exact checker would give the same verdicts for these checks. Even a Python loop would. An SMT solver may also scale better (Section 7). So the difference from the works in Weakness 1 is not Lean versus SMT. We still run the check in Lean for three practical reasons.

  • Lean keeps the formalization and its verdict in one typed file. Anyone can re-run that file.
  • Lean refuses any rule or query that does not type-check. One example is a rule that names an undefined field. VerLean never accepts a claim with such a query. Lean refused 32 such queries in the synthetic-benchmark run.
  • Lean's kernel can check each query verdict itself. We have now done this for the legal-summary run. For each query we added a proof that its verdict equals the #eval result. Lean's kernel accepted all 506 proofs. A reader then needs to trust only the kernel and the short definition of the check.

Thanks again for the review. We are happy to answer follow-up questions.

Reviewer_yZ3jOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

VERLEAN converts evidence and claims into formal models, uses Lean to check whether claims follow from those models, and uses counterexamples to guide corrections. Tests cover compliance tasks, legal summaries, and synthetic contract errors. F1 improves by 13.7–17.0 points over direct LLM judging across the three tasks with comparisons. An LLM reading the same formalization achieves nearly identical F1.

Critical strengths
  • Explicit models and counterexamples make decisions easier to inspect and errors easier to fix. The paper clearly acknowledges that translating text into formal models can introduce mistakes.

  • Detection and repair gains are substantial across several datasets. The ablation usefully compares Lean and an LLM on the same formalized inputs.

Critical weaknesses
  • Kernel-checked verification is not established by the documented implementation. Appendix D.1 obtains verdicts through #eval and says they can be checked with 'decide', without showing that every verdict is proof-checked. Section 3 also acknowledges that impossible query conditions can cause undetected automatic passes, but their frequency is not reported.
  • The comparisons do not isolate formalization’s contribution. VERLEAN uses LLM calls and instructions than the single-pass judge, and both ablation variants share these. A judge matched for computation and instructions is needed. The synthetic benchmark also lacks a judge accuracy baseline, I think.
Questions for authors
  • Does every verdict have a kernel-checked proof, and how often do impossible query conditions cause automatic passes?

  • How does VERLEAN compare with a direct judge given comparable computation and instructions? How consistent are repeated runs of the complete pipeline?

2 comments

Thank you for your review. We are glad you found that explicit models and counterexamples "make decisions easier to inspect and errors easier to fix". We are also glad you found the detection and repair gains "substantial across several datasets". Tasks that cannot be formally verified still rely on LLM judges. VerLean targets that gap in high-stakes settings such as regulatory compliance. One missed unsupported claim can silently change a compliance decision.

Our answers in brief.

  • On the paper's legal-summary run every query verdict now has a kernel-checked proof. We also counted automatic passes from impossible conditions. There were none.
  • We gave the judge VerLean's steps as a chain-of-thought checklist. We ran this new judge as an ablation on the fact-to-summary claims of one jurisdiction and on all 444 legal summaries. It gains 8.8 and 7.8 F1 points but is still 10.7 and 6.9 points behind VerLean.
  • The check decides the verdict without an LLM. So the same formalization always gets the same verdict.

In the revision we added the chain-of-thought judge ablation to Section 5.8 (Table 6). Appendix D.1 now reports the kernel proofs. Section 5.7 now reports the count of impossible conditions.

Weakness 1a and your first question. Does every verdict have a kernel-checked proof?

The submitted paper got each verdict from Lean's #eval command (Appendix D.1). #eval runs the formalization as compiled code and prints true or false. So those verdicts relied on Lean's compiler. A kernel-checked proof relies only on the kernel. The kernel is the small part of Lean that checks every proof.

We have now added such proofs for the legal-summary run. That run turned its 444 summaries into 506 Lean queries. One summary can have several queries or none. For each query we added a proof that its verdict equals the #eval result. Lean's kernel accepted all 506 proofs. So the kernel and #eval agree on every query.

The submitted Appendix D.1 said that the verdicts could be checked with Lean's decide tactic. In practice plain decide stops at a recursion limit in 4 of the formalization files. So we used decide +kernel. It lets the kernel do the whole check. The faster native_decide would rely on the compiler again.

Not every verdict comes from a Lean query. VerLean can reject a summary in two ways. A Lean query can fail. Or the coverage step can find a part of the summary that the queries leave out. The coverage step then asks the LLM for a source sentence that states that part. VerLean rejects the summary if there is none. For 281 of the 295 rejected summaries the coverage step was the only reason. No Lean query fails for those summaries, so the kernel has nothing to prove for their rejections. Every accepted summary passed all its Lean queries.

Weakness 1b and your first question. How often do impossible conditions cause automatic passes?

We counted them. A condition is impossible when no case satisfies it. The same loop over cases finds such conditions. In the legal-summary run 488 of the 506 queries passed. None of them passed because its condition was impossible. The same holds for all 12,679 queries that passed in the synthetic-benchmark run.

Weakness 2a and your second question. A judge matched for instructions and compute

We agree that the plain judge got fewer instructions and fewer calls than VerLean. You note that Formalize-then-judge shares VerLean's calls and instructions. So it does not fix this.

Instead we tested a judge that gets VerLean's instructions. The new chain-of-thought prompt (Appendix A.9) gives the judge the steps in Appendix A.1 to A.5 as a plain checklist. The judge first lists the conditions. Next it says what the evidence supports. Then it splits the claim into parts. Finally it checks that the evidence supports each part. It reasons first and gives the verdict last. The judge sees the same claims and evidence and uses the same model and settings. So the only new part is the checklist.

We ran this judge on the fact-to-summary claims of one of the jurisdictions in Appendix B.1. We also ran it on all 444 legal summaries in Table 3. The checklist raises recall by 13.5 points on both datasets and lowers precision by 4.4 and 2.1 points. On the fact-to-summary claims the judge's precision ends up about the same as VerLean's. On the legal summaries it stays below VerLean's (95.2 against 98.0). The checklist raises F1 by 8.8 and 7.8 points and closes about half of the gap to VerLean. The gap shrinks from 19.5 to 10.7 F1 points on the fact-to-summary claims and from 14.7 to 6.9 on the legal summaries (Table 6).

Weakness 2b. A judge baseline on the synthetic benchmark

The synthetic benchmark tests VerLean itself. We make each wrong claim by adding one error of a known type to a correct claim. Table 5 then shows which types VerLean catches and how often its counterexamples repair them. The comparison with the judge is in Tables 2 and 3. Those tables use real compliance documents and legal summaries with naturally occurring errors.

Your second question. How consistent are repeated runs?

A VerLean verdict comes from two steps that behave differently on a rerun. The check needs no LLM call and its verdict depends only on the formalization. The formalization is an LLM step. A full rerun writes a new formalization that can change the verdict. Two runs of the plain judge with the same inputs and settings disagree on 27 of the 444 legal summaries (6.1%). We have not run VerLean twice on the same summaries. We now say so in the limitations and list it as future work.

Thanks again for the review. We are happy to answer follow-up questions.

Reviewer_gvMVOpenReview ↗
Rating
2(+1)
Confidence
2
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper proposes to use "VerLean" to check whether claims in LLM generations are entailed by their source evidence. The authors try to steer away from LLM-as-a-Judge methods (which they claim can be unreliable, either due to simple randomness/stochasticity of generative LLM judges, or due to some lack in capability). Instead, they propose a verification pipeline that has an LLM rewrite source facts and claims as simple if/else rules over a handful of true/false or multiple-choice variables, that Lean 4 then can verify for consistency. When a claim fails verification, the instances that fail (i.e. where the claim does not hold in the generated truth table) can be used as counterexamples for the LLM to repair the claim.

Critical strengths

In general, verifiable rewards are very useful for establishing correctness and trust in LLM artifacts. There is a gap between tasks that can be formally verified, and those that currently are not (and, e.g., use LLM-as-a-Judge instead). The problem setting that this paper addresses is therefore an important one, and the method that it proposes is reasonable.

Critical weaknesses
  1. I'm not convinced of the need for Lean / theorem proving kernels here. It seems mostly for show. The check is a loop over a small truth table, which a simple python script can do (which the authors also more or less say on L191-192). It also seems to kick the can down the road so to speak, in the sense that its still using LLMs to extract the truth table in the first place (doesn't this suffer from the same problems identified in the introduction?). Most of the "work" is done in this formalization part (Formalize-then-judge, which skips the Lean kernel and just uses an LLM to judge correctness after formalizing, gets mostly the same result). Meanwhile, the LLM-as-a-Judge baseline has no chain-of-thought prompting, so its hard to tell if the gain comes from the several extra LLM calls to break down the evidence or what.

  2. Translating natural-language claims into a symbolic form, and then handing that to a deterministic (and trusted) solver to check is reasonable, but that in itself is not particularly new. Just a few examples, even beyond those already cited in the paper:

  • VeriCoT: Neuro-symbolic Chain-of-Thought Validation via Logical Consistency Checks. Feng et. al. 2026.
  • Fact-Checking Complex Claims with Program-Guided Reasoning. Pan et. al. 2023.
  • Explainable Claim Verification via Knowledge-Grounded Reasoning with Large Language Models. Wang and Shu. 2023.
  • Faithful Logical Reasoning via Symbolic Chain-of-Thought. Xu et. al. 2024.
  • Chain of Code: Reasoning with a Language Model-Augmented Code Emulator. Li et. al. 2024. Per the paper's claim of "the first to verify claim-level grounding of regulatory artifacts with a deterministic theorem-prover kernel"; I think this mainly applies to the application and the choice of Lean, and given the points above, I don't think it is clear that Lean adds much.
  1. I did not find the paper well written or easy to follow at all. It reads mostly like AI slop, and describes what should be fairly simple concepts in very abstract / incomprehensible ways... to name a few:
  • "LLM-as-a-Judge offers no independent trust boundary: the same class of model that may introduce unsupported claims is trusted to detect them."
  • "Its residual misses trace to neural translation, not the kernel; an ablation attributes the accuracy to the formalization, not the evaluator that reads it."
  • "VERLEAN separates semantic translation from entailment checking. The checker is VERLEAN's verification stage that enumerates worlds and evaluates queries, and the trusted Lean 4 kernel deterministically decides each query."
  • "VERLEAN moves neural uncertainty rather than removing it: the LLM carries the semantic translation, but once it is fixed the grounding decision is a settled check the kernel runs deterministically, with no model call and a re-runnable audit trail."
Questions for authors

How does an LLM-as-a-Judge baseline with reasoning/chain-of-thought (and that uses the same decomposition/checklists/coverage prompts in A.1-A.5) compare?

5 comments

Thank you for your review. We are glad you agree that the problem is "an important one" and the method is "reasonable". You note that tasks that cannot be formally verified still rely on LLM judges. VerLean targets that gap in high-stakes settings such as regulatory compliance. One missed unsupported claim can silently change a compliance decision.

So a grounding check must do three things.

  • Catch unsupported claims.
  • Give a verdict that anyone can check.
  • Show where a claim fails.

VerLean is built for all three. It uses the same LLM as the baseline judge. It catches 82.9% to 90.9% of unsupported claims across the three datasets in Tables 2 and 3. The judge catches 60.5% to 73.0%.

Our answers in brief.

  • The original judge already had Opus 4.8's extended thinking turned on. Its prompt (Appendix A.7) also asked it to check every assertion. It lacked an explicit chain-of-thought prompt. We added one as you asked. We ran this new judge as an ablation on the fact-to-summary claims of one jurisdiction and on all 444 legal summaries. It gains 8.8 and 7.8 F1 points but is still 10.7 and 6.9 points behind VerLean.
  • We agree that the accuracy comes mostly from formalizing the evidence and claims. This is the main claim of our paper. We also agree that turning text into logic for a solver is not new. And we agree that the sentences you quote were too abstract.
  • We disagree that the Lean check is for show. The check decides the verdict without an LLM. So the same formalization always gets the same verdict. The check's counterexamples also help fix bad claims (Table 4).
  • We also disagree that the LLM step has the same problem as a judge. Both can make mistakes. But a mistake in the formalization is written down in the Lean file. A person can find it there and fix it. A judge writes down only its verdict and a short explanation. So its mistake is hard to find or fix.

In the revision we added the chain-of-thought judge ablation to Section 5.8 (Table 6). Section 5.3 now states the judge's settings. Section 4.3 now explains what the check adds and why we use Lean. Related Work now includes the five papers. We also rewrote the unclear sentences.

Paper summary

Your summary describes "simple if/else rules over a handful of true/false or multiple-choice variables". This leaves out how strict the check is and what the rules can return.

  • A claim must hold in every case where it applies.
  • A coverage step looks for parts of a claim that the checks leave out. VerLean rejects the claim if such a part has no support in the evidence.

The two together reject a claim that adds something the evidence never says. This holds even if nothing contradicts the claim. Table 5 shows that VerLean catches 99.7% of such claims.

The rules can also return more than true or false. A rule can return a number such as a tax rate, a threshold or a time limit in days. VerLean catches 97.3% of claims that change such a number (Table 5). A rule can also return a category such as which law applies or which form to file.

Weakness 1a. Is the Lean check for show?

Section 5.8 tests where the accuracy comes from. Formalize-then-judge has an LLM read the formalization and give the verdict itself. You note that it gets mostly the same result. It comes within 0.6 F1 points of VerLean on all three datasets.

But we disagree that the check is for show. What matters is that an exact check decides the verdict. This check needs no LLM call. The same formalization always gets the same verdict. And the check gives a counterexample when it fails. The claim in Appendix D.2 leaves out "only after the initial three-year term". The check then fails on the case where that term has not ended. That tells the rewriter what to add back. The rewriter fixes more claims on the first try with counterexamples than with judge explanations. The gain is 4.3 to 12.9 points in Table 4.

We agree that the check is a loop over a small set of cases. Any exact checker would give the same verdicts for these checks. Even a Python loop would. We use Lean because it keeps the formalization and its verdict in one typed file. Anyone can re-run that file.

Weakness 1b. Does the LLM step kick the can down the road?

Partly. A wrong formalization of the evidence or the claim can lead to a wrong verdict. Our misses come from this step. Most of them are dropped conditions or "may" turned into "must" (types T2 and T4 in Table 5).

You ask whether this has the same problem as the LLM judges in our introduction. We think it does not. The two fail in different ways. A wrong judge shows you only a wrong verdict and a short explanation. A wrong VerLean verdict comes from a mistake in the formalization.

Appendix D.3 shows one such mistake. The source says a trademark is "not required" on the packaging. The claim says it "must not appear" there. The LLM formalized both the same way. So VerLean missed the error. Anyone reading the formalization can see why.

Weakness 1c and your question. A judge with chain-of-thought

The new chain-of-thought prompt (Appendix A.9) gives the judge the steps in Appendix A.1 to A.5 as a plain checklist. The judge first lists the conditions. Next it says what the evidence supports. Then it splits the claim into parts. Finally it checks that the evidence supports each part. It reasons first and gives the verdict last. The judge sees the same claims and evidence and uses the same model and settings. So the only new part is the checklist.

We ran this judge on the fact-to-summary claims of one of the jurisdictions in Appendix B.1. We also ran it on all 444 legal summaries in Table 3. The checklist raises recall by 13.5 points on both datasets and lowers precision by 4.4 and 2.1 points. On the fact-to-summary claims the judge's precision ends up about the same as VerLean's. On the legal summaries it stays below VerLean's (95.2 against 98.0). The checklist raises F1 by 8.8 and 7.8 points and closes about half of the gap to VerLean. The gap shrinks from 19.5 to 10.7 F1 points on the fact-to-summary claims and from 14.7 to 6.9 on the legal summaries (Table 6).

Weakness 2. Novelty

We cite Logic-LM and LINC and have now added the five papers you list. A language model still does some of the reasoning in ProgramFC, Wang & Shu, SymbCoT and Chain of Code. So an exact check does not decide their outputs. VeriCoT is the closest of the five. It appeared at ICLR 2026. It checks the reasoning steps behind an answer and can also use common-sense facts. We instead check each claim in a generated document against only its own sources at each stage of a multi-stage workflow. We then use the failing case to fix the claim. We think this setting is new. Table 4 shows how well counterexamples repair claims in this setting.

Our claim to be "the first" was meant to be about the application and not about Lean or any theorem prover. We agree that it was too broad even for the application and removed it in the revision. Automated Reasoning checks (ARc, arXiv 2511.09008) already use an SMT solver to check each claim of a chatbot answer against a policy formalized in advance. They also return scenarios that guide a revision. VerLean instead formalizes the sources of each generated document and checks every claim against only those sources at each stage of a multi-stage workflow. Related Work now cites ARc.

Weakness 3. Writing

We rewrote the four sentences you quote in the revision.

  • "no independent trust boundary..." becomes "Trust in artifacts generated by large language models (LLMs) often rests on another LLM acting as a judge, but the judge can make the same mistakes as the generator."
  • "residual misses trace to neural translation..." becomes "An ablation traces the gain to the formalization."
  • "separates semantic translation from entailment checking..." becomes "VerLean decides in two steps whether the evidence entails a claim. First, an LLM maps the evidence to a finite-domain semantic model and each claim to condition-conclusion queries. Lean then checks each query in every world of that model. We call this stage the checker, and Lean's trusted core the kernel."
  • "moves neural uncertainty rather than removing it..." becomes "The LLM can still make mistakes when it formalizes the evidence and the claim. Once the formalization is written, however, the check needs no LLM, and anyone who re-runs it gets the same answer."

We also rewrote similar passages in the abstract, the introduction, the conclusion and Sections 4.1, 5.8 and 7.

Thanks again for the review. We are happy to answer follow-up questions.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Rebuttal Summary

Summary of our responses to all reviewers

We thank the three reviewers. Reviewers gvMV and BRic see the problem as important. Reviewers yZ3j and BRic note substantial gains and useful counterexample feedback. VerLean is meant for high-stakes compliance work. VerLean and the judge use the same LLM. VerLean's recall in Tables 2 and 3 is 82.9% to 90.9% against the judge's 60.5% to 73.0%.

Points raised by more than one reviewer

All three reviewers ask what drives the gain over the judge. We agree that the formalization does most of the work. That is the paper's main claim. A chain-of-thought judge prompted with VerLean's steps closes about half the gap. It still trails VerLean by 10.7 F1 points on one jurisdiction's fact-to-summary claims and by 6.9 on the 444 legal summaries.

Reviewers gvMV and BRic ask what the Lean check adds. Each query verdict comes from exact evaluation without an LLM. So a given formalization has exactly one verdict. Failed checks also return counterexamples that help the rewriter (Table 4). We grant that a plain exact checker would reach the same verdicts. We use Lean because it puts the whole check in one typed file that anyone can re-run. It also rejects ill-typed rules and lets the kernel check query verdicts.

All three reviewers ask about errors in the LLM formalization. We agree that it can be wrong and Sections 3 and 7 already say so. We counted passes caused by impossible conditions in the legal-summary and synthetic runs and found none. Each wrongly accepted claim traces to a formalization or labeling error. Most of the synthetic ones drop a condition or strengthen "may" to "must". Such a mistake stays visible in the Lean file for anyone to fix. A judge's mistake leaves no such record.

Reviewers gvMV and BRic point to related work. We do not claim that solver checks on formalized text are new. At every stage of a multi-stage workflow we test whether each generated claim follows from its own sources. We believe the setting is the new part. Automated Reasoning checks (ARc, arXiv 2511.09008) come close to this setting, but they check every chatbot answer against one policy that they formalize ahead of time. The revision cites ARc and drops our claim to be "the first".

Points raised by one reviewer

Reviewer gvMV asks for a judge that reasons. The paper's judge already used extended thinking without an explicit chain-of-thought prompt. We also show that the check is stricter than simple if/else rules suggest. Our reply rewrites the four sentences that gvMV finds too abstract.

Reviewer yZ3j asks about kernel proofs, the synthetic benchmark and repeated runs. Lean's kernel proved all 506 query verdicts of the paper's legal-summary run. The coverage step alone rejected 281 legal summaries, so those rejections have no proof. Table 5 studies VerLean's errors by type. The judge comparison uses the real errors of Tables 2 and 3. Two runs of the plain judge differ on 6.1% of the legal summaries. VerLean's formalization is also written by an LLM, so a full rerun can produce a different formalization and change some verdicts. We did not run VerLean twice. Measuring how often this happens is future work.

Reviewer BRic compares VerLean with VERGE and asks how often bad formalizations get through. VERGE settles vague and commonsense claims by a vote of LLM judges. VerLean never accepts a claim that fails the exact check. It still wrongly accepts 29 legal summaries and 186 synthetic errors.

Changes in the revision

The revised PDF shows new and changed text in blue.

  • The introduction no longer claims to be "the first" and ARc is in Related Work.
  • Section 4.3 justifies the exact check and the choice of Lean.
  • Section 5.3 notes that the original judge already used extended thinking.
  • Section 5.7 reports the impossible-condition count and the synthetic errors that VerLean wrongly accepts.
  • Section 5.8 adds the chain-of-thought judge (Table 6) and Appendix A.9 gives its prompt.
  • Related Work adds the nine papers that gvMV and BRic list.
  • The limitations note that full VerLean reruns were not measured.
  • Appendix D.1 describes the kernel check of all 506 legal-summary query verdicts.
  • Unclear passages now use plain wording.

Further questions are welcome.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.