- 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
-
Checking whether the claims are entailed with the evidence is really important problem specially in high stake domains and paper motivates it very well.
-
Results are strong and significant improve over llm as a judge baseline.
-
Precise feedback using counterexamples is very clever and nice use of formal verification.
Critical weaknesses
- The main framework is significantly overlaps with already done work. I am listing those out here and this is my main concern.
- 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.
- VERGE: https://arxiv.org/pdf/2601.20055 is basically clearly similar to what this paper has done but using lean.
- This paper does entailement checking: https://arxiv.org/pdf/2602.24111
- 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.
-
There is no guarantee that NL to LEAN translation is faithful and this part seems to be ignored in the paper entirely.
-
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:
- How often do semantically incorrect or vacuous formalizations produce accepted claims, and how can such errors be detected?
- 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
Details
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.
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.
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.