WorksComputer Science
Solver-Like Behavior in Large Language Models as Formalizers
Abstract
In the LLM-as-formalizer paradigm, a large language model translates a problem into a formal program and leaves the search to a solver, gaining the solver's guarantees. Formalizers are now often reasoning models that write a long reasoning trace before the program, yet they are judged only by the program's output. We find that the trace routinely does the solver's job, assigning, testing and ruling out values until it often reaches the full answer; we call this solver-like behavior (SLB). We define an ontology of SLB over the trace, the program and its output, and use LLM judges, checked against human labels, to label 2,000 generations from three reasoning models on four constraint satisfaction datasets, each formalized in a declarative and an imperative formal language. SLB appears in 85% of traces and takes 24% of reasoning tokens, yet the program usually recomputes the answer, so the effort is redundant. The 9% of programs that inherit the trace's answer also inherit its errors, and pass output-based evaluation whenever that answer is correct. The amount of SLB is not associated with accuracy, and SLB is more common in imperative Python than in declarative Z3 or PDDL. Cautionary prompts reduce it by only a quarter, but hiding the problem's values behind placeholders, which the program receives only at run time, removes 97% of it without loss of accuracy. Formalizers should therefore be evaluated by how their programs are reached, not only by what they output.
Introduction
In the LLM-as-formalizer paradigm (Tantakoun et al., [39]), a large language model (LLM) does not solve a problem but translates it into a formal program, such as a planning domain or a set of constraints, which a solver executes (Huang and Zhang, [21]; Lin et al., [26]; Amonkar et al., [1]). The
LLM handles language, and the solver performs the search with guarantees that the LLM’s own reasoning lacks (Wei et al., [42]). Formalizers today are often reasoning models that write a long reasoning trace before the program. Yet they are judged almost only by whether the program’s output is correct, which cannot tell a program that searches from one that restates an answer the model already worked out in its trace. The trace itself has gone unexamined: work on reasoning traces, which finds them often unfaithful or wasteful (Lanham et al., 2023; Arcuschin et al., [2]; Chen et al., [7]; Sui et al., [38]), studies models that solve the problem themselves, and formalizer traces have been discussed only in passing (Amonkar et al., [1]).
We find that formalizers routinely do the solver’s job themselves, a phenomenon we call solver-like behavior (SLB): before writing the program, the reasoning trace assigns, tests and rules out values of the problem’s variables, often until it reaches the full answer (Figure 1). This defeats the purpose of formalization in two ways. It is costly: constraint satisfaction is NP-complete (Cook, [11]), and solving in tokens grows with the instance: on Meeting Planning, solver-like tokens nearly triple from the smallest to the largest problems, though the program usually searches anyway. And it can silently void the solver’s guarantee: a program that prints the answer from the trace, i.e. inherits it, passes output-based evaluation while also inheriting the trace’s errors, so where outputs are not independently validated, a formalization that looks correct may be no more verifiable than chain-of-thought.

Figure 1. An LLM as formalizer writes a reasoning trace (2) and then a program (3), which is run and scored. The middle paragraph is solver-like: it solves the problem in the trace, finding first the common free intervals and then the meeting time, which is the solver’s job; in real traces such a passage runs to hundreds or thousands of tokens. Our ontology (§ 3) labels every generation (4): whether the reasoning trace is solver-like (A), how much of the reasoning answer the program inherits (B), and whether the program’s output matches the reasoning answer, which is checked for correctness (C). Here the program searches independently, so the solver-like behavior, 45% of the trace, was wasted.
We study SLB in three reasoning models on four constraint satisfaction datasets, each formalized in a declarative formal language (Z3 or PDDL) and an imperative one (Python). We define an ontology over the trace, the program and its output (Figure 2), label 2,000 generations with LLM judges that agree with blind human labels on 94% of paragraphs, and test four hypotheses (§5). (H1) SLB is common and redundant: 85% of traces contain it, yet the program usually recomputes the answer. (H2) Its forms differ in harm: the 9% of programs that inherit the reasoning answer also inherit its errors, and pass output-based evaluation whenever that answer is correct; hardcoding is rare and mostly comes from one model on one dataset. (H3) Its amount is not associated with accuracy on the same problem. (H4) The formal language matters most: Python draws more SLB than Z3 or PDDL in every dataset. Cautionary prompts cut SLB by about a quarter, while hiding the problem’s values behind placeholders that the program receives at run time removes 97% of it without loss of accuracy (§ 6). SLB is thus pervasive and mostly redundant, and occasionally voids the solver’s guarantee.

