- Rating
- 1
- Confidence
- 4
- Informativeness
- 1
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper looks at the problem of auto-formalizing SMT models from technical manuals using LLMs. This is generally considered a very hard problem, specifically due to the lack of ground-truth formal models. Natural language is fairly ambiguous, and because of that, the same piece of natural language can be represented in many different ways in SMT. The authors argue that simply using an SMT solver to check if the model is satisfiable is not enough. The authors call this problem of removing constraints to make it satisfiable "solver gaming." They propose a pipeline that extracts what they call a partially observable hybrid automaton (POHA) and uses an SMT solver to identify inconsistencies. They introduce a fidelity gate, which is supposed to check whether a proposed repair does not delete existing constraints, weaken safety classification, change source references, or things like that.
There are two experiments in which the authors evaluate their method:
- Evaluating the fidelity gate on a small set of repair cases (15 valid additive, 5 destructive) and reporting that it accepts valid repairs and rejects destructive repairs.
- Checking whether including the raw extracted graphs in a RAG system improves decisions on automotive scenarios, where the authors are showing some improvements in decision accuracy.
Critical strengths
- I think the general problem is very important. The idea of autoformalization is to convert natural language into a formal model and make sure that the representation in this formal model actually preserves the intended spirit of what was expressed in natural language. That is a pretty hard problem, and it is very important for all of neurosymbolic reasoning.
- The observation that a solver can accept a specification that no longer reflects the source, along with the fact that lots of these reward-hacking things happen, is well documented in the literature as well, including in other formal settings with agents (for example, in math AI and the Lean language). This is an important problem statement, and that is a strength.
Critical weaknesses
Overall, I do not see sufficient scientific evidence to support the main contributions that the authors are making.
Novelty and relation to prior work From a theoretical standpoint, I do not understand what is fundamentally very new here compared to prior work. There are a lot of papers in the literature that have done more, including concepts of valid, satisfiable, invalid, and unsatisfiable [1] in prior work around auto-formalization and around finding uncertainty in many such auto-formalizations. The problem is well known.
The central observation here revolves around making a formal specification satisfiable, but that does not mean it is correct or that it preserves the original requirement. This is a fairly basic observation that we already know, but I struggle to understand why it requires a new formal framework. There is lots of existing work on how to write a specification, how to observe and maintain semantic preservation, and such problems. Could the same effect be achieved through straightforward structural comparisons? Finally, the paper spends a considerable amount of effort defining and motivating a very elaborate pipeline, much of which has already been explored in prior literature.
Necessity of the POHA formalism The paper is doing this four-dimensional decomposition and has a partially observable hybrid automaton representation, but I do not understand why this particular formalism is necessary for the repair mechanism. They are explicitly restricting their verification to graph structure and algebraic constraints. I want to know: compared to established ways of representing things in SMT, why is this additional machinery justified?
Limited evaluation of the fidelity gate On the empirical side, the validation of the fidelity gate is extremely limited. They are just adding 15 additive modifications, making 5 destructive modifications, and testing things. That is not the level of empirical evidence that is required for an ICLR venue paper.
Downstream evaluation does not test the repair method The downstream methods do not seem to evaluate the actual repair method at all. The decision accuracy can come from providing raw extracted graphs to the LLM without applying the repair process. It is hard to say that the central contribution of this paper, the fidelity gate, improves downstream behavior. If the formalization is better, of course, it will improve downstream behavior.
There is a comparison between text-only RAG and RAG augmented with the structured graph, but there is no comparison against simpler methods. All the downstream evaluation is also limited to 100 curated scenarios derived from automotive documentation. That is good because it provides a new benchmark, but it also does not test on the benchmarks in the existing neurosymbolic literature. There are a lot of papers around the same idea, and it does not actually check that it works on those datasets.
Overall, I do not think this currently meets the bar for an ICLR publication.
Please see some prior work here:
[1] A neurosymbolic approach to natural language formalization and verification. An et al.
[2] Grammars of Formal Uncertainty: When to Trust LLMs in Automated Reasoning Tasks. Ganguly et al.
Both papers are fairly comprehensive regarding prior literature review, and prior work and benchmarks for improvements can be found from there.
Questions for authors
If you are planning to re-submit this paper, I would recommend exploring the following questions.
- What is fundamentally new about this fidelity gate compared to prior work in the neurosymbolic literature on checking specification correctness and refining specifications?
- I would really like to understand how the proposed gate works when correct repairs require modifying or removing incorrect constraints in the original extraction, especially if you're going through many different data types. In SMT, you're going through the many different sorts you have previously defined.
- I would want to see a lot more evaluation across datasets used in the literature.
- I want to specifically understand what the proposed hybrid automaton representation adds. Would a simpler representation provide similar improvements over text-only RAG at retrieval time? I think so.
3 comments
Maintaining my score
Thank you for the response. It seems to me that the method under review has been changed during the rebuttal, and there is now a new Z3-based gate. This means that most of the numbers in the rebuttal come from different scenarios and a different experimental methodology compared to the original submission, so they cannot be compared with what was originally reviewed.
In fact, I am not even sure how they are all presented in the paper at once without rerunning all the experiments, since some results appear unchanged from the original submission.
As I mentioned in my original review, there is a very elaborate formal setup, and I am still not convinced that there is anything novel about it.
The rebuttal's comparison with the papers I mentioned uses terminology that is hard to follow. Overall, the rebuttal and the revision read like a lot of word spaghetti: they are unnecessarily dense, and it is hard to keep track of how much AI writing has been done.
Response to previous concerns/queries
Thank you for your feedback. We apologize if our previous reply was overly dense, and we clarify each point below if it helps:
-
Did the gate change, or did we add a Z3 feasibility check?
- We did not replace our pipeline or method. In the original submission, Step 3 already compiled graphs into Z3, and Step 4 (the Fidelity Gate) already locked source traces, states, effects, durations, sensor tags, and
is_safety_critical, while checking guards by string matching. During the rebuttal, we simply connected our existing Z3 compiler to that guard check—adding a Z3 transition-feasibility check (to block contradictory dead guards) and UNSAT-core guard unlocking—specifically to answer your Q2 on how to modify or remove wrong initial guards. We kept the original string-matching gate side-by-side in Table 1 so both versions are directly compared on the exact same tasks.
- We did not replace our pipeline or method. In the original submission, Step 3 already compiled graphs into Z3, and Step 4 (the Fidelity Gate) already locked source traces, states, effects, durations, sensor tags, and
-
Which experiments are original (unchanged) vs. newly added for the rebuttal?
- None of the original experiments were removed or altered:
-
- Original & unchanged: The 20-case repair benchmark (15/15 valid, 5/5 destructive), the validation manual repair audit (Section 5.1), and the 100-scenario RAG evaluation (77.33% -> 87.33% and 78.00% -> 87.00%, Section 5.2, Table 2). Table 2 did not need rerunning because it tests text-only RAG against raw Step-1 extracted graphs before the Step-4 repair loop ever runs. Moreover, on all 7 manual sections where repair ran (Table 4), both the original gate and the Z3-extended gate reject the gamed edits and keep the exact same raw graph.
-
- Added in rebuttal per reviewer requests: Table 1 (testing wrong initial guards across Bool, Real, and String sorts, per your Q2) and Table 3 (comparing Ungated Repair, Structured Text, Discrete FSM, and Fidelity-Gated POHA on repair-affected scenarios, per your W4 and Q4 and also some queries from other reviewers).
-
- None of the original experiments were removed or altered:
-
What is the core novelty?
- Standard LLM + SMT repair loops stop as soon as the edited model is
SAT. Unlike Lean proof repair (where a human locks the target theorem) or code verification like Clover (Sun et al., 2024, where specs are cross-checked against executable code), technical manuals have neither a human-written formal spec nor reference code: the LLM edits its own imperfect SMT model after Z3 reportsUNSAT, and often reachesSATby deleting rules or flippingis_safety_criticalfromTruetoFalse("solver gaming"). Our experiments show that all three "obvious" solutions fail:
- An unconstrained SMT repair loop (
Verifier-Only, stopping as soon as Z3 returnsSATwith no fidelity gate) accepted all 7/7 solver-gamed manual sections (28 silent safety-flag flips plus guard/effect deletions) and 100% ofSATgamed candidates, dropping downstream accuracy to 70.9%—worse than plain text-only RAG (76.3%) without a solver. - Anti-gaming prompts (
Prompt-Only) stop flag flips, yet the LLM still games Z3 by deleting conflicting transitions and postconditions (Wipers,eCall). - Straightforward structural diffing (
Syntactic Gate, directly testing the question in your original review) fails in both directions: it rejects 100% (10/10) of legitimate fixes when an initial LLM guard is wrong (e.g., tighteningtemp <= 31totemp < 31), while still accepting 85.7% (30/35) of bad edits when the LLM appends a contradiction (speed > 0 and speed == 0). Our contribution is identifying this failure mode and resolving the two-way trap: using Z3 UNSAT cores and text boundary witnesses to unlock only the broken clauses while checking Z3 implication and pre/post-state satisfiability on everything else. This turns 0/10 valid repair and 85.7% false accepts into 10/10 valid repair and 0.0% false accepts, lifting downstream accuracy from 70.9% to 92.6% (+21.7 points).
- Standard LLM + SMT repair loops stop as soon as the edited model is
-
Comparison with [1] An et al. and [2] Ganguly et al.:
- In An et al. [1], humans inspect and freeze a trusted formal specification first, and the solver checks answers against that fixed specification. In our setting, there is no human-frozen specification yet—the LLM is editing its own SMT model inside a repair loop. In Ganguly et al. [2], grammar entropy detects when an LLM is uncertain during a single-pass translation. In our repair loop, even at temperature 0 (high confidence), the LLM deletes rules or flips safety flags to make Z3 return
SAT, so uncertainty scores alone do not catch it.
- In An et al. [1], humans inspect and freeze a trusted formal specification first, and the solver checks answers against that fixed specification. In our setting, there is no human-frozen specification yet—the LLM is editing its own SMT model inside a repair loop. In Ganguly et al. [2], grammar entropy detects when an LLM is uncertain during a single-pass translation. In our repair loop, even at temperature 0 (high confidence), the LLM deletes rules or flips safety flags to make Z3 return
-
On writing and AI polishing:
- Consistent with our paper's AI Use Statement, we designed and ran all experiments and drafted the responses, and used an LLM tool to condense and polish wording to fit OpenReview's 5,000-character limit. Compressing eight detailed answers into that limit made our previous reply read too densely; we wrote this clarification directly in simple terms so the distinction is clear. If you have any further questions, we will be happy to clarrify each sections.
Author Response to Reviewer dqZG: Novelty, Multi-Sort Gate & Baselines
We thank Reviewer
dqZGfor the detailed critique and references[1,2]. We address W1–W4 and Q1–Q4 below and in the revised paper.W1 & Q1: Novelty vs.
[1]An et al. &[2]Ganguly et al., and why structural checks failWe added dedicated comparisons in Secs. 2 & 3.3:
[1]An et al. (AWS ARc) & fixed-spec verifiers (Clover,nl2spec): In An et al., experts freeze an immutable model M∗ offline and check outputs against fixed M∗. In reference-free spec repair (H0→H′), the LLM has write-access to the specification. Because meta-axioms take the implicational form ∀t:A(t)⇒B(t) (e.g., κt=True⇒Sensor(Pt)), Z3 returnsSATwhether the LLM repairs B(t) or erases A(t) (flipping κt:True→False, deleting t, or injecting Pt′≡⊥). StaticSATchecks miss antecedent erasure; we formulate a cross-step relational refinement contract (H0⪯fidH′, Eqs. 4–6).[2]Ganguly et al. (NeurIPS 2025): Ganguly et al. measure open-loop parse uncertainty (PCFG grammar entropy). Solver gaming is closed-loop reward hacking, not uncertainty: at T=0.0, the LLM deterministically flips κt:True→False or deletes guards to clear UNSAT cores.30/35) when appending contradictions (speed > 0 and speed == 0) preserves strings while making Pt′≡⊥ vacuous (28.6%even with Z3 feasibility, solved to0%[0/35] byEvidence-Assisted); and (ii) 100% FQR (0/10) when flawed initial guards need tightening (temp <= 31→temp < 31) or revision (0%FQR [10/10] with our gate).W2 & Q4: Necessity of the 4-pillar POHA formalism vs. simpler representations
In Sec. 3.1, we ground each pillar in classical formal methods (LTS Topology, EFSM/
QF_LRAOntology, Timed Automata δt>0 Temporality, POMDP/Shielding σt Epistemology) and ablate representations in Table 3 & App. F (Table 6):RAG-Only:76.3%(7 repair-affected) /56.5%(all 13 scenarios)RAG + Structured Text(JSON rules):71.2%/61.4%(fails topology on mirror folding0.00)RAG + Discrete FSM(states + boolean guards, noRealQF_LRA, δt, or σt):87.0%/69.9%(solves discrete switches1.00, but drops to0.00vs. POHA1.00on reserve-charge display and0.375vs.0.625on summer parking due to missingRealthresholds)RAG + Fidelity-Gated POHA:92.6%(7 repair-affected) /72.9%staged base across all 13, rising to88.3%with+Verifierdiagnostics (Sliding Door0->1) and σt re-anchoring (Steering0->1; Apps. C.2 & F).W3, W4 & Q3: Expanded repair evaluation, downstream repair impact & literature datasets
15/15valid,5/5gamed), we evaluate real manual sections across splits (7/7gamed dev/val sections quarantined, blocking28silent κt flips, plus live σt re-anchoring onSteering; Table 4), a 60-case multi-sort pool (35/35invalid rejected,20/20valid accepted,5/5unsupported abstained), and 10 live closed-loop tasks (50LLM calls across 5 policies;10/10repaired vs.0/10syntactic; Table 5).RAG + Ungated Repairdrops accuracy by-21.7pp (92.6% -> 70.9%), causing unsafeALLOWdecisions on summer parking (0.625 -> 0.250). Standard NL-to-FOL datasets in[1,2](e.g., FOLIO, PrOntoQA) test single-turn open-loop entailment rather than closed-loop hybrid state-transition repair over multi-page CPS manuals (Sec. 6).Q2: Modifying/removing incorrect initial constraints across
Bool,Real&StringDetailed in Secs. 4.1–4.2 & App. E.2 (Table 5): our Z3 compiler encodes
Bool,Real(QF_LRAintervals and linear updates xnext=x+c), andStringenums, catching100%of cross-sort conflicts. When an initial guard is flawed: (i) valid tightenings pass via Z3 implication SAT(Pt′)∧UNSAT(Pt′∧¬p); (ii) contradictory (request and not request), over-restricted (and ambient), or loose-enum (!= "blocked" -> == "ready") guards in Z3's localUNSATcore or witness check (Auth(t,F,WM)) are unlocked for replacement while Preservectx locks states, invariants, effects, κt, and δt (10/10live tasks repaired;0context damage).