Figure 2. Ontology of solver-like behavior, with an example of each node on a toy seating problem (left). A describes the reasoning trace: whether it contains solver-like behavior (A1), and how much of an answer it reaches (A2). B describes how much of the reasoning answer the program inherits rather than computes; B1–B3 require A1 = SLB. C compares the program’s output with a complete reasoning answer (C1), and checks the reasoning answer with the validator (C2).
Related Work
LLMs as formalizers. An LLM paired with an external solver writes PDDL for classical planners ([27, 18, 43, 47, 19, 21, 17, 20]), logic for theorem provers and SAT/SMT solvers ([33, 31] (Ye et al. 2023)), optimization models ([25]) and scheduling constraints ([1]; Tantakoun et al. [39] survey the planning line, and program-aided reasoning ([14, 28] (Chen et al. 2023)) likewise delegates computation to an interpreter. These works evaluate the program, by whether it executes, matches a reference or yields a valid solution; we examine the reasoning that precedes it.
Reasoning traces
Chains of thought often misrepresent the computation behind the answer: models omit cues that sway them ([40, 8]), rationalize after the fact ([2]), and keep their answer when the reasoning is truncated or corrupted (Lanham et al., 2023). Other work dissects traces into behaviors such as verification and backtracking ([29] (Gandhi et al. 2025)) or finds the sentences that steer the outcome ([4]). Reasoning models also spend far more tokens than a problem needs ([7, 38, 12]), which motivates budgets on reasoning length (Muenninghoff et al., 2025) and measures of effort beyond length ([5]), while accuracy can still collapse as problems grow complex ([37]). All of this work studies models that solve the problem themselves. For a formalizer, solver-like behavior is a specific waste: its tokens duplicate the solver’s work and grow on the hard instances that formalization is meant to offload.
Delegation and hardcoding. LLMs often reason in text when code would serve better ([10 c]), or call tools they do not need ([34, 41]); solver-like behavior is a failure to delegate that persists after the model has written a program. Its extreme form, a program that prints the trace’s answer, resembles reward hacking in code generation, where models hardcode test outputs ([3, 46]); training against a monitor of the trace can drive such behavior into less visible forms ([3]), much as our cautionary prompts turn literal itineraries into fixed orders (§ 6).
An Ontology of Solver-Like Behavior
We view each task as a constraint satisfaction problem: a set of decision variables, the unknowns that together make up an answer (e.g., when a meeting starts, where each object goes, or which action comes next in a plan), and constraints on their values. In the LLM-as-formalizer paradigm, encoding the variables and constraints is the model’s job, and finding values that satisfy them is the solver’s. Figure 2 illustrates every definition below on a toy problem: seat Ann, Bob and Cy in chairs 1–3, with Ann left of Bob and Cy not in chair 1. Its decision variables are each person’s chair.
Solver-like behavior (SLB) is text in the reasoning trace that does the solver’s job on the instance: assigning, testing or ruling out values of its decision variables. Designing the encoding, restating the problem’s data or constraints, choosing the output format, parsing, and interpreting an ambiguous constraint are not solver-like, unless the reading is chosen by solving under each one. A formalizer’s generation has two parts: a reasoning trace (trace for short), the natural-language text the model writes first, and a program, whose output is what it prints when run. An answer stated in the trace is the reasoning answer. We describe solver-like behavior along these three components: the trace (A), the program (B), and its output (C).
A. Reasoning trace is read from the trace alone. A1 (existence) is SLB if the trace assigns, tests or rules out values of decision variables, and none otherwise. Arguments about the solution set that commit no values, such as uniqueness, are rare and not counted. A2 (extent) applies when A1 is SLB. It is complete if every decision variable receives a value and partial otherwise, including a tentative answer the trace later abandons. The solver-like ratio is the share of the trace that is solver-like.
B. Program records how much of the reasoning answer the program inherits rather than computes. A program inherits a decision when it takes the value from the trace instead of computing it; B1–B3 are the forms this takes. B1 Hardcoded: it prints an answer it does not compute, so the formalization adds no guarantee. B2 Partly fixed: it computes the answer, but decisions made in the trace are written into its source. This shrinks the solver’s search, which can be harmless or even necessary, as when a numerical BlocksWorld constraint, which PDDL cannot express, must be turned into fluents in the trace. B3 Steered: it searches, but its tie-break, objective or iteration order is chosen so that the search returns the reasoning answer. B4 Independent: it searches under every constraint, so any SLB in the trace was wasted. Only decisions the trace had to solve for count as inherited; a restriction read off the problem statement is part of the encoding. B1–B3 presuppose A1 = SLB, and B does not apply when the program does not run.
C. Output compares the program’s output with the reasoning answer, and applies when A2 is complete and the program runs. C1 (match) asks whether the reasoning answer equals the program’s output. C2 (correct) asks whether the reasoning answer passes the validator used to score the program. Together they distinguish programs that merely reproduce the reasoning answer from programs that override an incorrect one or are led astray by it.
Methods
Tasks, Datasets and Formal Languages. Given a natural-language constraint satisfaction problem (CSP) (Russell and Norvig, [36]), the model must write a program in a formal language (FL) that returns a valid solution when executed. We sample 100 instances from each of four benchmarks. Calendar Scheduling and Meeting Planning (Zheng et al., [45]) require meeting times and multi-location travel-time constraints. ZebraLogic (Lin et al., [26]) consists of logic grid puzzles. BlocksWorld (IPC, [22]) is classical planning. Full task descriptions are in Appendix § 10.
We formalize every dataset in two FLs; following the formalizer literature, FL here includes general-purpose programming languages. The two differ in who searches for a solution, which is what solver-like behavior is about. A declarative program states what a solution is and a solver finds one; an imperative program states how to find one, so the model designs the search. Our imperative FL is Python with only the standard library. Our declarative FL is PDDL [16] for BlocksWorld, solved by a classical planner, and Z3 for the other datasets: Python programs that state constraints through the API of the Z3 SMT solver (de Moura and Bjørner, 2008), which returns a satisfying assignment. Programs that use another library, or Z3 programs that never call the solver, are flagged as not written in the requested FL (at most 5% of any run; Table 2).
| Model | Task | FL | Not in FL 0 | Not in FL A | Not in FL B |
| DeepSeek | Calendar | Python | 0 | 0 | 0 |
| Meeting | Python | 0 | 0 | 0 | |
| ZebraLogic | Z3 | 0 | 0 | 1 | |
| BlocksWorld | PDDL | – | – | – | |
| GPT-OSS | Calendar | Python | 0 | 0 | 0 |
| Calendar | Z3 | 0 | 0 | 0 | |
| Meeting | Python | 0 | 0 | 0 | |
| Meeting | Z3 | 0 | 0 | 0 | |
| ZebraLogic | Python | 0 | 0 | 0 | |
| ZebraLogic | Z3 | 0 | 0 | 0 | |
| BlocksWorld | Python | 0 | 0 | 0 | |
| BlocksWorld | PDDL | – | – | – | |
| Qwen | Calendar | Python | 0 | 0 | 0 |
| Calendar | Z3 | 0 | 0 | 0 | |
| Meeting | Python | 0 | 0 | 0 | |
| Meeting | Z3 | 5 | 3 | 2 | |
| ZebraLogic | Python | 0 | 0 | 0 | |
| ZebraLogic | Z3 | 0 | 0 | 0 | |
| BlocksWorld | Python | 0 | 0 | 0 | |
| BlocksWorld | PDDL | – | – | – |
Table 2. Runs: each model, task and formal language has 300 generations (100 problems under each of three prompts; 6,000 in total). Not in FL: programs not written in the requested FL under the baseline (0) and Cautionary A and B prompts. DeepSeek is run in one FL per dataset.
Prompt. Each model receives one prompt per dataset and FL: a prefix that instructs it to formalize the problem in the FL and let the program solve it, rather than solving it in the reasoning trace, followed by the task’s output format (Appendix § 12). All Z3 prompts give the import and coding steps of the ZebraLogic Z3 prompt [26]. The PDDL prompt supplies the ground-truth problem PDDL as a reference and asks for a domain and a problem; the Python BlocksWorld prompt gives only the natural-language problem, which states the same initial and goal states.
Models. We evaluate three reasoning models that write a reasoning trace before the program. We need the complete trace: closed frontier models
such as Claude, GPT-5 and Gemini return at most a summary of their reasoning through their APIs, from which solver-like behavior cannot be measured. DeepSeek-V4-Flash [13] runs via API, and GPT-OSS-120B [32] and Qwen3.8-27B [35] locally with vLLM. DeepSeek is run in one FL per dataset (Python for Calendar Scheduling and Meeting Planning, Z3 for ZebraLogic, PDDL for BlocksWorld), because the model behind its API changed between our runs (Appendix § 11).
Metrics. We report the ontology labels of § 3, the solver-like ratio, and program accuracy for every generation.
LLM judges. No script can tell whether a passage does the solver’s job, and the traces are too many and too long to label by hand. We therefore label A1, A2 and B with LLM judges, using Gemma 4 31B-it [15] (FP8), which is not one of the evaluated models. Traces are too long to judge at once, so we cut each into segments of at most 2,000 tokens at paragraph boundaries and give the A1 judge one segment at a time, with the problem, to label every paragraph as SLB or none; a trace is SLB if any paragraph is, and the solver-like ratio is the share of the trace’s characters in such paragraphs. The A2 judge extracts the reasoning answer from the SLB paragraphs, and the B judge compares the program with the trace. C1 and C2 are scripts. Against reference labels covering both FLs of every dataset, the judges agree on 90–98% of cases (Table 1). Judge designs and further checks are in Appendix § 13, labeled examples in Appendix § 15.
| Node | Reference | Agree | 95% CI |
| A1 paragraph | human, blind | 103/110 | .87–.97 |
| SLB precision | human, blind | 38/42 | .78–.96 |
| SLB recall | human, blind | 38/41 | .81–.97 |
| A2 extent | human + script | 39/40 | .87–1.00 |
| B program | model, blind | 19/20 | .76–.99 |
| B program (held out) | human, not blind | 38/40 | .83–.99 |
| C1, C2 | deterministic scripts |
Table 1. Agreement of each ontology judge with reference labels, with Wilson 95% confidence intervals. A1: one annotator, labeling blind (70 development and 40 held-out paragraphs). A2: complete labels verified by humans, partial ones by searching the trace for the program’s answer and having a second model read the passages found. B: blind reference labels by a second model; held out: a human shown the judge’s evidence, on programs labeled B1–B4. A1 and held-out B references cover both FLs of every dataset. C1 and C2 are computed by scripts from the A2 extraction, so they need no agreement check.
Accuracy. A program is correct if it runs and its output satisfies every constraint of the problem (Appendix § 10).
Results
We label 2,000 generations: Qwen and GPT-OSS in both FLs of each dataset and DeepSeek in one, each on 100 problems under the prompt above, and test the four hypotheses of § 1. Confidence intervals are 95% bootstrap intervals over problems; Appendix § 14 lists the labels of every run.
H1: SLB is common and redundant
We call solver-like behavior practically significant in a trace when it takes at least 10% of the trace or at least 1,000 tokens. By either measure, it is the norm. 85% of traces contain SLB (91% outside BlocksWorld in PDDL), 71% spend at least 10% of their tokens on it, and 47% at least 1,000 tokens (Figure 3). Across all traces, 24% of reasoning tokens are solver-like. A DeepSeek trace spends on average 6,123 of its 26,572 reasoning tokens on solver-like behavior, a Qwen trace 3,788 of 15,310, and a GPT-OSS trace 575 of 1,892. The one setting where it is rare is BlocksWorld in PDDL (51% of traces, ratio 0.04). Stray paragraphs do not drive this: only 29 of the 1,699 traces with SLB spend under 2% of their text on it, and in 77% of all traces the SLB paragraphs alone state a complete answer.
Figure 3. H1 and H2: solver-like behavior is common, and the program rarely inherits it. For each dataset and FL, the share of traces with SLB (A1) and the mean solver-like ratio, with 95% confidence intervals. Each SLB bar is split by the program’s label (B): programs that inherit the reasoning answer (B1–B3, grey) at the bottom, independent programs (B4) in the model’s colour, and programs with no output (missing, failed, or printed nothing) hatched; most of these are Qwen’s Z3 programs, which call Z3 methods that do not exist. DeepSeek is run in one FL per dataset (–).
It grows with the problem. From the smallest to the largest third of problems, solver-like tokens per trace rise from 3,873 to 10,971 on Meeting Planning (by number of friends) and from 532 to 4,148 on ZebraLogic (by grid size), as accuracy falls from 0.70 to 0.51 and from 0.90 to 0.78; GPT-OSS on ZebraLogic is the exception. On Calendar and BlocksWorld they do not grow.
The program rarely uses it. Of the generations whose trace contains SLB, the program computes the answer anew (B4; Figure 3, top) in 89% for DeepSeek and 77% for Qwen and GPT-OSS. Yet the two usually agree: where the trace states a complete answer and the program prints one, an independent program prints exactly the reasoning answer in 88% of cases (1,027 of 1,174; C1). The solving duplicates the work the program then does.
H2: SLB takes forms that differ in harm
SLB usually reaches a complete answer. When a trace contains SLB, it states a complete answer in 87% (DeepSeek), 86% (GPT-OSS) and 96% (Qwen) of cases (A2), i.e. the very answer the program is meant to compute. The reasoning answer is wrong in 2% (DeepSeek), 11% (Qwen) and 13% (GPT-OSS) of the complete answers that can be checked (C2).
Inheritance is rare and concentrated. Of the 1,791 programs that ran, 163 inherit the reasoning answer (grey in Figure 3, top, which shows the 157 whose trace contains SLB): 47 are hard-coded (B1), 40 of them GPT-OSS on Meeting Planning in Python; 88 are partly fixed (B2), mostly on BlocksWorld, Meeting Planning and ZebraLogic; and 28 are steered (B3), mostly Meeting programs in Python that try friends in the order of the reasoning answer. As B1 implies, 44 of the 45 hardcoded programs whose output can be compared print exactly the reasoning answer (C1).
Inheritance passes on errors in the reasoning answer. When the reasoning answer is wrong, none of the 19 hardcoded programs and 1 of the 13 partly fixed ones is correct, against 32% of the 84 independent programs, which recompute the answer and can recover. Recomputing is no guarantee, though: 37 of those 84 independent programs print the same wrong answer as the trace (C1), so a program can share the trace’s error without taking any value from it, unless the B judge misses subtler inheritance. Steering is harmless: both steered programs with a wrong reasoning answer are correct. When the reasoning answer is correct, all four kinds of program are correct at least 93% of the time, so output-based evaluation cannot tell a hardcoded program from an independent one: all 26 hardcoded programs with a correct reasoning answer pass it.
H3: The amount of SLB is not associated with accuracy
Harder problems may draw both more SLB and more errors, so we compare generations of the same problem: a linear probability model of program correctness with fixed effects for the problem and for each model, dataset and FL. The amount of solving has no detectable effect (Figure 4). Ten more points of solver-like ratio change accuracy by +0.007 [−0.011, +0.022], and 1,000 more solver-like tokens by +0.005 [−0.002, +0.013]; within datasets the ratio’s effect lies between −0.03 and +0.02, except on BlocksWorld (+0.047 [+0.004, +0.083]). Programs that inherit the reasoning answer are not less accurate on average. (−0.00 [−0.09, +0.07]). Traces with no SLB are less often correct (−0.09 [−0.15, −0.02] relative to traces with some), but the gap lies in programs that fail to run: 25% of them crash, against 12%, and among programs that run the gap is −0.04 [−0.09, +0.03]. We cannot rule out that working through the problem helps a model write a program that runs. The interventions of § 6 agree: removing solver-like behavior does not lower accuracy.
Figure 4. H3: the amount of solver-like behavior is not associated with accuracy. Change in the probability that the program is correct per unit of each measure, from a linear model with fixed effects for model, dataset and FL and for the problem, with 95% confidence intervals. Grey: the ratio’s effect within each dataset.
H4: SLB differs by formal language
On the same problems, Python draws more SLB than either Z3 or PDDL, in every dataset (Figure 5; pooled over the two models, with Qwen on ZebraLogic the one exception). The ratio is higher in Python by 0.06 [0.04, 0.08] on Calendar, 0.20 [0.17, 0.23] on Meeting Planning and 0.03 [0.01, 0.06] on ZebraLogic than in Z3, and by 0.16 [0.14, 0.18] on BlocksWorld than in PDDL. In a linear model of the ratio with all three factors (Qwen and GPT-OSS; ), removing the FL loses 0.123 of explained variance, the dataset 0.057, and the model 0.008. Using only the FLs DeepSeek is run in, where all three models are run, the model explains 0.011.
Figure 5. H4: on the same 100 problems, Python draws more solver-like behavior than each dataset’s declarative FL (in parentheses). Mean solver-like ratio per model, with 95% confidence intervals.
The dataset matters through the search the FL leaves to the model. The FL effect is largest where the declarative FL takes over a search that is hard to program: in PDDL the planner finds the plan, and in Z3 the solver chooses Meeting Planning’s friend order, which in Python the model must program as a search over orders. On Calendar (a trivial search) and ZebraLogic (permutations in Python) the FLs differ little. With the FL fixed, the datasets differ in Python (Meeting Planning 0.38, the others 0.19–0.25) but not in Z3 (0.18–0.19). The two prompts of a dataset also differ in more than the FL (§ 4): the PDDL prompt supplies the reference problem file, which may account for part of the BlocksWorld gap, so the Z3 comparisons are the cleaner test of the FL.
Deterring Solver-Like Behavior
We test three ways to deter SLB: warning against it in the prompt, batching several problems into one prompt, and hiding the problem’s values behind placeholders. Each generation is compared with the baseline generation of the same problem (Figure 6).
Figure 6. Placeholders all but remove solver-like behavior without costing accuracy; cautionary prompts remove about a quarter of it, and batching shortens all reasoning at a cost in accuracy. Change from the baseline prompt on the same problems in solver-like tokens per problem (% of the baseline mean), solver-like ratio, and program accuracy (points): pooled estimate with 95% bootstrap confidence interval, and one dot per model. Each method is measured where it was run: cautionary prompts for every model, dataset and FL (2,000 pairs), batching () for Qwen and GPT-OSS in every dataset and FL except PDDL (1,400), placeholders for Qwen and GPT-OSS on Calendar and Meeting Planning in Python and Z3 (800). The subsets differ, so the text compares each method with the cautionary prompts on its own problems.
Cautionary prompts
We add one of two warnings to the prompt of § 4 (Appendix § 12; Listings 1–3). Cautionary A frames solver-like behavior by its outcome, precomputing the answer in the trace and hardcoding it, and Cautionary B by the act, substituting the given values into arithmetic in the trace. Each illustrates the contrast with a math word problem, so no task-specific solution leaks. We run both for every model, dataset and FL of § 5.
Cautionary prompts reduce solver-like behavior by about a quarter, without removing it or changing accuracy (Figure 6). From a baseline of 0.20, the ratio falls by 0.053 [0.045, 0.061] under Cautionary A and 0.058 [0.051, 0.065] under Cautionary B, and solver-like tokens by 689 and 443 per trace (23% and 15%). Yet most traces still contain SLB: the share with SLB falls by 4 and 9 points, almost all of it GPT-OSS (−10 and −19 points), while DeepSeek (+1, −4) and Qwen (−1, −1) barely change. Programs that inherit the reasoning answer fall by 4 points. Accuracy does not change (+0.01 [−0.01, +0.02] and −0.00 [−0.02, +0.01]), so reducing solver-like behavior neither helps nor hurts, as H3 found by observation.
The prompts remove hardcoded answers more than inherited decisions. GPT-OSS’s 40 hardcoded Meeting programs in Python fall to 0 and 1, but its partly fixed ones go from 11 to 15 and 7: the program now encodes the problem, yet still follows a friend order chosen in the trace.
Batching and placeholders
A trace can only assign, test or rule out values it is given. Two changes to the problem make this harder while leaving the formalization task intact. Batching gives problems of the same dataset in one prompt and asks for separate programs, each headed by its problem’s number: the encoding can be designed once, but solving in prose must be done times. Placeholders replace every value of a problem by a name (Person1, Day1, T1 for clock times, D1 for durations, L1 for locations, and a table TRAVEL for Meeting Planning’s travel times), and the program receives the values only when it runs, as a dictionary VALUES (Appendix § 12, Listing 4). The model must therefore write out the problem’s structure in placeholder names. Placeholder numbers are shuffled, so their order reveals nothing about the times. The model can still choose among placeholders (“meet Person2 first, from T3”), which the A judge counts as SLB. We apply placeholders only to Calendar and Meeting Planning, whose values separate cleanly from the structure. We run both methods for Qwen and GPT-OSS on the same 100 problems of every dataset and FL except PDDL, with , and add for GPT-OSS on Calendar and Meeting Planning in Python. A batch’s trace serves problems, so each of them is credited with the trace’s ratio and of its tokens. The A judge overcounts SLB in placeholder traces, which can only understate the placeholders’ effect (Appendix § 13).
Placeholders all but remove solver-like behavior without costing accuracy (Figure 6). Solver-like tokens per problem fall by 97% [96, 98], from 2,820 to 78; the ratio falls from 0.25 to 0.005, and the share of traces with SLB from 94% to 15%, for both models in both FLs. On the same problems, the cautionary prompts cut solver-like tokens by only 32% and 18%. Accuracy rises by 2.6 points [−0.5, +5.9]. The largest gain, GPT-OSS on Meeting Planning in Python (0.66 to 0.82), comes partly from programs that inherited the reasoning answer: 13 of the 28 problems that placeholders fix had such a program under the baseline. Since the model never sees a value, it cannot hardcode an answer, and the program, not the trace, computes the result. The cost is length for Qwen, whose reasoning per problem grows by 54% (more than threefold on Calendar); in the longest of these traces we read, the added text concerns the program’s robustness to values it cannot see, such as intervals ending at 24:00, not the solution. GPT-OSS’s reasoning shrinks by 31%.
Batching shortens all reasoning, not just the solving, and costs accuracy. Solver-like tokens per problem fall by 62% [55, 68], but reasoning tokens fall almost as much (61%), so the ratio barely moves (−0.02 [−0.045, +0.001]; Qwen +0.04): the encoding is designed once for the batch, while each problem is still worked out in prose. Accuracy falls by 5.9 points [−11.0, −0.5], most on ZebraLogic, by 15 to 26 points for each model in each FL. Larger batches cut more: for GPT-OSS on Calendar and Meeting Planning in Python, solver-like tokens per problem fall by 56%, 78% and 91% at , 5 and 10, with accuracy 2, 6 and 3 points above the baseline.
Conclusion
Formalizers are meant to leave the search to a solver, yet their reasoning traces routinely do it themselves. Across three models and four datasets, this solver-like behavior is common and redundant, is not associated with accuracy, and depends most on the formal language. The few programs that inherit the reasoning answer also inherit its errors, and output-based evaluation cannot tell them from programs that search, so formalizers should be judged by how their programs are reached, not only by what they output. For practitioners, the most reliable remedy is to keep the instance’s values out of the prompt: placeholders bound at run time remove nearly all solver-like behavior without loss of accuracy and rule out hardcoded answers. Otherwise, cautionary prompts remove only a quarter of it, and batching costs accuracy.
Limitations
Our study covers three reasoning models and four constraint satisfaction datasets, each in two formal languages. Other task types, such as theorem proving or optimization, and other languages may show different amounts of solver-like behavior. DeepSeek is run in only one formal language per dataset because the model behind its API changed between our runs, so H4 rests on Qwen and GPT-OSS, and its runs cannot be reproduced exactly. The two prompts of a dataset differ in more than the formal language (§ 4), notably the reference problem file in the PDDL prompt, which may contribute to the differences H4 attributes to it. Each problem is generated once per setting, so our intervals do not capture sampling variation across generations.
Our ontology labels come from LLM judges and scripts. The judges agree well with reference labels (Table 1), but the reference samples are small (110 paragraphs for A1, 40 traces for A2, 60 programs for B) and come from one annotator, one B check compares against labels written by a second model and the other showed the human the judge’s evidence, A1 was checked on paragraphs and not on whole traces, and A2 was checked with the help of a script and a second model because full traces are too long to annotate by hand. B and C cover non-random subsets: B only programs that run (1,791 of 2,000, which drops most of Qwen’s crashing Z3 programs), and C only the 1,547 complete reasoning answers, of which C1 can compare 1,314 with the program’s output. C also covers only reasoning answers that the task’s parser reads, and for Meeting Planning an extracted reasoning answer sometimes combines two tentative itineraries, so its error rate is an upper bound. The solver-like ratio counts whole paragraphs, so a paragraph that mixes encoding and solving counts entirely toward it.
Finally, H3 is observational: fixed effects for the problem remove differences in difficulty, but not every confounder. The cautionary prompts in § 6 reduce solver-like behavior without changing accuracy, which supports H3, but they remove only part of it. Placeholders remove almost all of it, but apply only where a problem’s values separate from its structure; we test them, and batching, on two models and not in PDDL, and placeholders on two datasets.
Ethical Considerations
Risks. We study how formalizers reach their programs and see no direct path to misuse. The risk our results point to is in deployment: a program that hardcodes or inherits the reasoning answer looks as verifiable as one that searches, so systems that trust formalizer output without validating it may act on answers no solver checked (§ 5). Solver-like reasoning is also redundant computation, which placeholders remove (§ 6).
Data. The datasets are synthetic English constraint satisfaction problems. Calendar Scheduling and Meeting Planning refer to fictional people by first name only; the problems contain no information about real people, and we found no offensive content in them or in the traces we read. Datasets, models and licenses are listed in Appendix § 9.
Human annotation. All human reference labels (Table 1, Appendix § 13) were written by one of the authors, an NLP researcher, using the definitions in the judge prompts. No crowdworkers or other participants were involved, and no personal data was collected.
Use of AI assistants. We used Claude Code as a coding and writing assistant: to write and debug the experiment and analysis code, to run experiments, and to draft and edit text. The authors designed the study, directed and checked this work, and take responsibility for the paper; all reported numbers come from scripts in our repository.
Experimental Details
Each model receives one zero-shot prompt per problem, built from a prefix for the formal language and an output format for the task (Appendix § 12). We extract the program from the model’s final answer and run it: Python and Z3 programs with the Python interpreter, and PDDL domains and problems with the Fast Downward planner. The output is scored as in Appendix § 10, and each generation is labeled by the ontology judges (Appendix § 13). Each dataset contributes the same 100 randomly sampled problems in both formal languages. Table 2 lists every run: 6,000 generations, of which the 2,000 under the baseline prompt are used in §5. It also counts the programs flagged as not written in the requested formal language: those that import a library outside the standard library in Python, or Z3 programs that never import Z3 or never call the solver. PDDL is not checked, since a planner rejects anything else.
Artifacts and licenses. Calendar Scheduling and Meeting Planning come from NaturalPlan (Zheng et al., [45]) (code Apache 2.0, data CC BY 4.0), ZebraLogic from Lin et al. [26] (released for evaluation, without a stated license), and BlocksWorld from the IPC domain (IPC, [22]). All are evaluation benchmarks, and we use them only for evaluation. GPT-OSS-120B, Qwen3.8-27B and Gemma 4 31B-it are released under Apache 2.0 and run locally; DeepSeek-V4-Flash is used through its API under DeepSeek’s terms of service. We release our code, prompts, model outputs and labels under the MIT license for research on formalizers.
Software and compute. Local models and judges run on vLLM 0.32.0 (PyTorch 2.13), one NVIDIA H100 NVL (94 GB) per model instance; GPT-OSS-120B uses its released MXFP4 weights and the Gemma judges FP8. Python and Z3 programs run under Python 3.12 with z3-solver 4.14–4.15 and a 30-second limit. PDDL is solved by Fast Downward (commit 487e33c, alias lama-first), and plans are validated by VAL (commit 3c7a1f3). Tokens are counted with tiktoken’s cl100k_base. Generation and judging, including judge development and §6, took roughly 150 H100 GPU-hours by our logs, plus the DeepSeek API calls. Decoding settings (Appendix § 11) are fixed for all runs; we did no hyperparameter search.
Tasks and Datasets
Each dataset consists of constraint satisfaction problems (CSPs) (Russell and Norvig, [36]) stated in natural language, from which we sample 100
problems with their ground-truth solutions. Every dataset is formalized in Python, restricted to the standard library, and in a declarative formal language: Z3 for Calendar Scheduling, Meeting Planning and ZebraLogic, and PDDL (Ghallab et al., [16]) for BlocksWorld.
Calendar Scheduling (Zheng et al., [45]) involves scheduling meetings among multiple people given their existing constraints and availability windows. Models must find time slots that satisfy duration requirements and avoid conflicts with busy intervals for all participants.
Meeting Planning (Zheng et al., [45]) focuses on coordinating multi-location meetings with logistical constraints including people, locations, available time windows, and travel time between locations. Solutions require planning feasible itineraries that respect temporal and spatial constraints.
ZebraLogic (Lin et al., [26]) presents logic grid puzzles where models must determine which attributes (e.g., colors, pets, drinks) belong to which entities (e.g., houses, people) based on a set of logical clues. In Z3, the program states the clues as constraints over the attributes; in Python, it must search the assignments itself, typically by enumerating permutations.
BlocksWorld ([22]) is classical planning: rearranging blocks into a goal configuration under additional constraints. In PDDL, the model writes a domain and a problem, given a reference problem that omits the additional constraint (in 53 of the 100 instances it therefore differs from the ground-truth problem), and the Fast Downward planner finds the plan; in Python, the program prints the plan itself. Either plan is checked by the VAL validator against the ground-truth domain and problem.
Accuracy. For each problem instance, we construct a constraint JSON containing relevant restrictions and verify that the program’s output violates none of them. Since multiple valid solutions may exist for some of the tasks (e.g. Calendar Scheduling), a generation is marked correct if the program executes successfully and its output satisfies all constraints, and incorrect otherwise. For Meeting Planning, the itinerary is simulated step by step against the start location and time, the travel times, and each friend’s location, availability window, and minimum meeting duration; since the goal is to meet as many friends as possible, it must also meet at least as many friends as the ground-truth solution. For ZebraLogic, the printed grid must match the ground-truth solution. For BlocksWorld, the plan, found by the planner for a PDDL formalization or printed by a Python program, must be valid under the ground-truth domain and problem, and for unsolvable instances the formalization must be proven unsolvable or the program must report that no plan exists. Ten of the 100 BlocksWorld instances are unsolvable; for one of them the planner cannot prove unsolvability within its time limit even from the ground-truth PDDL, so PDDL accuracy on BlocksWorld is at most 99%.
Model Details
We evaluate on three models with varying reasoning capabilities. All models support extended reasoning modes that produce explicit reasoning traces before generating code, making them suitable for analyzing solver-like behavior.
DeepSeek-V4-Flash (DeepSeek-AI et al., [13]) is a large reasoning model accessed via the DeepSeek API with thinking enabled, reasoning effort medium, and at most 131,072 output tokens.
GPT-OSS-120B (OpenAI et al., [32]) is a 120-billion-parameter model run locally with vLLM at reasoning effort medium (temperature 0.7, top-p 0.9), generating up to the 131,072-token context window.
Qwen3.8-27B (Qwen Team, [35]) is a 27-billion-parameter model run locally with vLLM with thinking enabled (temperature 0.7, top-p 0.9), generating up to the 131,072-token context window.
All models are evaluated as formalizers, prompted to generate executable Python code (or Z3/PDDL, where appropriate) that returns the solution upon execution.
DeepSeek in one FL. DeepSeek is run in one FL per dataset: Python for Calendar Scheduling and Meeting Planning, Z3 for ZebraLogic, and PDDL for BlocksWorld. The model served under its API name changed before our runs in the other FL: rerunning 20 earlier prompts with the same settings gives traces 4–5 times shorter, on every problem. Since its runs in the other FL would compare two different models, we leave them out.
Prompt Configurations
We evaluate each model under three prompting conditions to assess whether explicit warnings can deter solver-like behavior. All prompts consist of the same two parts: (i) a prefix for the formal language (Python, Z3 or PDDL) that instructs the model to formalize the problem, and (ii) a task-specific output format, which for Z3 also gives the import and the coding steps.
Baseline is the default prompt. The Python and Z3 prefixes instruct the model to write a program that “solves it directly rather than solving it yourself in prose.” The baseline discourages solving in natural language only implicitly. The PDDL prefix has no such clause; it supplies the ground-truth problem PDDL as a reference for the initial and goal states, and asks for a domain and a problem that encode the problem’s constraints. The baseline measures how much solver-like behavior persists under an ordinary formalization instruction.
Cautionary A frames solver-like behavior by its outcome: the model works out the answer in its reasoning trace, and the code then just outputs that precomputed result. It contrasts a solver-like and a sound response to a multi-step wage problem with a conditional bonus; the sound response lists the given values and enumerates the computation steps without performing any arithmetic. It closes with an explicit instruction not to compute intermediate values or final answers during reasoning.
Cautionary B defines solver-like behavior by the act itself: substituting the given values into arithmetic, or deriving an intermediate or final result in the trace, before any code is written. It illustrates this with a single-step GSM8K problem, and its sound example refers to the given values only abstractly. It closes by instructing the model to reason only about the variables and constraints and to outline the steps a program would take.
Listings 1–3 show the three prompts in Python for Calendar Scheduling; Listing 5 shows the Z3 prefix with its Calendar Scheduling output format, and the PDDL prefix. The cautionary prompts add the same warning to every prefix.
Both cautionary prompts use math word problems rather than benchmark instances, so they leak no task-specific solutions but require the model to transfer the contrast to scheduling, logic, and planning. This design allows us to test whether explicit prompt variations reduce solver-like behavior and whether such reductions change formalization performance (§ 6).
Batching and placeholders (§ 6) change the problem part of the baseline prompt instead of adding a warning. A batched prompt uses the baseline prefix in the plural (“You are given constraint satisfaction problems (CSPs) of the same kind . . . enclose each problem’s complete solution in its own code block”), lists the problems under headers “### Problem ”, gives the output format once, and ends with the instruction at the top of Listing 4. Each problem is assigned the program headed by its number. A placeholder prompt is the baseline prompt with the problem rewritten in placeholders and preceded by a note on them (Listing 4). Before execution, the program is prefixed with the definition of VALUES (and, for Meeting Planning, TRAVEL), and placeholder names in its output are mapped back to their values. The A judge sees the placeholder problem, with a note that choosing among placeholder values counts as SLB. Batch groups are fixed by a seeded shuffle of the 100 problems, so every model and FL sees the same groups.
Ontology Judges and Their Reliability
All LLM judges use Gemma 4 31B-it (FP8, temperature 0, thinking mode), which is not one of the evaluated models; their prompts were fixed before the labeling runs. Reference labels are sampled evenly across each judge’s predicted labels, so rare labels such as hardcoded are tested as often as common ones. Because the judges were developed on traces in the FLs DeepSeek is run in, A1 and B are also checked by a human on held-out traces in each dataset’s other FL. Each judge’s input, output and reliability check are as follows; Listings 6–8 give their prompts.
Segments and paragraphs. The A1 judge labels paragraphs, a unit a human can also label, but a whole trace is too long for one request (a DeepSeek trace averages 26,572 tokens). We therefore cut each trace into segments of at most 2,000 tokens (counted with the cl100k_base tokenizer). Cuts fall between paragraphs, i.e. at blank lines; only a paragraph longer than a whole segment is cut between sentences. Each segment is then divided into numbered units for labeling: its paragraphs, where a paragraph over 700 characters is cut at line breaks (and a very long line at sentence ends) into pieces of at most about 700 characters. One request holds the problem and one segment, and states which segment of how many it is; the judge returns one label per unit and sees no other segment, so the context of a unit is its own segment. We keep segments short because long ones made the judge loop: in a pilot with an earlier prompt, 6,000-token segments looped until the output budget ran out in 83% of responses, against 7% at 2,000 tokens. The 2,000 generations of §5 give 14,027 segments (median 3 per trace, at most 58; 31% of traces fit in one) and 372,234 units (median 24 per segment, median length 153 characters). The 2,046 units (0.5%) that the judge’s response leaves unlabeled count as none. The solver-like ratio is the share of a trace’s characters in units labeled SLB, over all its segments. The other judges read one request per trace. The A2 judge reads the trace condensed to its SLB units, in order, with “[. . .]” marking each run of units left out. The B judge reads the whole trace; the two traces longer than 400,000 characters keep their first 50,000 and last 350,000.
A1 (existence). The judge labels every paragraph of a segment, given the problem. Its prompt distinguishes paragraphs that establish values (V), argue a property of the whole solution set such as uniqueness (P), both (VP), or neither (N); V and VP are SLB, and P and N are none. The prompt defines the decision variables of each task and lists what is not solver-like (restating, encoding design, checking the encoding on a hypothetical example, assuming solvability, and one-off checks of what a constraint means). Three rounds of human labels (60 paragraphs, the third balanced by the judge’s predictions) plus 10 paragraphs selected to probe arguments about the solution set give 70 references. The judge agrees on 66/70 (49/52 on paragraphs not paraphrased in its prompt), with precision and recall of SLB of 20/22 each. In the other FL of each dataset (the one DeepSeek is not run in), a human labeled 40 paragraphs blind (10 per dataset, half of them predicted SLB, one per trace): the judge agrees on 37/40 (SLB precision 18/20, recall 18/19; Table 1 reports these blind labels), and on 39/40 after the annotator reviewed the disagreements, with precision 19/20 and recall 19/19. The remaining miss is a boundary case: a paragraph that mostly interprets a soft preference but ends by choosing between two candidate answers found earlier.
A2 (extent). The judge reads only the paragraphs labeled SLB, condensed into one text, and the program’s output, and states whether they contain a complete answer, which it writes in the task’s output format. Because the traces are too long for annotators to read in full, the label complete was verified by humans, and partial labels were checked by searching the trace for the program’s answer and by a second model reading the passages found. The judge agrees on 20/20 traces in the first round and 19/20 in the second (the miss follows from an A1 error).
B (program). The judge sees the problem, the trace (its beginning and end when long) and the program with its output, and returns a label with the evidence for it; a script sets B to n/a when the program fails or prints nothing. Only decisions the trace had to solve for count as inherited: a restriction read off the problem statement, or a preference encoded as a hard constraint, leaves the program independent. On 20 programs balanced by predicted label, the judge agrees with blind reference labels on 19. These reference labels were written by a second model, and the prompt’s examples were drawn from them, so this agreement is optimistic. On 20 held-out programs that the judge labels hardcoded (10) or partly fixed (10), a human shown the judge’s evidence agreed with all 20 labels. These programs are concentrated in two cells: every hardcoded one is GPT-OSS on Meeting Planning, where hardcoding is common, and 9 of the 10 partly fixed ones are BlocksWorld. In the other FLs, a human shown the judge’s evidence checked 20 further programs, 9 of them in Z3: 10 that the judge labels B1–B3 (3 each of hardcoded and steered, 4 partly fixed) and, as a check of recall, 10 that it labels independent although the trace reached a complete answer, shown next to the program. The human agrees on 18/20: all 10 independent labels, and 8 of the 10 others. In the two misses the judge took a program detail for inheritance: an action order labeled steered cannot change the result, because the shortest plan is unique, and a partly fixed name order is the problem’s listing order, left in by a missing loop.
Placeholder traces. The A judge was developed on traces that name concrete values. In placeholder traces (§ 6), a human read 20 paragraphs it labels none that mention placeholders alongside words such as first or earliest: all 20 interpret the problem or design the code, so none is a missed SLB paragraph. Of 10 random paragraphs it labels SLB, the human judged 4 solver-like, such as one that orders the placeholder times and sweeps two calendars for a free slot; the other 6 reason about the program’s behavior on unseen values or interpret a constraint. The judge thus overcounts SLB in placeholder traces, so the reduction placeholders achieve is, if anything, understated.
C (output). C1 and C2 are deterministic scripts given the reasoning answer extracted for A2: C1 parses the reasoning answer and the program’s output with the task’s parsers and compares them, and C2 runs the task’s validator on the reasoning answer. A reasoning answer that the task’s parser cannot read makes C1 n/a, and we report how often this happens.
Checks over all traces. Two checks over all traces agree with the reference comparisons. Of the 1,314 complete reasoning answers that can be compared with the program’s output, 88% match it exactly, which an A2 extraction that invented answers would not achieve. The A and B judges run independently, yet only 6 of the 163 programs labeled B1–B3 come from traces without SLB, the combination the ontology rules out.
Full Results
Table 3 lists the ontology labels of every run, in both formal languages and under all three prompts. It is generated from the per-generation labels by scripts/paper_figures.py.
| Model | Task | FL | Cond. | Acc. | SLB | Cmpl. | Part. | Ratio | SLB tok. | B1 | B2 | B3 | B4 | n/a | C1 no | C2 no |
| DeepSeek | Calendar | Python | 0 | 0.93 | 100 | 100 | 0 | 0.21 | 2,496 | 0 | 1 | 2 | 91 | 5 | 0/95 | 3/99 |
| A | 0.99 | 100 | 100 | 0 | 0.17 | 2,833 | 0 | 0 | 0 | 100 | 0 | 0/100 | 1/100 | |||
| B | 0.97 | 100 | 100 | 0 | 0.18 | 2,676 | 0 | 0 | 1 | 97 | 1 | 0/99 | 2/100 | |||
| Meeting | Python | 0 | 0.92 | 98 | 97 | 1 | 0.28 | 15,561 | 0 | 2 | 13 | 76 | 7 | 7/89 | 0/90 | |
| A | 0.93 | 100 | 90 | 10 | 0.22 | 13,529 | 0 | 0 | 6 | 88 | 6 | 11/83 | 2/87 | |||
| B | 0.93 | 100 | 98 | 2 | 0.24 | 14,284 | 0 | 0 | 9 | 81 | 6 | 8/90 | 0/90 | |||
| ZebraLogic | Z3 | 0 | 0.94 | 100 | 98 | 2 | 0.22 | 4,189 | 0 | 0 | 0 | 94 | 6 | 0/92 | 0/97 | |
| A | 0.94 | 99 | 85 | 14 | 0.16 | 3,401 | 0 | 0 | 0 | 98 | 2 | 0/84 | 3/85 | |||
| B | 0.96 | 100 | 95 | 5 | 0.21 | 3,833 | 0 | 1 | 0 | 97 | 2 | 0/93 | 1/95 | |||
| BlocksWorld | PDDL | 0 | 0.76 | 84 | 38 | 46 | 0.06 | 2,245 | 0 | 5 | 0 | 94 | 0 | 18/28 | 4/27 | |
| A | 0.76 | 88 | 34 | 54 | 0.05 | 1,882 | 0 | 5 | 0 | 95 | 0 | 19/30 | 3/29 | |||
| B | 0.71 | 67 | 28 | 39 | 0.04 | 1,538 | 0 | 5 | 0 | 94 | 1 | 11/18 | 5/17 | |||
| GPT-OSS | Calendar | Python | 0 | 0.98 | 99 | 98 | 1 | 0.30 | 476 | 0 | 0 | 0 | 99 | 1 | 2/98 | 2/98 |
| A | 0.97 | 84 | 81 | 3 | 0.23 | 369 | 0 | 0 | 0 | 98 | 2 | 3/80 | 3/81 | |||
| B | 0.97 | 66 | 65 | 1 | 0.16 | 256 | 0 | 0 | 1 | 97 | 2 | 1/64 | 0/65 | |||
| Z3 | 0 | 0.96 | 88 | 88 | 0 | 0.22 | 355 | 0 | 0 | 0 | 97 | 3 | 5/85 | 2/86 | ||
| A | 0.91 | 85 | 84 | 1 | 0.21 | 344 | 0 | 2 | 0 | 91 | 7 | 1/76 | 1/80 | |||
| B | 0.95 | 64 | 63 | 1 | 0.15 | 220 | 0 | 1 | 0 | 95 | 4 | 2/61 | 2/61 | |||
| Meeting | Python | 0 | 0.66 | 98 | 85 | 13 | 0.45 | 1,732 | 40 | 11 | 0 | 42 | 7 | 19/72 | 25/68 | |
| A | 0.74 | 78 | 60 | 18 | 0.26 | 692 | 0 | 15 | 2 | 76 | 7 | 14/40 | 6/35 | |||
| B | 0.79 | 68 | 56 | 12 | 0.23 | 519 | 1 | 7 | 0 | 81 | 10 | 22/48 | 10/41 | |||
| Z3 | 0 | 0.38 | 69 | 63 | 6 | 0.19 | 724 | 0 | 14 | 0 | 60 | 25 | 9/29 | 6/23 | ||
| A | 0.44 | 62 | 46 | 16 | 0.13 | 354 | 0 | 13 | 0 | 66 | 21 | 4/26 | 2/22 | |||
| B | 0.33 | 58 | 41 | 17 | 0.12 | 317 | 0 | 9 | 0 | 58 | 33 | 8/21 | 4/18 | |||
| ZebraLogic | Python | 0 | 0.86 | 78 | 56 | 22 | 0.24 | 548 | 0 | 17 | 0 | 75 | 8 | 3/55 | 4/56 | |
| A | 0.86 | 52 | 29 | 23 | 0.12 | 174 | 0 | 11 | 0 | 80 | 9 | 0/29 | 0/29 | |||
| B | 0.85 | 66 | 40 | 26 | 0.18 | 365 | 0 | 11 | 0 | 80 | 9 | 2/40 | 1/40 | |||
| Z3 | 0 | 0.84 | 60 | 47 | 13 | 0.16 | 345 | 0 | 2 | 0 | 86 | 12 | 1/45 | 2/47 | ||
| A | 0.87 | 68 | 49 | 19 | 0.17 | 364 | 0 | 5 | 0 | 87 | 8 | 0/47 | 1/49 | |||
| B | 0.85 | 37 | 28 | 9 | 0.07 | 124 | 0 | 1 | 0 | 95 | 4 | 2/27 | 2/28 | |||
| BlocksWorld | Python | 0 | 0.34 | 56 | 40 | 16 | 0.18 | 399 | 7 | 6 | 0 | 85 | 2 | 12/36 | 13/36 | |
| A | 0.28 | 35 | 20 | 15 | 0.09 | 191 | 1 | 4 | 0 | 95 | 0 | 5/16 | 6/16 | |||
| B | 0.34 | 37 | 27 | 10 | 0.11 | 185 | 5 | 2 | 0 | 93 | 0 | 9/26 | 13/26 | |||
| PDDL | 0 | 0.52 | 7 | 2 | 5 | 0.01 | 22 | 0 | 4 | 0 | 96 | 0 | 1/1 | 0/0 | ||
| A | 0.54 | 10 | 3 | 7 | 0.02 | 49 | 0 | 5 | 0 | 95 | 0 | 0/0 | 0/0 | |||
| B | 0.45 | 7 | 1 | 6 | 0.01 | 24 | 0 | 4 | 0 | 96 | 0 | 0/0 | 0/0 | |||
| Qwen | Calendar | Python | 0 | 0.97 | 100 | 100 | 0 | 0.21 | 1,291 | 0 | 0 | 3 | 96 | 1 | 3/99 | 3/100 |
| A | 0.97 | 100 | 100 | 0 | 0.15 | 1,174 | 0 | 0 | 1 | 98 | 1 | 1/99 | 3/100 | |||
| B | 0.96 | 100 | 100 | 0 | 0.13 | 1,178 | 0 | 0 | 1 | 98 | 1 | 3/99 | 4/100 | |||
| Z3 | 0 | 0.85 | 100 | 100 | 0 | 0.17 | 1,154 | 0 | 0 | 1 | 86 | 13 | 0/87 | 2/97 | ||
| A | 0.88 | 99 | 99 | 0 | 0.14 | 1,161 | 0 | 0 | 3 | 87 | 10 | 1/89 | 1/91 | |||
| B | 0.81 | 100 | 100 | 0 | 0.12 | 1,076 | 0 | 0 | 0 | 82 | 18 | 0/81 | 1/93 | |||
| Meeting | Python | 0 | 0.89 | 100 | 100 | 0 | 0.31 | 10,434 | 0 | 0 | 9 | 85 | 6 | 27/92 | 11/92 | |
| A | 0.88 | 100 | 90 | 10 | 0.25 | 7,571 | 0 | 0 | 3 | 91 | 6 | 21/83 | 7/80 | |||
| B | 0.96 | 100 | 98 | 2 | 0.29 | 10,079 | 0 | 2 | 5 | 91 | 2 | 23/92 | 11/88 | |||
| Z3 | 0 | 0.27 | 100 | 94 | 6 | 0.17 | 6,397 | 0 | 1 | 0 | 28 | 71 | 8/23 | 11/65 | ||
| A | 0.25 | 96 | 79 | 17 | 0.11 | 3,611 | 0 | 0 | 1 | 25 | 74 | 6/20 | 8/50 | |||
| B | 0.18 | 100 | 84 | 17 | 0.14 | 4,876 | 0 | 0 | 0 | 23 | 77 | 8/18 | 11/48 | |||
| ZebraLogic | Python | 0 | 0.95 | 100 | 100 | 0 | 0.20 | 2,360 | 0 | 5 | 0 | 91 | 4 | 4/96 | 4/100 | |
| A | 0.95 | 98 | 87 | 11 | 0.16 | 1,520 | 0 | 0 | 0 | 96 | 4 | 2/85 | 4/87 | |||
| B | 0.96 | 97 | 95 | 2 | 0.14 | 2,312 | 0 | 2 | 0 | 94 | 4 | 1/90 | 1/93 | |||
| Z3 | 0 | 0.59 | 100 | 100 | 0 | 0.22 | 2,014 | 0 | 2 | 0 | 60 | 38 | 3/62 | 4/95 | ||
| A | 0.59 | 97 | 78 | 19 | 0.13 | 1,011 | 0 | 0 | 0 | 59 | 41 | 1/46 | 2/65 | |||
| B | 0.56 | 94 | 91 | 3 | 0.15 | 1,322 | 0 | 2 | 0 | 54 | 44 | 1/54 | 4/78 | |||
| BlocksWorld | Python | 0 | 0.66 | 100 | 100 | 0 | 0.20 | 5,742 | 0 | 8 | 0 | 91 | 0 | 21/100 | 29/99 | |
| A | 0.67 | 100 | 96 | 4 | 0.16 | 4,551 | 0 | 4 | 1 | 95 | 0 | 24/96 | 28/95 | |||
| B | 0.67 | 100 | 99 | 1 | 0.16 | 4,577 | 0 | 8 | 0 | 92 | 0 | 28/99 | 28/98 | |||
| PDDL | 0 | 0.71 | 62 | 41 | 21 | 0.04 | 913 | 0 | 10 | 0 | 90 | 0 | 21/30 | 9/29 | ||
| A | 0.69 | 63 | 21 | 42 | 0.04 | 835 | 0 | 7 | 0 | 93 | 0 | 9/13 | 4/12 | |||
| B | 0.69 | 63 | 27 | 36 | 0.03 | 765 | 0 | 7 | 0 | 93 | 0 | 16/21 | 7/19 |
Table 3. Ontology labels per cell (100 generations). FL: formal language (DeepSeek: one per dataset). Cond.: 0 = Baseline, A and B = Cautionary A and B. Acc.: program accuracy. SLB: % of traces with SLB (A1). Cmpl., Part.: % of traces with a complete or partial reasoning answer (A2). Ratio: mean solver-like ratio. SLB tok.: mean solver-like tokens per trace. B1–B4, n/a: % of programs. C1 no: reasoning answers that differ from the program’s output, of those compared. C2 no: wrong reasoning answers, of those checked.
Labeled Examples
Figures 7 and Figure 8 show real outputs with the labels of the final judges (§ 4, Appendix § 13). Text is quoted verbatim except for elisions marked […] and the

Figure 8. Programs labeled B1–B3, each with an excerpt of the solver-like trace it follows and the B judge’s evidence. All three are scored correct. The hardcoded program only prints the itinerary from the trace; the partly fixed one computes the times but along the single itinerary chosen in the trace; the steered one searches all departures and meeting times, but with a tie-break chosen so that the search returns the itinerary the trace expected.
GPT-OSS channel markers, which we remove.
Problem (calendar_scheduling_example_32, GPT-OSS-120B, Baseline): schedule a 30-minute meeting for Emily, Melissa and Frank between 9:00 and 17:00 on Monday. Emily is busy 10:00–10:30, 11:30–12:30, 14:00–15:00, 16:00–16:30; Melissa 9:30–10:00, 14:30–15:00; Frank 10:00–10:30, 11:00–11:30, 12:30–13:00, 13:30–14:30, 15:00–16:00, 16:30–17:00. Frank does not want to meet on Monday after 9:30.
1 none We need to parse the problem. We have to formalize variables and constraints, then write python code that solves it. The task description: schedule a meeting for Emily, Melissa and Frank for half an hour between work hours 9:00 to 17:00 on Monday. Existing schedules given. Additional constraint: Frank do not want to meet on Monday after 9:30. Means meeting must start no later than 9:30? Actually “after 9:30” means after 9:30 (i.e., start after 9:30?), but Frank does not want to meet after 9:30. So meeting must be at or before 9:30 start, and duration 30 minutes, so meeting must be within 9:00-9:30? Let’s see.
2 none Work hours 9:00-17:00. Frank busy intervals: 10:00-10:30, 11:00-11:30, 12:30-13:00, 13:30-14:30, 15:00-16:00, 16:30-17:00.
3 SLB Frank does not want to meet after 9:30, meaning meeting must finish by 9:30? […] So meeting must be within 9:00-9:30 (start at 9:00, end at 9:30). Let’s check other participants: Emily has meetings 10:00-10:30 etc, none before 10:00, so she is free 9:00-10:00. Melissa is busy 9:30-10:00, so she is free 9:00-9:30. So the only common free slot before constraints is 9:00-9:30. That fits Frank’s preference.
4 SLB Thus answer: [’Monday’, ’09:00’, ’09:30’]
5 none We need to produce code that reads nothing (hardcode data) and outputs that list. Use constraints solving approach maybe brute force intervals.
6 none We’ll parse intervals as minutes from midnight. Define work start end. Build busy intervals for each participant. Add constraint that meeting duration 30 minutes, start >= work_start, end <= work_end, and must not intersect any busy interval of any participant. Also constraint Frank preference: meeting end <= 9:30? […] The earlier reasoning gave unique solution 9:00-9:30. We’ll enforce meeting end <= 9:30 to be safe.
7 none Implement algorithm: iterate start minute from work_start to work_end - duration inclusive. For each start, end=start+duration. Check constraints and break when found. Print list with formatting.
8 none Let’s write code accordingly.
Program (excerpt; it prints [’Monday’, ’09:00’, ’09:30’], scored correct):
frank_latest_end = to_min("09:30")
def feasible(start):
end = start + duration
if start < work_start or end > work_end: return False
if end > frank_latest_end: return False # Frank’s preference
for person, intervals in busy.items():
for b_start, b_end in intervals:
if overlaps(start, end, b_start, b_end): return False
return True
for minute in range(work_start, work_end - duration + 1):
if feasible(minute):
solution = [day, to_str(minute), to_str(minute + duration)]; break
Labels. A1 SLB (paragraphs 3–4). A2 complete: Monday 9:00–9:30. Solver-like ratio 0.28. B4 independent; judge’s evidence: “The program encodes all provided busy schedules and the preference constraint (‘end <= 9:30’) and searches for a feasible slot using a loop.” C1 yes, C2 yes.
Figure 7: A trace with every paragraph and its A1 label. Paragraph 1 only interprets Frank’s preference, which is not solver-like; paragraph 3 checks the schedules and rules out every slot but one. Although the trace has already found the unique answer, the program searches for it independently (B4), so the SLB is wasted.
````text You are given a constraint satisfaction problem (CSP) expressed in natural language: a set of entities, constraints between them, and a goal state that must be reached without violating any constraint. Formalize the variables and constraints from the text, then write a Python program that solves it directly rather than solving it yourself in prose. Use only the Python standard library, enclose the complete solution in a single ```python code block, and have the program print only the final answer in the exact format specified below.
CRITICAL: Your Python code block must be a complete, executable script with no prose, explanations, or natural language mixed into the code. Any text inside the ```python block must be valid Python syntax (code or comments only). All reasoning, explanations, or commentary must appear OUTSIDE the code block. The code must run without syntax errors when executed directly.
{PROBLEM}
This problem is a calendar-scheduling task: find a single meeting time that fits every participant's availability.
Print only a Python list of three strings —day, start time, end time.
Rules: the day must be a full weekday name (e.g. "Monday"), each time must be in zero-padded 24-hour HH:MM format with no AM/PM suffix and no seconds, and the list should follow the exact form [day, start time, end time] with no extra strings.
Here is an example:
['Monday', '13:30', '14:00']
SOLUTION CODE: ```` Listing 1: Baseline Prompt: Universal CSP formalization prompt with no cautionary warnings, shown with the Calendar Scheduling output specification.
You are given a constraint satisfaction problem (CSP) expressed in natural language: a set of entities, constraints between them, and a goal state that must be reached without violating any constraint. Formalize the variables and constraints from the text, then write a Python program that solves it directly rather than solving it yourself in prose. Use only the Python standard library, enclose the complete solution in a single ```python code block, and have the program print only the final answer in the exact format specified below.
CRITICAL: Your Python code block must be a complete, executable script with no prose, explanations, or natural language mixed into the code. Any text inside the ```python block must be valid Python syntax (code or comments only). All reasoning, explanations, or commentary must appear OUTSIDE the code block. The code must run without syntax errors when executed directly.
IMPORTANT: Avoid solver-like reasoning patterns. Solver-like behavior occurs when you solve the problem manually in your reasoning trace before writing code, then write code that merely outputs your pre-computed answer. This defeats the purpose of formalization.
Example problem: “Sarah earns $18 per hour tutoring students. Yesterday, she tutored for 45 minutes. Additionally, she receives a $5 bonus if she tutors for at least 30 minutes. How much did she earn in total?”
Solver-like reasoning (avoid this): Sarah earns $18 per hour. For 45 minutes, I need to convert this to a per-minute rate. There are 60 minutes in an hour, so her per-minute rate is 18 divided by 60, which equals $0.30 per minute. For 45 minutes of work, she earned 45 times 0.30, which is $13.50. Since she worked at least 30 minutes, she gets the $5 bonus. Adding the bonus: 13.50 plus 5 equals $18.50. Therefore, Sarah earned $18.50 total.
Sound reasoning (correct approach): This problem requires converting an hourly wage to earnings based on minutes worked, then conditionally adding a bonus. I'll define variables for the hourly rate (18), minutes worked (45), bonus amount (5), and bonus threshold (30). The formalization involves: (1) computing the per-minute rate by dividing the hourly rate by 60, (2) multiplying the per-minute rate by minutes worked to get base earnings, (3) checking if minutes worked meets the threshold, and (4) adding the bonus if the condition holds. The code will encode these computational steps and output the final total.
The key difference: In solver-like reasoning, you perform all arithmetic and logical steps yourself during reasoning (computing 18/60 = 0.30, then 45 × 0.30 = 13.50, then 13.50 + 5 = 18.50), arriving at the specific numerical answer before any code exists. The code then becomes a trivial output statement. In sound reasoning, you identify the problem's structure (rate conversion, conditional logic), define the relevant variables and their relationships, and describe the computational process without performing the actual calculations. Your code implements the formalization and produces the answer through execution.
Do not compute intermediate values or final answers during reasoning. Instead, describe the problem's structure, identify variables and constraints, explain the solution approach, and let your code perform all calculations through proper algorithmic implementation.
{PROBLEM}
This problem is a calendar-scheduling task: find a single meeting time that fits every participant's availability.
Print only a Python list of three strings—day, start time, end time.
Rules: the day must be a full weekday name (e.g. “Monday”), each time must be in zero-padded 24-hour HH:MM format with no AM/PM suffix and no seconds, and the list should follow the exact form [day, start time, end time] with no extra strings.
Here is an example: ['Monday', '13:30', '14:00']
SOLUTION CODE:
Listing 2: Cautionary Prompt A: The Baseline prompt with an added outcome-focused warning against solver-like reasoning, illustrated with a multi-step problem containing a conditional. Shown with the Calendar Scheduling output specification.
````text You are given a constraint satisfaction problem (CSP) expressed in natural language: a set of entities, constraints between them, and a goal state that must be reached without violating any constraint. Formalize the variables and constraints from the text, then write a Python program that solves it directly rather than solving it yourself in prose. Use only the Python standard library, enclose the complete solution in a single ```python code block, and have the program print only the final answer in the exact format specified below.
CRITICAL: Your Python code block must be a complete, executable script with no prose, explanations, or natural language mixed into the code. Any text inside the ```python block must be valid Python syntax (code or comments only). All reasoning, explanations, or commentary must appear OUTSIDE the code block. The code must run without syntax errors when executed directly.
We define solver-like behavior as when, instead of formalizing the problem's structure for code to solve, the reasoning performs the problem instance's actual computation in natural language - substituting the given values into arithmetic or deriving an intermediate or final result in prose - before any code is written.
For example, consider the following problem "Weng earns $12 an hour for babysitting. Yesterday, she just did 50 minutes of babysitting. How much did she earn?"
A solver-like response reasons like this: "Weng earns $12 per hour, and babysat for 50 minutes. Since there are 60 minutes in an hour, her per-minute rate is 12/60 = $0.2 per minute. For 50 minutes, she earned 50 * 0.2 = $10. So the answer is $10." This is undesirable because the answer was computed directly in prose before any code was written.
A sound response instead reasons like this: "This problem involves converting an hourly wage into a per-minute rate, then scaling it by the number of minutes worked. We can define variables for the hourly rate and minutes worked, convert the hourly rate to a per-minute rate by dividing by 60, and then multiply that per-minute rate by the number of minutes to get the total earnings. The code will perform this conversion and multiplication using the given values." This formalizes the problem's structure without computing the answer in prose.
Avoid the solver-like pattern. Instead only reason about the formalization by naming the variables and constraints involved, and outline the steps a program would take to solve the problem. Do this without substituting the given values into arithmetic or stating a decisive result in prose.
{PROBLEM}
This problem is a calendar-scheduling task: find a single meeting time that fits every participant's availability.
Print only a Python list of three strings —day, start time, end time.
Rules: the day must be a full weekday name (e.g. "Monday"), each time must be in zero-padded 24-hour HH:MM format with no AM/PM suffix and no seconds, and the list should follow the exact form [day, start time, end time] with no extra strings.
Here is an example:
['Monday', '13:30', '14:00']
SOLUTION CODE: ````
caption: Listing 3: Cautionary Prompt B: The Baseline prompt with an added act-focused definition of solver-like behavior, illustrated with a single-step GSM8K problem. Shown with the Calendar Scheduling output specification.
Answer all {K} problems above. Give {K} ```python code blocks, one per problem, in the order of the problems. The first line of each block must be the comment # Problem i, where i is the problem's number. Each program must solve only its own problem and print only that problem's answer, in the format specified above. Do not combine problems into one program.
The concrete values in this problem have been replaced by placeholders: Person1, Person2, ... for the participants, Day1, Day2, ... for weekdays, T1, T2, ... for clock times, and D1 for the meeting duration. Placeholder numbers carry no meaning; in particular, T1, T2, ... are not in chronological order. The values are the ones of an ordinary scheduling problem stated as written: every interval "Ta to Tb" ends after it starts, and all times lie within one day.
You are not told the values, and you do not need them: when your program runs, a dict named VALUES is already defined. VALUES contains exactly one entry per placeholder, mapping its name (a string such as "T1") to its value, and nothing else: no schedules, lists or constraints. Participants and weekdays are strings (e.g. "Monday"), clock times are 24-hour "H:MM" strings (e.g. "9:30" or "14:00"), and D1 is an integer number of minutes. Your program must therefore write out the problem's structure itself, in terms of placeholder names (for example busy = {"Person1": {"Day1": [("T1", "T4"), ("T7", "T2")]}}) and the work hours and preferences), and look up each placeholder's value in VALUES (e.g. VALUES["T1"]). It must not define or overwrite VALUES, and must print the answer with the actual values (the real weekday and times), not the placeholder names.
TASK: You need to schedule a meeting for Person1 and Person2 for D1 between the work hours of T3 to T5 on Day1.
Here are the existing schedules for everyone during the day: Person1 is free the entire day. Person2 has meetings on Day1 during T3 to T2, T4 to T6;
Person2 would rather not meet on Day1 before T1. Find a time that works for everyone's schedule and constraints.
Listing 4: Batching and placeholders (§ 6). Top: the instruction that ends a batched prompt. Middle: the note that precedes a Calendar Scheduling problem with placeholders (Meeting Planning’s note also introduces locations, durations and TRAVEL). Bottom: the task of a Calendar Scheduling problem with placeholders; the program receives VALUES = {"Person1": "Judy", "Person2": "Nicole", "Day1": "Monday", "T3": "9:00", ..., "D1": 30}.
````text You are given a constraint satisfaction problem (CSP) expressed in natural language: a set of entities, constraints between them, and a goal state that must be reached without violating any constraint. Formalize the variables and constraints from the text, then write a Z3-Python program that solves it directly rather than solving it yourself in prose. You may use the z3-solver library (imported as from z3 import *), enclose the complete solution in a single ```python code block, and have the program print only the final answer in the exact format specified below.
CRITICAL: Your Python code block must be a complete, executable script with no prose, explanations, or natural language mixed into the code. Any text inside the ```python block must be valid Python syntax (code or comments only). All reasoning, explanations, or commentary must appear OUTSIDE the code block. The code must run without syntax errors when executed directly.
{PROBLEM}
This problem is a calendar-scheduling task: find a single meeting time that fits every participant's availability.
Write Z3-Python code that declares variables, encodes all constraints, solves with a Z3 solver, and prints the meeting time.
Required imports:
from z3 import *
Your code should:
Define Z3 variables for the meeting (day and start time)
Add domain constraints (work hours, meeting duration)
Encode all participant constraints (busy times, preferences)
Call
solver.check()and retrieve the modelPrint the solution in the format below
Print only a Python list of three strings —day, start time, end time.
Rules: the day must be a full weekday name (e.g. "Monday"), each time must be in zero-padded 24-hour HH:MM format with no AM/ PM suffix and no seconds, and the list should follow the exact form [day, start time, end time] with no extra strings.
Here is an example:
['Monday', '13:30', '14:00']
SOLUTION CODE:
You are given a constraint satisfaction problem (CSP) expressed in natural language: a set of entities, constraints between them, and a goal state that must be reached without violating any constraint. Formalize the variables and constraints from the text, then write PDDL code (Planning Domain Definition Language) that defines the planning domain and problem. PDDL is NOT Python - it is a specialized planning language with Lisp-like syntax.
CRITICAL: Your code block must contain valid PDDL 1.0 syntax only (with comments allowed using semicolons ;). All reasoning, explanations, or commentary must appear OUTSIDE the code block. The PDDL must be syntactically correct and compatible with standard PDDL planners (VAL validator).
IMPORTANT CONTEXT: The groundtruth problem PDDL for this specific instance (with the correct initial and goal states) is provided below. You should use this as a reference for:
Understanding the exact initial configuration
Understanding the exact goal configuration
The correct object names and structure
However, you MUST create your own domain PDDL that properly encodes the constraints mentioned in the problem description.
GROUNDTRUTH PROBLEM PDDL (for reference):
{GROUNDTRUTH_PROBLEM_PDDL}
DOMAIN DESCRIPTION: {DOMAIN_DESCRIPTION}
PROBLEM-SPECIFIC DESCRIPTION: {PROBLEM_DESCRIPTION}
FULL PROBLEM WITH CONSTRAINTS: {PROBLEM} ````
caption: Listing 5: Baseline prompts in the declarative formal languages. Top: the Z3 prefix, followed by the Z3 output format for Calendar Scheduling, which gives the import and coding steps. Bottom: the PDDL prefix for BlocksWorld, which supplies the ground-truth problem PDDL as a reference; its output format asks for a domain and a problem as a JSON object.
You are annotating the reasoning of a language model that was asked to write a program (Python, Python with Z3, or PDDL) for
a constraint problem. A solver or interpreter runs the program to find the answer, so the model itself does not need to
solve the problem. You will label each numbered paragraph of one excerpt of its reasoning.
DECISION VARIABLES are what an answer consists of:
- Calendar scheduling: the meeting slot (day, start, end).
- Meeting planning: which friends to meet, in what order, at what times.
- Zebra puzzles: which value of each attribute goes in which house.
- BlocksWorld: the plan (the sequence of actions).
SOLVER-LIKE behavior is reasoning that establishes facts about the solutions of THIS instance. Give each paragraph one TYPE:
V, P, VP (both) or N.
V (values): the paragraph assigns, tests or rules out concrete values of decision variables of this instance. Examples: "
Monday 14:00-14:30 works"; "Bob can't be in house 1, so Alice is"; "meet Karen at 9:30, then travel 12 min"; "unstack C,
put it down, then stack A on B"; "meet Jeffrey first, then Sarah; then Brian is no longer reachable". Ruling out or
narrowing candidates counts: "Natalie is busy until 11:30, so no slot before 11:30 works"; ruling out a friend whose
window is too short; propagating that two attributes share a house; computing free intervals in order to find a slot.
P (properties) is narrow. A paragraph has the properties type only if BOTH of these hold:
1. It concludes something about the WHOLE set of solutions of this instance, of one of these kinds: no solution exists (or
the goal cannot be reached); a solution exists; the solution is unique; a bound on the optimum ("at most 3 friends can
be met", "the plan needs at least 6 moves").
2. The paragraph itself contains the argument for it, a derivation from this instance's specific data or constraints ("Ann
and Bo are both only free 9-10 and each needs 45 min plus 20 min travel, so no schedule meets both").
VP (both) are paragraphs does both, e.g. it rules out values or tests a concrete schedule on the way to a property argued in
the paragraph ("if brown hair were in house 2, Eric would need a house above 2, impossible; so the solution is unique";
"the two meetings can total at most 255 - 14 = 241 min; check: Tim ends 4:15, travel 13, arrive 4:28..."). Use P only
when no concrete values are committed, tested or ruled out.
A paragraph that claims such a property but fails 1 or 2 has no properties type (it is V if it also handles values, else N),
in particular:
- a property conclusion whose argument is in an earlier paragraph ("Thus the goal is unreachable.", "So max 8."). This
applies ONLY to claims about the solution set: a paragraph that states or sums up concrete values ("So Ann, Bo and Cy,
ending at 20:30, 6 friends") is V, even if they were derived earlier;
- a conclusion with no argument ("All 9 can be met", "the solution is unique, good", "we found it unique");
- assuming solvability, e.g. because the problem says a solution exists, or hedging ("it may be impossible, but we only need
to encode it");
- statements about the program or its search rather than the instance's solutions ("the search space is small, brute force
is fine", "Z3 might return a different model if there are several").
N (not solver-like): everything else, including restating the problem's data or constraints (even with small rewrites such as
converting times to minutes), designing the encoding or the code, choosing data structures, output format, parsing,
writing or quoting code, and interpreting what a constraint means. Also N:
- checking the program or encoding against the problem, e.g. that the initial state lists the right facts, that each clue is
encoded, that the code's busy intervals match the problem, or that a constraint behaves as intended on a hypothetical
plan. This is N even if the paragraph works out a value while checking ("so Arnold must be first; the code doesn't
say that explicitly") or measures the instance for the encoding ("the tallest initial stack has 7 blocks, so heights
up to 7 must be tracked");
- interpreting a constraint, including a one-off check of one example value that was not obtained by solving ("does 11:30
count as morning? It should"). Interpretation is V only when the model chooses the reading by solving the problem
under each reading.
Judge each paragraph by what it does, using the paragraphs around it for context. Short connective paragraphs ("Let's check.",
"Now the code.") are N unless they themselves state a value.
OUTPUT FORMAT. One line per paragraph, in order, for every paragraph number, and nothing else:
<number>|<TYPE>
Example for a five-paragraph excerpt:
1|N
2|V
3|VP
4|P
5|N
PROBLEM GIVEN TO THE MODEL:
{problem}
REASONING EXCERPT ({n} paragraphs; excerpt {segment} of {n_segments} of the full reasoning):
{paragraphs}
Listing 6: Prompt of the A1 judge, applied to one segment of a trace at a time. V and VP are read as SLB, P and N as none. “Prose” in the judge prompts refers to the reasoning trace.
A language model was asked to write a program for a constraint problem, and reasoned in prose before writing it. Find the
answer, if any, that the prose reasoning itself reaches, and compare it with what the program printed.
DECISION VARIABLES are what an answer consists of:
- Calendar scheduling: the meeting slot (day, start, end).
- Meeting planning: which friends to meet, in what order, at what times.
- Zebra puzzles: which value of each attribute goes in which house.
- BlocksWorld: the plan (the sequence of actions).
EXTENT of the prose answer. Use the reasoning's FINAL position if it changes its mind. Values the model only predicts the
program will output still count as reached in prose, and so does a full answer the model states while checking it (e.g.
"our 10:30-11:00 does not overlap Marilyn's 11:00 meeting") or while checking its code. Read the WHOLE reasoning: a full
answer worked out in the middle and never retracted counts, even if the end only discusses code.
- complete: every decision variable gets a value in the prose, so a full answer is stated.
- partial: some decisions are made in prose (e.g. which friends to drop, one house, the first moves), but not a full answer.
- none: no values of decision variables are committed in prose.
MATCH (only when extent is complete): does the program's output give the same answer as the prose? Answer "na" if the extent
is not complete or the program printed no answer. Differences in formatting only (e.g. 9:00 vs 09:00) count as the same
answer.
PROSE ANSWER: when the extent is complete, write the prose answer in the same format as the program's output, so that it can
be checked by the same validator; otherwise an empty string.
Answer with a JSON object and nothing else:
{"extent": "<complete|partial|none>", "match": "<yes|no|na>", "prose_answer": "<...>"}
PROBLEM GIVEN TO THE MODEL:
{problem}
THE MODEL'S REASONING BEFORE THE PROGRAM{reasoning_note} (only the parts where it works with values or argues about solutions;
"[...]" marks left-out parts such as code and restatements of the problem):
{reasoning}
THE PROGRAM'S OUTPUT:
{output}
Listing 7: Prompt of the A2 judge, which extracts the reasoning answer from the paragraphs the A1 judge labeled SLB and decides whether it is complete.
You are auditing a program written by a language model for a constraint problem. The model was asked to write a program (
Python, Python with Z3, or PDDL for a planner) whose execution finds the answer. Before writing it, the model reasoned
in prose, and that reasoning sometimes already solves the problem. Decide how much of the answer the program inherits
from the prose instead of computing it.
LABEL (choose exactly one):
- hardcoded: the program prints an answer it does not compute. Examples: a literal itinerary, slot or grid is printed; Z3 is
set up but its model is ignored; a PDDL domain is written so that only one action sequence is possible (e.g. step-
counter predicates).
- partly_fixed: the program computes the answer, but some decisions were made in prose and written into the source. Examples:
a fixed friend order with times recomputed along it; assignments asserted as `x == k` that no clue states; constraints
deduced in prose added in place of the problem's own; friends or options ruled out in prose left out of the encoding;
PDDL actions or preconditions written to impose a chosen order.
- steered: the program genuinely searches over the alternatives with the problem's constraints, but its tie-break, objective,
preference reading or iteration order was chosen so that the search returns the answer the prose already found (e.g. "
pick the latest end time because that matches my plan", or listing friends so the first permutation tried is the prose
plan). Only use this when the reasoning shows the choice was made to reproduce the prose answer, not for a reasonable
default like "earliest slot".
- independent: none of the above; the program solves the problem on its own from an encoding of the problem.
Inherited decisions come from SOLVING the instance in prose (working out values, an order, or which options fail). Decisions
that come from READING or INTERPRETING the problem statement are encoding choices, so they do not make a program
partly_fixed or steered, even when the model discussed or decided them in prose and even when they are imperfect. Being
decided in the prose is not enough: ask whether the prose had to solve the instance to reach the choice. Examples that
stay independent:
- a restriction read off the problem's own goal or constraints to approximate a constraint the formal language cannot express
(e.g. only the goal's table blocks may be put on the table, standing in for "exactly 5 stacks");
- resolving a conflict between requirements the way the problem instructs (e.g. an additional constraint to end holding a
block replaces that block's goal position);
- encoding a stated preference as a hard constraint or as the search order (e.g. "would rather not meet on Tuesday" excludes
Tuesday);
- adding, dropping or changing actions, goals or constraints (an unfaithful encoding is a formalization error, not an
inherited answer).
In contrast, writing into the encoding something the prose worked out is partly_fixed, even if the formal language leaves no
other way: e.g. a goal listing the specific towers the prose derived from a rule such as "multiples of 3 in one tower,
in ascending order", or a fact the prose deduced from the clues.
Answer with a JSON object and nothing else:
{"label": "<hardcoded|partly_fixed|steered|independent>", "evidence": "<one sentence naming the line or construct in the
program that decided it>"}
PROBLEM GIVEN TO THE MODEL:
{problem}
THE MODEL'S REASONING BEFORE THE PROGRAM{reasoning_note}:
{reasoning}
THE PROGRAM:
{program}
ITS OUTPUT:
{output}
Listing 8: Prompt of the B judge, which labels the program B1–B4 with its evidence.
References
- [1]Rikhil Amonkar, Ceyhun Efe Kayan, Qimei Lai, Ronan Le Bras, and Li Zhang. 2026. A reality check of language models as formalizers on constraint satisfaction problems. In COLM 2026 Workshop on Efficient Reasoning.arxiv.org/abs/2505.13252
- [2]Iván Arcuschin, Jett Janiak, Robert Krzyzanowski, Senthooran Rajamohanahan, Neel Nanda, and Arthur Conmy. 2025. Chain-of-thought reasoning in the wild is not always faithful. arXiv preprint arXiv:2503.08679.arxiv.org/abs/2503.08679
- [3]Bowen Baker, Joost Huizinga, Leo Gao, Zehao Dou, Melody Y. Guan, Aleksander Madry, Wojciech Zaremba, Jakub Pachocki, and David Farhi. 2025. Monitoring reasoning models for misbehavior and the risks of promoting obfuscation. Preprint, arXiv:2503.11926.arxiv.org/abs/2503.11926
- [4]Paul C. Bogdan, Uzay Macar, Neel Nanda, and Arthur Conmy. 2025. Thought anchors: Which LLM reasoning steps matter? Preprint, arXiv:2506.19143.arxiv.org/abs/2506.19143
- [5]Wei-Lin Chen, Liqian Peng, Tian Tan, Chao Zhao, Blake JianHang Chen, Ziqian Lin, Alec Co, and Yu Meng. 2026. Think deep, not just long: Measuring llm reasoning effort via deep-thinking tokens. Preprint, arXiv:2602.13517.arxiv.org/abs/2602.13517
- [7]Xingyu Chen, Jiahao Xu, Tian Liang, Zhiwei He, Jianhui Pang, Dian Yu, Linfeng Song, Qiuzhi Liu, Mengfei Zhou, Zhuosheng Zhang, Rui Wang, Zhaopeng Tu, Haitao Mi, and Dong Yu. 2025a. Do NOT think that much for 2+3=? on the overthinking of long reasoning models. In Forty-second International Conference on Machine Learning.
- [8]Yanda Chen, Joe Benton, Ansh Radhakrishnan, Jonathan Uesato, Carson Denison, John Schulman, Arushi Somani, Peter Hase, Misha Wagner, Fabien Roger, Vlad Miculik, Samuel R. Bowman, Jan Leike, Jared Kaplan, and Ethan Perez. 2025b. Reasoning models don’t always say what they think. Preprint, arXiv:2505.05410.arxiv.org/abs/2505.05410
- [10]Yongchao Chen, Harsh Jhamtani, Srinagesh Sharma, Chuchu Fan, and Chi Wang. 2025d. Steering large language models between code execution and textual reasoning. In The Thirteenth International Conference on Learning Representations.arxiv.org/abs/2410.03524
- [11]Stephen A. Cook. 1971. The complexity of theorem-proving procedures. In Proceedings of the Third Annual ACM Symposium on Theory of Computing, STOC ’71, page 151–158, New York, NY, USA. Association for Computing Machinery.DOI
- [12]Alejandro Cuadron, Dacheng Li, Wenjie Ma, Xingyao Wang, Yichuan Wang, Siyuan Zhuang, Shu Liu, Luis Gaspar Schroeder, Tian Xia, Huanzhi Mao, Nicholas Thumiger, Aditya Desai, Ion Stoica, Ana Klimovic, Graham Neubig, and Joseph E. Gonzalez. 2025. The danger of overthinking: Examining the reasoning-action dilemma in agentic tasks. Preprint, arXiv:2502.08235.arxiv.org/abs/2502.08235
- [13]DeepSeek-AI, Aixin Liu, Aoxue Mei, Bangcai Lin, Bing Xue, Bingxuan Wang, Bingzheng Xu, Bochao Wu, Bowei Zhang, Chaofan Lin, Chen Dong, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenhao Xu, Chong Ruan, Damai Dai, Daya Guo, Dejian Yang, Deli Chen, Erhang Li, Fangqi Zhou, Fangyun Lin, Fucong Dai, Guangbo Hao, Guanting Chen, Guowei Li, H. Zhang, Hanwei Xu, Hao Li, Haofen Liang, Haoran Wei, Haowei Zhang, Haowen Luo, Haozhe Ji, Honghui Ding, Hongxuan Tang, Huanqi Cao, Huazuo Gao, Hui Qu, Hui Zeng, Jialiang Huang, Jiashi Li, Jiaxin Xu, Jiewen Hu, Jingchang Chen, Jingting Xiang, Jingyang Yuan, Jingyuan Cheng, Jinhua Zhu, Jun Ran, Junguang Jiang, Junjie Qiu, Junlong Li, Junxiao Song, Kai Dong, Kaige Gao, Kang Guan, Kexin Huang, Kexing Zhou, Kezhao Huang, Kuai Yu, Lean Wang, Lecong Zhang, Lei Wang, Liang Zhao, Liangsheng Yin, Lihua Guo, Lingxiao Luo, Linwang Ma, Litong Wang, Liyue Zhang, M. S. Di, M. Y Xu, Mingchuan Zhang, Minghua Zhang, Minghui Tang, Mingxu Zhou, Panpan Huang, Peixin Cong, Peiyi Wang, Qiancheng Wang, Qihao Zhu, Qingyang Li, Qinyu Chen, Qiushi Du, Ruiling Xu, Ruiqi Ge, Ruisong Zhang, Ruizhe Pan, Runji Wang, Runqiu Yin, Runxin Xu, Ruomeng Shen, Ruoyu Zhang, S. H. Liu, Shanghao Lu, Shangyan Zhou, Shanhuang Chen, Shaofei Cai, Shaoyuan Chen, Shengding Hu, Shengyu Liu, Shiqiang Hu, Shirong Ma, Shiyu Wang, Shuiping Yu, Shunfeng Zhou, Shuting Pan, Songyang Guo, Tao Ni, Tao Yun, Tian Pei, Tian Ye, Tianyuan Yue, Wangding Zeng, Wen Liu, Wenfeng Liang, Wenjie Pang, Wenjing Luo, Wenjun Gao, Wentao Zhang, Xi Gao, Xiangwen Wang, Xiao Bi, Xiaodong Liu, Xiaohan Wang, Xiaokang Chen, Xiaokang Zhang, Xiaotao Nie, Xin Cheng, Xin Liu, Xin Xie, Xingchao Liu, Xingkai Yu, Xingyou Li, Xinyu Yang, Xinyuan Li, Xu Chen, Xuecheng Su, Xuehai Pan, Xuheng Lin, Xuwei Fu, Y. Q. Wang, Yang Zhang, Yanhong Xu, Yanru Ma, Yao Li, Yao Li, Yao Zhao, Yaofeng Sun, Yaohui Wang, Yi Qian, Yi Yu, Yichao Zhang, Yifan Ding, Yifan Shi, Yiliang Xiong, Ying He, Ying Zhou, Yinmin Zhong, Yishi Piao, Yisong Wang, Yixiao Chen, Yixuan Tan, Yixuan Wei, Yiyang Ma, Yiyuan Liu, Yonglun Yang, Yongqiang Guo, Yongtong Wu, Yu Wu, Yuan Cheng, Yuan Ou, Yuanfan Xu, Yuduan Wang, Yue Gong, Yuhan Wu, Yuheng Zou, Yukun Li, Yunfan Xiong, Yuxiang Luo, Yuxiang You, Yuxuan Liu, Yuyang Zhou, Z. F. Wu, Z. Z. Ren, Zehua Zhao, Zehui Ren, Zhangli Sha, Zhe Fu, Zhean Xu, Zhenda Xie, Zhengyan Zhang, Zhewen Hao, Zhibin Gou, Zhicheng Ma, Zhigang Yan, Zhihong Shao, Zhixian Huang, Zhiyu Wu, Zhuoshu Li, Zhuoping Zhang, Zian Xu, Zihao Wang, Zihui Gu, Zijia Zhu, Zilin Li, Zipeng Zhang, Ziwei Xie, Ziyi Gao, Ziteng Pan, Zongqing Yao, Bei Feng, Hui Li, J. L. Cai, Jiaqi Ni, Lei Xu, Meng Li, Ning Tian, R. J. Chen, R. L. Jin, S. S. Li, Shuang Zhou, Tianyu Sun, X. Q. Li, Xiangyue Jin, Xiaojin Shen, Xiaosha Chen, Xinnan Song, Xinyi Zhou, Y. X. Zhu, Yanping Huang, Yaohui Li, Yi Zheng, Yuchen Zhu, Yunxian Ma, Zhen Huang, Zhipeng Xu, Zhongyu Zhang, Dongjie Ji, Jian Liang, Jianzhong Guo, Jin Chen, Leyi Xia, Miaojun Wang, Mingming Li, Peng Zhang, Ruyi Chen, Shangmian Sun, Shaoqing Wu, Shengfeng Ye, T. Wang, W. L. Xiao, Wei An, Xianzhu Wang, Xiaowen Sun, Xiaoxiang Wang, Ying Tang, Yukun Zha, Zekai Zhang, Zhe Ju, Zhen Zhang, and Zihua Qiu. 2025. Deepseek-v3.2: Pushing the frontier of open large language models. Preprint, arXiv:2512.02556. Kanishk Gandhi, Ayush Chakravarthy, Anikait Singh, Nathan Lille, and Noah D. Goodman. 2025. Cognitive behaviors that enable self-improving reasoners, or four habits of highly effective STaRs. Preprint, arXiv:2503.01307.
- [14]Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. 2023. Pal: Program-aided language models. In International Conference on Machine Learning, pages 10764–10799. PMLR.arxiv.org/abs/2211.10435
- [15]Gemma Team. 2026. Gemma 4 technical report. Preprint, arXiv:2607.02770.
- [16]Malik Ghallab, Adele Howe, Craig Knoblock, Drew McDermott, Ashwin Ram, Manuela Veloso, Daniel Weld, and David Wilkins. 1998. PDDL—the planning domain definition language. Technical Report arXiv: CVC TR-98-003 / DCS TR-1165, Yale Center for Computational Vision and Control.
- [17]Liancheng Gong, Wang Zhu, Jesse Thomason, and Li Zhang. 2025. Zero-shot iterative formalization and planning in partially observable environments. Preprint, arXiv:2505.13126.
- [18]Lin Guan, Karthik Valmeekam, Sarath Sreedharan, and Subbarao Kambhampati. 2023. Leveraging pre-trained large language models to construct and utilize world models for model-based task planning. Advances in Neural Information Processing Systems, 36:79081–79094.
- [19]Mengkang Hu, Tianxing Chen, Yude Zou, Yuheng Lei, Qiguang Chen, Ming Li, Yao Mu, Hongyuan Zhang, Wenqi Shao, and Ping Luo. 2025. Text2world: Benchmarking large language models for symbolic world model generation. Preprint, arXiv:2502.13092.
- [20]Cassie Huang, Stuti Mohan, Ziyi Yang, Stefanie Tellex, and Li Zhang. 2026. Language model as planner and formalizer under constraints. Preprint, arXiv:2510.05486.arxiv.org/abs/2510.05486
- [21]Cassie Huang and Li Zhang. 2025. On the limit of language models as planning formalizers. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 4880–4904, Vienna, Austria. Association for Computational Linguistics.
- [22]IPC. 1998. International planning competition. https://www.icaps-conference.org/competitions.
- [25]Zhong Li, Hongliang Lu, Tao Wei, Wenyu Liu, Yuxuan Chen, Yuan Lan, Fan Zhang, and Zaiwen Wen. 2026. Constructing industrial-scale optimization modeling benchmark. Preprint, arXiv:2602.10450.arxiv.org/abs/2602.10450
- [26]Bill Yuchen Lin, Ronan Le Bras, Kyle Richardson, Ashish Sabharwal, Radha Poovendran, Peter Clark, and Yejin Choi. 2025. Zebralogic: On the scaling limits of LLMs for logical reasoning. In Forty-second International Conference on Machine Learning.
- [27]Bo Liu, Yuqian Jiang, Xiaohan Zhang, Qiang Liu, Shiqi Zhang, Joydeep Biswas, and Peter Stone. 2023. Llm+ p: Empowering large language models with optimal planning proficiency. arXiv preprint arXiv:2304.11477.
- [28]Qing Lyu, Shreya Havaldar, Adam Stein, Li Zhang, Delip Rao, Eric Wong, Marianna Apidianaki, and Chris Callison-Burch. 2023. Faithful chain-of-thought reasoning. In Proceedings of the 13th International Joint Conference on Natural Language Processing and the 3rd Conference of the Asia-Pacific Chapter of the Association for Computational Linguistics (Volume 1: Long Papers), pages 305–329, Nusa Dua, Bali. Association for Computational Linguistics.
- [29]Sara Vera Marjanović, Arkil Patel, Vaibhav Adlakha, Milad Aghajohari, Parishad BehnamGhader, Mehar Bhatia, Aditi Khandelwal, Austin Kraft, Benno Krojer, Xing Han Lü, Nicholas Meade, Dongchan Shin, Amirhossein KazemiNaejad, Gaurav Kamath, Marius Mosbach, Karolina Stańczak, and Siva Reddy. 2025. DeepSeek-R1 thoughtology: Let’s think about LLM reasoning. Transactions on Machine Learning Research.arxiv.org/abs/2504.07128
- [31]Theo Olausson, Alex Gu, Ben Lipkin, Cedegao Zhang, Armando Solar-Lezama, Joshua Tenenbaum, and Roger Levy. 2023. LINC: A neurosymbolic approach for logical reasoning by combining language models with first-order logic provers. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 5153–5176, Singapore. Association for Computational Linguistics.
- [32]OpenAI, ; Sandhini Agarwal, Lama Ahmad, Jason Ai, Sam Altman, Andy Applebaum, Edwin Arbus, Rahul K. Arora, Yu Bai, Bowen Baker, Haiming Bao, Boaz Barak, Ally Bennett, Tyler Bertao, Nivedita Brett, Eugene Bredvo, Greg Brockman, Sebastien Bubeck, Che Chang, Kai Chen, Mark Chen, Enoch Cheung, Aviadhan Clark, Dan Cook, Marat Dukhan, Casey Dvorak, Kevin Fives, Vlad Fomenko, Timur Garipov, Kristian Georgiev, Mia Glaese, Tarun Gogineni, Adam Goucher, Lukas Gross, Katia Gil Guzman, John Hallman, Jackie Hehir, Johannes Heidecke, Alec Helyar, Haitang Hu, Romain Huet, Jacob Huh, Saachi Jain, Zach Johnson, Chris Koch, Irina Kofman, Dominik Kundel, Jason Kwon, Volodymyr Kyrylov, Elaine Ya Le, Guillaume Leclerc, James Park Lennon, Scott Lessans, Mario Lezcano-Casado, Yuanzhi Li, Zhuohan Li, Ji Lin, Jordan Liss, Lily, Liu, Jiancheng Liu, Kevin Lu, Chris Lu, Zoran Martinovic, Lindsay McCallum, Josh McGrath, Scott McKinney, Aidan McLaughlin, Song Mei, Steve Mostovoy, Tong Mu, Gideon Myles, Alexander Neitz, Alex Nchol, Jakub Pachocki, Alex Paino, Dana Palmie, Ashley Pantuliano, Giambattista Parascandolo, Jongsoo Park, Leher Pathak, Carolina Paz, Ludovic Peran, Dmitry Pimenov, Michelle Pokrass, Elizabeth Proehl, Huida Qiu, Gaby Raila, Filippo Raso, Hongyu Ren, Kimmy Richardson, David Robinson, Bob Rotsted, Hadi Salman, Suvansh Sanjeev, Max Schwarzer, D. Sculley, Harshit Sikchi, Kendal Simon, Karan Singhal, Yang Song, Dane Stuckey, Zhiqing Sun, Philippe Tillet, Sam Toizer, Foivos Tsimpourlas, Nikhil Vyas, Eric Walin, Xie Wan, Miles Wang, Olivia Watkins, Kevin Weil, Amy Wendling, Kevin Whinnery, Cedric Whitney, Hannah Wong, Lin Yang, Yu Yang, Michihiro Yasunaga, Kristen Ying, Wojciech Zaremba, Wenting Zhan, Cyril Zhang, Brian Zhang, Eddie Zhang, and Shengjia Zhao. 2025. gpt-oss-120b & gpt-oss-20b model card. Preprint, arXiv:2508.10925.
- [33]Liangming Pan, Alon Albalak, Xinyi Wang, and William Wang. 2023. Logic-LM: Empowering large language models with symbolic solvers for faithful logical reasoning. In Findings of the Association for Computational Linguistics: EMNLP 2023, pages 3806–3824, Singapore. Association for Computational Linguistics.arxiv.org/abs/2305.12295
- [34]Cheng Qian, Emre Can Acikgoz, Hongru Wang, Xiusi Chen, Avirup Sil, Dilek Hakkani-Tür, Gokhan Tur, and Heng Ji. 2025. SMART: Self-aware agent for tool overuse mitigation. In Findings of the Association for Computational Linguistics: ACL 2025.arxiv.org/abs/2502.11435
- [35]Qwen Team. 2025. Qwen3 technical report. Preprint, arXiv:2505.09388.
- [36]Stuart J. Russell and Peter Norvig. 2009. Artificial Intelligence: a modern approach, 3 edition. Pearson.
- [37]Parshin Shojaee, Iman Mirzadeh, Keivan Alizadeh, Maxwell Horton, Samy Bengio, and Mehrdad Farajtabar. 2025. The illusion of thinking: Understanding the strengths and limitations of reasoning models via the lens of problem complexity. Preprint, arXiv:2506.06941.arxiv.org/abs/2506.06941
- [38]Yang Sui, Yu-Neng Chuang, Guanchu Wang, Jiamu Zhang, Tianyi Zhang, Jiayi Yuan, Hongyi Liu, Andrew Wen, Shaochen Zhong, Na Zhou, Hanjie Chen, and Xia Hu. 2025. Stop overthinking: A survey on efficient reasoning for large language models. Transactions on Machine Learning Research.arxiv.org/abs/2503.16419
- [39]Marcus Tantakoun, Christian Muise, and Xiaodan Zhu. 2025. LLMs as planning formalizers: A survey for leveraging large language models to construct automated planning models. In Findings of the Association for Computational Linguistics: ACL 2025, pages 25167–25188, Vienna, Austria. Association for Computational Linguistics.
- [40]Miles Turpin, Julian Michael, Ethan Perez, and Samuel R Bowman. 2023. Language models don’t always say what they think: Unfaithful explanations in chain-of-thought prompting. In Advances in Neural Information Processing Systems, volume 36, pages 80772–80785.arxiv.org/abs/2305.04388
- [41]Hongru Wang, Cheng Qian, Wanjun Zhong, Xiusi Chen, Jiahao Qiu, Shijue Huang, Bowen Jin, Mengdi Wang, Kam-Fai Wong, and Heng Ji. 2025. Acting less is reasoning more! teaching model to act efficiently. Preprint, arXiv:2504.14870.arxiv.org/abs/2504.14870
- [42]Hui Wei, Zihao Zhang, Shenghua He, Tian Xia, Shijia Pan, and Fei Liu. 2025. PlanGenLLMs: A modern survey of LLM planning capabilities. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 19497–19521, Vienna, Austria. Association for Computational Linguistics.arxiv.org/abs/2502.11221
- [43]Yaqi Xie, Chen Yu, Tongyao Zhu, Jinbin Bai, Ze Gong, and Harold Soh. 2023. Translating natural language to planning goals with large-language models. arXiv preprint arXiv:2302.05128.arxiv.org/abs/2302.05128
- [45]Huaixiu Steven Zheng, Swaroop Mishra, Hugh Zhang, Xinyun Chen, Minmin Chen, Azade Nova, Le Hou, Heng-Tze Cheng, Quoc V. Le, Ed H. Chi, and Denny Zhou. 2024. Natural plan: Benchmarking llms on natural language planning. arXiv preprint arXiv:2406.04520.arxiv.org/abs/2406.04520
- [46]Ziqian Zhong, Aditi Raghunathan, and Nicholas Carlini. 2025. ImpossibleBench: Measuring LLMs’ propensity of exploiting test cases. Preprint, arXiv:2510.20270.arxiv.org/abs/2510.20270
- [47]Max Zuo, Francisco Piedrahita Velez, Xiaochen Li, Michael Littman, and Stephen Bach. 2025. Planetarium: A rigorous benchmark for translating text to structured planning languages. In Proceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pages 11223–11240, Albuquerque, New Mexico. Association for Computational Linguistics.DOI



