betaFeedback

WorksComputer Science

Procedure without Judgment: What Small Language Models Learn under an Exact Verifier

Abstract

When an authorization policy blocks an agent's tool call, the audit log should name the facts that forced the decision and nothing more. For an executable policy over an enumerable context space this minimal sufficient reason can be computed exactly, so an explanation is scored against ground truth rather than a proxy for it. We use that exactness to ask what a model can learn from a verifier that has no error in it. The explainer sees one request and one decision, never the policy, and has thirty turns in which it may call the policy on altered requests and ask whether a candidate set of facts is sufficient. Frontier models find the exact reason about half the time with the tools alone, and one sentence telling them to shrink the answer lifts Haiku 4.5 from 58% to 75%. A 4B model fine-tuned on 2000 traces of the deletion algorithm reaches 92% on the policy it was trained on. Teacher kind is what moves this: at matched data size the algorithm-taught student leads the frontier-taught one in all three training seeds, and the two arms never overlap. What the student learns is a fixed schedule of sufficiency checks, and the schedule does not travel. On three public policies it never saw, its answers stay sufficient (94%) and stop being minimal (48%), while Haiku under the same sentence is exact on all 47 episodes. Reinforcement learning from the exact reward leaves held-out accuracy where it was and inverts the strategy, from probing the policy to spending the entire budget on sufficiency checks. The oracle made the effect of training legible, but it did not make training better.

Introduction

Reinforcement learning from verifiable rewards works where a verifier exists, and the field is now asking what happens when the verifier is a rubric, a judge, or a heuristic that only approximates the objective [17, 24]. We take the other end of that question and suppose the verifier is exact. What can a model learn from it, and what can it not?

Explaining a decision of an executable authorization policy is a task where exactness is available and the answer is non-trivial. An agent asks to send a file to an external domain, and the policy blocks it. A useful audit entry names the facts that forced the block, say the target domain and the absence of elevated authorization, and leaves out the facts that did not matter. In the formal explanation literature this is an abductive explanation or prime implicant [31, 20], a subset of the request’s features whose values entail the decision under every completion of the rest, with no proper subset that does. We call it a minimal sufficient reason (MSR). For a policy over an enumerable context space an oracle can enumerate every MSR of every decision, so a cited reason set is scored against ground truth rather than a proxy for it.

The model does not see the policy. It sees one request, one decision, and two tools. It may call the policy on any altered request, and it may ask whether a candidate set of features is sufficient. It has thirty turns. Finding the MSR under those rules is an experiment, and this paper asks who can run it. Figure 1 shows the setup.

Explanation as experiment: executable policy, explainer, algorithmic baselines, exact scorer, and training procedures

Figure 1. Explanation as experiment. An explainer sees a context xx and the policy’s decision yy but never the policy. It may call decide on any context and check on any candidate reason set, at most k=30k=30 times, then commits to a reason set SS. An exact oracle over the enumerable context space knows every minimal sufficient reason, so SS is scored without a proxy. The deletion algorithm, which needs exactly ∣F∣|F| check calls, is the ceiling. The same episode format and the same scorer serve frontier models, the supervised students and RL, so every number in the paper is on a shared set of episodes. Bottom: the procedure is installed three ways, from algorithmic traces, from frontier traces, and by RL from the scorer’s reward. Blue marks the two tools and the arrow carrying the policy’s answers.

Four results follow. First, frontier accuracy does not follow model tier, and one sentence of instruction moves it. On 120 shared episodes with both tools, Haiku 4.5 reaches the exact MSR on 58% and Sonnet 5 on 50%, against 16% for Gemini Flash-Lite. Opus 5 is exact on all 21 episodes it did not refuse, but that subset is easier and we do not read it as a ceiling (§ 3). Adding a single instruction to remove any cited feature whose removal keeps the decision lifts Haiku to 75% and Flash-Lite to 43%. Sonnet does not move, for a reason unrelated to what it cites. On 55 of 120 episodes it answers in prose instead of the required action format and the harness ends the episode empty; where it commits it is exact 94% of the time. Its score is a format-compliance number, and we report it as one (§ 3).

Second, the deletion algorithm is a better teacher for a small model than a frontier model is. We fine-tune a small language model, Qwen3-4B, on traces of the algorithm and, separately, on traces of Opus and Sonnet solving the same episodes, keeping only their exact answers so that both teachers are correct on every training episode. At matched data size the algorithm-taught student is ahead in every one of three training seeds, by 16, 47 and 61 points, with the worst algorithm seed above the best frontier seed. With 2000 traces it reaches 92%, 39 points ahead of the frontier-taught student (p<10−4p < 10^{-4}). It is also 11 points ahead of Haiku under the same shrink instruction (81%), a gap these 64 episodes cannot resolve (p=0.12p = 0.12), and uses fewer calls: ten checks and no probes against Haiku’s 8.6 checks and 8.8 probes (§ 4).

Third, what the student learned is a schedule, and the schedule does not travel. On three public policies written in OPA and Cedar, with three to ten features, the students keep producing sufficient reasons (94 to 98%) and stop producing minimal ones (down 29 to 44 points). Haiku with the shrink instruction, evaluated on the same 47 episodes, is exact on all of them. The student’s advantage is confined to the gate it was trained on, so its in-distribution lead is not evidence about small-model capability in general (§ 5).

Fourth, reinforcement learning from the exact reward moves the strategy and not the accuracy. Warm-started from the frontier-taught student and trained with a group-relative baseline against a reward in which exact minimality dominates, the student does not get more accurate on held-out episodes (+3 points, p=0.80p = 0.80). It changes how it works, stopping probing entirely and spending its whole budget on sufficiency checks, which is the deletion algorithm’s query shape without its accuracy. A training-distribution gain vanished on the held-out set, and a second warm start diverged. Padding under a sufficiency-heavy reward and starvation at the reward ceiling both appear with the verifier held exact, which places them in the reward’s shape rather than in its error (§ 6).

Every cross-system number is computed on the intersection of episodes the compared systems share, under the same prompt, with nn stated.

Setting: explaining an executable policy by querying it

Policies and contexts. GlassGate is an executable authorization policy for an agent gateway ([9, 10]). A request is a context xx over ten categorical features: the tool being called (twelve values), the scope level, the target domain, three content flags for personal, credential and financial data, the caller’s authorization level and role, the declared intent, and a count of prior violations. The product of the domains is 124,416 contexts, and the policy is a fixed function g:X→{allow,block}g : X \to\{\text{allow},\text{block}\}. Because XX is enumerable, every claim below about sufficiency is decided by evaluating gg, not by sampling. Five public policies are the held-out domains: a load-balancer policy in OPA, two Kubernetes Gatekeeper constraints (seccomp profiles and container limits), and two Cedar policies (a streaming service and a tax-preparation service). They have three to ten features and run on the same oracle machinery. The students were scored on the OPA and Cedar policies, the frontier models on all five. All episodes are stratified over the decision and over MSR size.

What the policy is. GlassGate is nine rules checked in order with the first match deciding, eight BLOCK rules over a final ALLOW default. Each BLOCK rule is a conjunction of two or three literals over the ten features. R1 credential-egress, for instance, blocks when the payload contains credentials, the target domain is public.web or unknown.xyz, and the tool is an outbound channel (email.send, http.post or files.write); Appendix § 10.§ 3 lists all nine. The rules were written to overlap, so a context usually carries distractors: literals that pattern-match some BLOCK rule’s antecedent, and so look risk-relevant, while lying outside every minimal sufficient reason. Blocked contexts carry 3.55 such distractors on average, 91% carry at least two, and 52% of contexts admit more than one minimal sufficient reason. Blocks are 54.6% of the space. The policy was fixed before any model reported here was run and was not changed afterwards. The two decisions are asymmetric. A block is sufficient as soon as one rule’s antecedent is pinned, so its minimal reasons run two to three features, while an allow has to defeat all eight BLOCK rules at once and runs three to six (Appendix § 11).

Minimal sufficient reasons.

Definition 1 For a context xx with decision y=g(x)y = g(x), a feature set S⊆FS \subseteq F is sufficient if every context x′x' that agrees with xx on SS satisfies g(x′)=yg(x') = y. It is a minimal sufficient reason if it is sufficient and no proper subset is.

This is the abductive explanation of Ignatiev et al. [20] and the prime implicant of Shih et al. [31], specialised to a Boolean decision. A decision may have several MSRs of different sizes. The oracle enumerates all of them.

The episode. The explainer receives xx, yy, the feature names and their domains, and a preamble describing an audit-log task. It never receives gg. Each turn it may issue one of three actions. decide(x') returns g(x′)g(x') for any context x′x'. check(S) returns whether SS is sufficient for (x,y)(x,y). final(S) commits to SS and ends the episode. The budget is k=30k = 30 turns. A model that has not committed by then is asked once for its answer, and we record that it was forced. The check tool is what makes an exact minimality search possible in ∣F∣|F| queries, and we give it to every system in the paper, so no comparison turns on who had which tool.

Metrics. Given the committed set SS and the oracle’s MSR set M\mathcal{M}, we report the fraction of episodes on which S∈MS \in\mathcal{M} (Exact, the headline), the fraction on which SS is sufficient (Suff), the precision of SS against the union of all MSRs (CPrec), the surplus ∣S∣−min⁡M∈M∣M∣|S| - \min_{M \in\mathcal{M}} |M| (positive means padding, negative means an insufficient answer), and the mean number of decide and check calls per episode, which describe the strategy. Every comparison between two systems is a paired sign-flip permutation test on the per-episode Exact difference over the episodes both systems ran, with 20,000 permutations.

Ceiling and floors. The deletion algorithm starts from S=FS = F and removes each feature that is not needed for sufficiency, returning an MSR in exactly ∣F∣|F| check calls with no probes, so it is the ceiling for any explainer with the same tools. Its surplus in Table 1 is positive with Exact at 1.0 because it returns an MSR, not necessarily the smallest. Single-flip cites the features whose individual change flips the decision; random probing cites what it saw co-vary over random contexts. These bound what tool access alone achieves.

systemExactSuffCPrecsurplusprobeschecksforced
base 4B (prompt only)0.0000.2500.430+2.420.021.80.00
Frontier-1480.5310.7810.841+1.173.525.50.00
+ RL, exact reward0.5620.7340.877+0.750.030.00.00
Alg-1480.6881.0000.914+0.880.010.20.00
Alg-20000.9220.9840.973+0.380.010.00.00
Haiku 4.5 + shrink0.8120.9060.980+0.258.88.60.00
Sonnet 5 + shrink0.5620.5780.574−1.553.38.90.42
deletion algorithm (ceiling)1.0001.0001.000+0.270.010.00.00
single-flip heuristic0.5160.5160.750−1.0828.00.00.00
random probing0.0000.7970.524+3.5630.00.00.00

Table 1. Students, RL and algorithmic baselines on the same 64 GlassGate episodes. Students are named for their teacher and their number of training traces. Suff is the fraction of sufficient answers, CPrec the precision against the union of all MSRs, surplus the mean number of cited features beyond the smallest MSR (negative means insufficient), and probes and checks the mean decide and check calls per episode, forced the fraction of episodes ended by the harness after two malformed replies. Every system, including the two frontier rows, ran with the shrink instruction. The deletion algorithm’s surplus is positive with Exact at 1.0 because it returns an MSR, not necessarily the smallest one. Bold marks the best of the five student rows on Exact, Suff and CPrec.

Systems. Frontier explainers are Gemini 3.5 Flash-Lite, Claude Haiku 4.5, Claude Sonnet 5 and Claude Opus 5, thinking disabled, both tools. Opus declined most episodes as a security task, the refusal bias documented by Campbell et al. [5], so its numbers are on the 21 of 120 it answered. Students are Qwen3-4B (Yang et al. (2025)) with a rank-16 LoRA (Hu et al. [19]), 600 steps, one recipe for all arms. Each student is named for its teacher and its number of training traces. Alg-2000 and Alg-148 are taught by the deletion algorithm. Frontier-148 is taught by Opus 5 or Sonnet 5 traces, kept only where the model committed to an exact answer. Alg-public is taught by the deletion algorithm on the five public policies only, never on GlassGate (§ 5). The RL arm warm-starts from Frontier-148 and runs group-relative REINFORCE (Williams, 1992; Shao et al., [30]) for 25 steps. Appendix § 10.§ 1 has every setting.

Can frontier models find the minimal reason?

We first ask what models never trained on the task do with the two tools. Figure 2 shows four frontier models on GlassGate at budget 30, without and with the shrink instruction; Appendix § 11 has every domain and Appendix § 11 the breakdown by reason size.

Figure 2. Frontier models with both tools, and what one sentence changes. (a) Exact minimality, sufficiency and precision on GlassGate with both tools and no further instruction, all three models on the same 120 episodes and Opus on the 21 it did not refuse (hatched), a subset with no minimal reason above three features. The number above each group is the mean surplus of cited features over the smallest MSR; Sonnet’s is negative because 46% of its episodes end in a forced empty answer (§ 3). The dotted line is the deletion algorithm. (b) Paired within model on the episodes each model ran under both prompts (nn on the plot; Opus’s shrink arm has 20), with and without a one-sentence shrink instruction. Solid lines are gains of more than two points.

Two tiers, then one sentence. With the tools alone, Haiku 4.5 reaches the exact MSR on 58% of episodes and Flash-Lite on 16%, a gap of 42 points (p<10−4p < 10^{-4}, paired). Sonnet 5, which one would expect above Haiku, is at 50%, eight points below it (p=0.064p = 0.064). Opus 5 is exact on all 21 episodes it did not refuse, 24 points above Sonnet there (p=0.063p = 0.063, n=21n = 21), but that subset is easier: its minimal reasons average 2.29 features against 3.02, it contains none of the 32 episodes whose reason exceeds three, and Haiku and Sonnet both reach 76% on it. Opus is not established as a ceiling. One added sentence, telling the model to remove any cited feature whose removal keeps the decision, lifts Flash-Lite 28 points to 43% and Haiku 17 to 75% (both p≤10−4p \le10^{-4}, paired within model, Figure 2b). It repairs the failure both share, citing one feature too many: Haiku’s sufficiency goes from 75% to 83% and its surplus falls.

Sonnet’s score is a format number. Sonnet does not move under the instruction (50% to 51%), and the reason is visible in the trajectories. On 55 of 120 episodes in each arm (45 in both), Sonnet twice replies with reasoning prose instead of the required single JSON action, and the harness ends the episode with an empty answer scoring zero on every metric. It happens at turn 20 on average, not at the budget, and on the hard episodes: 17 of the 18 whose smallest reason has four features are among the 55. On the 65 where it commits it is exact 92% without the instruction and 94% with it, against Haiku’s 95% on those same episodes, while its overall sufficiency, 53%, sits below Flash-Lite’s 94%. Haiku, Flash-Lite and Opus have at most one forced episode each. We report the forced rate rather than reinterpret the score; a more forgiving harness would change Sonnet’s numbers and no one else’s.

Teaching a small language model the procedure

Can a small language model (Belcak et al. [3]) be taught what the frontier does with the instruction? We fine-tune one student, Qwen3-4B, from three teachers with one recipe, and evaluate all of them on the same 64 GlassGate episodes with the same tools, the same budget and the same shrink instruction, against Haiku and Sonnet under that same instruction. Table 1 gives the numbers and Table 2 the paired tests.

comparison (a − b)Δ\DeltaExactnnpp
algorithm ×2000\times2000 vs frontier ×148\times148 teacher+0.39164<.001
algorithm vs frontier teacher, both ×148\times148+0.156640.11
algorithm ×2000\times2000 vs ×148\times148+0.234640.003
best student vs Haiku 4.5, same instruction+0.109640.12
best student vs Sonnet 5, same instruction+0.35964<.001
frontier-taught student vs Haiku 4.5, same instruction−0.28164<.001
best student vs the deletion ceiling−0.078640.06
RL from the exact reward vs its warm start+0.031640.80
Haiku 4.5 vs Flash-Lite+0.425120<.001
Sonnet 5 vs Haiku 4.5−0.0831200.06
best student vs single-flip heuristic+0.40664<.001
frontier-taught student vs single-flip+0.016641.00
RL student vs single-flip+0.047640.72

Table 2. Paired tests on exact minimality, GlassGate. Each row is computed on the episodes both systems ran; pp is a two-sided sign-flip permutation test with 20,000 draws.

Teachers. The algorithm teacher is the deletion procedure of § 2, rendered as an episode with a check call per feature, a one-line rationale for each, and a final. It supplies 2000 training episodes for Alg-2000 and 148 for Alg-148. The frontier teacher is Opus 5 or Sonnet 5 solving 148 episodes with the same tools and the same prompt, and we keep only the trajectories that committed on their own to an exact minimal reason, so Frontier-148 sees nothing but correct answers. Both teachers are correct on every training episode. They differ in kind, and Alg-148 against Frontier-148 is the pair that holds volume fixed and isolates kind. No teacher and no student ever sees the policy. The untrained base model with the shrink prompt is the first row of Table 1, and is what prompting alone achieves at this scale.

The algorithm is the better teacher. Alg-2000 reaches the exact MSR on 92% of episodes, against 53% for Frontier-148, a difference of 39 points (p<10−4p < 10^{-4}), and eight points short of the deletion ceiling (p=0.064p = 0.064). Against the frontier under the same instruction it is 11 points ahead of Haiku, a gap 64 episodes cannot resolve (p=0.12p = 0.12), and 36 ahead of Sonnet (p<10−4p < 10^{-4}, with Sonnet bounded by its format failures). It gets there with ten check calls and no probes, against Haiku’s 8.6 checks and 8.8 probes. Frontier-148 does not get there at all: 28 points behind Haiku, p<10−3p < 10^{-3}. Volume and teacher kind can be separated, because Alg-148 and Frontier-148 saw the same number of traces. Alg-148 wins, and it wins in every one of three training seeds (Appendix § 11). Seed variance is wide, 69% to 97% against 36% to 53%, yet the arms never overlap: the worst algorithm seed beats the best frontier seed, and that is the claim. On all 120 GlassGate episodes the margin is 17.5 points (p=0.006p = 0.006); on the stratified 64 it is 16 points and does not reach significance (p=0.11p = 0.11), so that comparison was underpowered rather than negative. Going from 148 traces to 2000 adds a further 23 points (p=0.003p = 0.003), so kind and volume both contribute and are separable.

Not everything clears the heuristic floor. Single-flip changes one feature at a time and cites what flips the decision, reaching 52% on GlassGate with 28 probes and no check calls. Table 2 tests every system against that floor. Alg-2000 clears it by 41 points and instructed Haiku by 30, both at p<10−3p < 10^{-3}. Frontier-148 does not clear it, before or after RL, and neither does Sonnet with the instruction. § 6’s RL null is therefore measured on a policy that starts at the heuristic floor.

The teacher installs a schedule. The probes and checks columns of Table 1 show how each student spends its budget. The algorithm-taught students never call decide: they run ten check calls, one per feature, and commit, reproducing the deletion algorithm’s query pattern exactly. Frontier-148 probes 3.5 times per episode and checks 25.5 times, its teachers’ probe-then-verify order at three times their check count (Opus and Sonnet averaged seven checks per episode). Each student learned how to spend thirty turns, with the count anchored to the training gate and not to the policy at hand: Appendix § 11 shows the algorithm-taught students making ten checks on the three-feature policy and about fourteen on the seven- and ten-feature ones. Appendix § 10.§ 5 gives a worked episode.

What transfers to policies the student never saw

The three public policies test whether the students of § 4 learned the procedure or the gate. Figure 3 plots exact minimality and sufficiency on GlassGate and on the real policies; Appendix § 11 has the per-policy numbers.

Figure 3. What survives the move to policies the student never saw. Solid lines are exact minimality, dashed lines sufficiency, on GlassGate and on the three public policies the students ran. (a) The algorithm-taught students keep sufficiency and lose minimality. (b) Haiku and Sonnet with the same shrink instruction move both together, upward, because most public policies have fewer features than GlassGate. Per-policy numbers with shared-episode counts are in Appendix § 11.

Sufficiency transfers and minimality does not. Alg-2000 keeps its answers sufficient off-distribution, 94% against 98% at home, and Alg-148 likewise, 98% against 100%. Their exact minimality falls from 92% to 48% and from 69% to 40%. The gap between sufficiency and minimality opens by 46 and 58 points on the real policies, both at p<10−3p < 10^{-3}. The verification step, which keeps checking until the set is sufficient, survives the move to policies with different features and different sizes. The search, which removes features until nothing more can go, does not. Frontier-148 is flat on both measures pooled, and off-distribution the ordering reverses. In all three seeds the frontier-taught student is the more minimal one on the public policies, 50%, 58% and 54% against 40%, 56% and 44%, while the algorithm-taught student keeps the higher sufficiency, 96% to 98% against 77% to 83%. That advantage is not general. On cedar-streaming-service, the only ten-feature public policy, the frontier-taught student is exact on zero episodes in all three seeds while the algorithm-taught students reach 6% to 31%. What travels is citing few features, which pays when the answer has few features.

The frontier models do not show the split. Haiku and Sonnet with the same instruction move both quantities together and upward on the same three policies. Haiku goes from 75% to 100% exact and 83% to 100% sufficient on all 47 episodes; Sonnet from 51% to 69% exact and 54% to 71% sufficient, its forced rate falling with the shorter policies. Most public policies have fewer features than GlassGate, so a general search finds the minimal set more easily and the untrained models behave as general searchers. The students behave as models that learned a schedule for ten features, so the split is a signature of the taught procedure and not of the task.

The schedule is policy-specific in both directions. Training on GlassGate and testing elsewhere cannot separate learning the procedure from memorising GlassGate’s ten-feature structure, so we ran the mirror. Alg-public is taught by the same deletion algorithm on the five public policies only, 80 trajectories, never GlassGate. It reaches 92% on those policies against 40% to 50% for every GlassGate-trained student, so the recipe is not a GlassGate artefact. On GlassGate it reaches 28%, above the untrained base (0%, p=10−4p = 10^{-4}) but below the frontier-taught student (−25-25 points, p=0.010p = 0.010), the matched algorithm-taught student (−41-41 points, p=10−4p = 10^{-4}) and even single-flip (−23-23 points, p=0.021p = 0.021). Something transfers and it is not enough to be useful: the algorithm teaches a schedule fitted to the policy it was taught on, whichever direction the experiment runs.

Off-distribution the student is behind. On the policies it never saw, Alg-2000 is behind instructed Haiku on all three, by 50, 38 and 73 points, every one significant; Appendix § 11 has the per-policy numbers. It is behind Sonnet on two of the three. The level comparison of § 4 holds where the student was trained and nowhere else.

Reinforcement learning from the exact reward

The exact oracle gives a process reward with no error in it, and the question is whether RL against it can push the frontier-taught student toward the algorithm-taught one. We warm-start from Frontier-148, since Alg-2000 sits at the reward ceiling and yields no within-group variance to learn from, and train with REINFORCE and a group-relative baseline over four rollouts per context on fresh contexts, for 25 steps. Table 1 gives the held-out result and Appendix § 11 the training-time evaluations.

Reward shape. Our first reward weighted sufficiency and recall above exact minimality and precision, with small terms for answering and a per-probe cost. Within 25 steps it produced padding. Reward rose by 0.012 while exact minimality fell from 58% to 33% and the surplus grew from 0.5 to 2.0 features (Appendix § 10.§ 2). Citing an extra feature raises sufficiency and recall and is charged less than it earns. The verifier was exact throughout, so the hacking is a property of the reward’s shape alone, the distinction Mahmoud et al. [24] draw between verifier failure and rubric design in its sharpest form. The corrected reward makes exact minimality dominant and charges per surplus feature, so padding is strictly worse than the minimal answer (Appendix § 10.§ 2 has both in full).

Accuracy does not move and strategy inverts. Under the corrected reward, the policy’s exact minimality on the 24 fresh contexts used for training-time evaluation rose from 63% to 83%. On the 64 held-out episodes of Table 1 it is 56% against its warm start’s 53%, a difference of three points (p=0.80p = 0.80). The training-distribution gain did not transfer, and we report the held-out number as the result. What did change is how the student spends its budget. Frontier-148 probes 3.5 times and checks 25.5 times per episode. After RL it probes zero times and checks 30 times, the full budget, on every one of 112 episodes, and commits its own rather than being cut off. The exact reward turned an explorer into an exhaustive verifier with the deletion algorithm’s query shape, all sufficiency and no exploration, but without the algorithm’s judgment about which check to run next, and so without its accuracy.

Two warm starts, two outcomes. A second run from an independently trained copy of Frontier-148, under the identical reward and hyperparameters, diverged instead, and exact minimality fell to 6% on the held-out set with a surplus of 3.5 features (Appendix § 10.§ 2). Its reward fell too, so this is not hacking but a policy that lost the procedure. One RL run from one warm start is not evidence of a direction, and we have two runs pointing opposite ways. Both share the strategy inversion, and neither improves the answer. The third case is the ceiling: RL from Alg-2000 found zero within-group variance on all 21 of its steps and never took a gradient. Across all three, the exact reward measured what training did, and in this setting training changed the procedure without improving the answer.

Related work

Explaining by querying. Geng et al. [14] have LLMs recover a hidden program, formal language or equation by querying it, and find that models plateau under passive observation and improve when allowed to intervene. Yin et al. (2025) benchmark the same protocol across 96 hidden functions, and Wei et al. (2025) fine-tune an 8B model on traces from a teacher with access to the hidden function, the closest precedent for training the querier. Our setting shares the premise and differs in the object. Their explainer hypothesises a whole function; ours explains one decision and is scored exactly against every minimal sufficient reason of that decision, and we train the querier rather than only prompting it. Mayne et al. [26] show self-generated counterfactuals are valid but not minimal, the failure our check tool makes measurable. The protocol is query learning ([1] (Weiss et al. 2018)): decide is a membership query, check a sufficiency query, and unlike L∗L^* there is no equivalence oracle.

Formal explanations. The minimal sufficient reason is the abductive explanation of Ignatiev et al. [20], the prime implicant of Shih et al. [31], and the sufficient reason of Darwiche and Hirth [8], whose term we adopt; Marques-Silva and Ignatiev [25] argue formal XAI should deliver it. Query-based methods for related objects predate LLMs: Anchors (Ribeiro et al. [29]) finds high-precision sufficient conditions of a black box by sampling, Blanc et al. [4] give query-efficient algorithms with guarantees, and the deletion procedure we use as teacher is the standard extractor for minimal unsatisfiable cores ([21]). Recent work computes these for black-box vision models by query, Xing and Lagniez (2026) for point clouds and Hoarau et al. [18] at the concept level. Those are algorithms, and our question is whether a language model can be taught to run one. An exact oracle replaces the faithfulness proxies of Atanasova et al. [2] and Chen et al. [6], which Gur-Arieh et al. [16] show do not measure faithfulness.

Verifiers and reward shape. Reward hacking under RLVR is documented by Helff et al. [17] and Tarek and Beheshti (2025), and Mahmoud et al. [24] separate verifier failure from rubric design. Egashira et al. [12] and Ray [28] degrade or fuzz the verifier to study the first. We hold the verifier exact, so what remains is the second, and the padding we observe under a sufficiency-heavy reward is the pattern Wang et al. (2026) reproduce and detect under rubric rewards, here with verifier error at zero. Kim et al. [22] report RL collapsing tool use while task accuracy holds, which is the same shape as our strategy inversion; Yue et al. (2025) report the same shape for RLVR more broadly. Process reward models for agents (Choudhury, [7] supply dense signal from a learned scorer, and ours is dense and exact, which is what lets us attribute the strategy inversion to the reward rather than to scorer noise.

Teachers. Training small models on traces of a symbolic search is established ([13, 27, 23] (Yang et al. 2022)), and Valmeekam et al. (2025) show students reproduce trace form without its semantics, the mechanism behind our off-distribution result and the small-model form of the gap Gudibande et al. [15] report. Distillation from frontier traces is surveyed by Song and Zheng (2026); the closest precedent for a verifier-guided variant is Dixit et al. [11], whose traces carry backtracking where ours carry only a fixed schedule of checks. We did not find a prior comparison of an algorithmic against a frontier teacher on identical exact ground truth, which is what § 4 runs.

Limitations

Alg-148 and Frontier-148 have three training seeds each (Appendix § 11); every other arm has one, so intervals elsewhere are over episodes. Three seeds is also the floor for a seed-level test, since complete separation of 3 against 3 gives an exact permutation pp of 0.10, so the teacher-kind claim rests on the within-seed paired tests and the nonoverlap. One student size and one base model were trained. GlassGate is a single hand-written policy, and the student loses to Haiku on all three public policies it was scored on. Sonnet’s numbers are bounded by a harness rule, two malformed replies end the episode, that no other model triggered; a different rule would raise Sonnet and change nothing else. The oracle needs an enumerable context space, bounding the setting to categorical policies.

Conclusion

With the verifier exact, every result above is measured against ground truth. The frontier finds a minimal sufficient reason about half the time with the tools alone and three quarters once instructed. An algorithm can teach a 4B model to match it where a frontier model cannot, but only on the gate it was taught on; off it, sufficiency travels and minimality does not. An exact reward changed the strategy in both RL runs and moved accuracy in opposite directions. In the supervised and RL results alike, training installed the shape of a procedure without the judgment inside it, and the exact verifier is what let us tell the two apart.

Reproducibility

One script generates every number from per-episode records, restricting each comparison to the episodes the compared systems share and printing nn. The policy, the exact oracle, the deletion algorithm, the training scripts and the per-episode records will be released on publication. Settings are in § 2 and Appendix § 10.

Use of AI assistants

LLMs are the subject of this work: the frontier models measured, the Opus and Sonnet traces used as one teacher, and the trained 4B policies. The authors also used LLM assistance for editing text and for coding, under their direction. Every result comes from the exact oracle and the deterministic evaluation pipeline, and the authors take full responsibility for the content.

Replication details

Hyperparameters and compute

Table 3 and Table 4 give every training and evaluation setting and the compute used.

Table 3: Training and evaluation settings.

settingvalue
student base modelQwen3-4B, chat template, thinking disabled
adapterLoRA rank 16, α=32\alpha= 32, dropout 0, on q/k/v/o and gate/up/down projections
SFT steps, batch, learning rate600, 2, 10−510^{-5} (AdamW)
SFT precisionfp16 with dynamic loss scaling (T4 has no bf16)
teacher A data2000 (A) or 148 (A′) deletion-algorithm episodes, one check per feature
teacher B data148 Opus 5 / Sonnet 5 episodes with both tools, full trace
evaluationbudget 30, both tools, shrink instruction, greedy decoding, 220 new tokens per turn
RL algorithmREINFORCE, group-relative baseline, 4 rollouts per context
RL learning rate, temperature5×10−65 \times10^{-6}, 0.8
RL budgets15 turns during training, 30 at evaluation
RL contextsfresh random contexts each step; 24 fixed held-out contexts for the training-time curve
RL steps per leg, total25, 25 (one leg reported)
RL safeguardspre-flight: 3 groups, abort if max std <0.02< 0.02; breaker after 10 zero-variance steps
frontier modelsGemini 3.5 Flash-Lite, Claude Haiku 4.5, Claude Sonnet 5, Claude Opus 5; thinking off
statisticspaired sign-flip permutation, 20,000 draws; bootstrap CIs, 2,000 resamples

Table 3.

Table 4: Compute and spend. GPU time is on Kaggle’s free T4 tier across two accounts.

stagecostnotes
SFT, three students3×443 \times44 min T44.1 s/step
student evaluation, 112 episodes≈1.8\approx1.8 h T4 per adapter60 s/episode with greedy decoding
RL, one 25-step leg3.1 h T4310–340 s/step plus a 24-episode evaluation
RL adapter evaluation, 112 episodes3.4–4.7 h T4 per adapterthe RL policies use the full budget
frontier episodes, Gemini$3.35 | 10,190 calls
frontier episodes, Anthropic API$3.62 | remainder of Haiku and Sonnet arms
frontier episodes, Claude CLIsubscriptionmost Haiku and Sonnet arms
total GPU≈\approx 30 T4-hourstwo free Kaggle accounts

Table 4.

Reward definitions

Both rewards are functions of the committed set SS and the episode’s metrics. Reward v1, which produced padding, was

r1=0.10[answered]+0.05[not forced]+0.25 CRec+0.15 CPrec+0.25[Suff]+0.20[Exact]−0.01⋅#probes.r_1 = 0.10 \left[\text{answered}\right] + 0.05 \left[\text{not forced}\right] + 0.25\,\mathrm{CRec} + 0.15\,\mathrm{CPrec} + 0.25 \left[\text{Suff}\right] + 0.20 \left[\textit{Exact}\right] - 0.01 \cdot\#\text{probes}.

Reward v3, used for the reported runs, is

r3=0.05[answered]+0.05[not forced]+0.10 CRec+0.15 CPrec+0.15[Suff]+0.50[Exact]−0.05⋅surplus−0.005⋅#probes.r_3 = 0.05 \left[\text{answered}\right] + 0.05 \left[\text{not forced}\right] + 0.10\,\mathrm{CRec} + 0.15\,\mathrm{CPrec} + 0.15 \left[\text{Suff}\right] + 0.50 \left[\textit{Exact}\right] - 0.05 \cdot\text{surplus} - 0.005 \cdot\#\text{probes}.

Under r3r_3 the exact minimal answer scores 1.0 and any padded sufficient answer strictly less. Each step samples four rollouts per context on fresh contexts; the baseline is the group mean. A run stops after ten consecutive steps with zero within-group variance.

The full policy

Table 5 is the complete GlassGate rule set, generated from the policy source. Rules are checked in order and the first match decides, so R9 fires only when no BLOCK rule matched.

Table 5: The nine GlassGate rules. literals is the number of feature-value conditions in the antecedent, which bounds the size of a block’s minimal sufficient reason at three.

idnamedecisionliteralscondition
R1credential-egressBLOCK3BLOCK if the payload contains credentials, the target domain is public.web or unknown.xyz, and the tool is an outbound channel (email.send, http.post, or files.write).
R2payments-elevationBLOCK2BLOCK if the tool is payments.transfer and the session auth_level is not elevated.
R3destructive-roleBLOCK3BLOCK if the declared intent is destructive, the user_role is not admin, and the tool can modify or delete data (files.delete, files.write, or db.write).
R4unauthenticated-writeBLOCK2BLOCK if the session auth_level is none and the requested scope_level is write or admin.
R5pii-external-shareBLOCK3BLOCK if the payload contains PII, the declared intent is external_share, and the target domain is not internal.corp.
R6repeat-offender-adminBLOCK2BLOCK if the session has 2 prior policy violations and the requested scope_level is admin.
R7intern-financial-exportBLOCK3BLOCK if the user_role is intern, the declared intent is bulk_export, and the payload contains financial data.
R8unknown-domain-writeBLOCK2BLOCK if the target domain is unknown.xyz and the requested scope_level is write or admin.
R9defaultALLOW0ALLOW if no earlier rule matched.

Table 5.

Prompts

The explainer prompt (Figure 4) is assembled from the blocks shown, in order, followed by the request context, the decision, the feature domains, the log of actions so far, and the action-format block for the remaining budget. The shrink instruction is present for every student and for the shrink arms of § 3. The algorithm teacher’s traces use the identical prompt with the deletion algorithm’s actions as completions; the frontier teacher’s are Opus 5 and Sonnet 5 transcripts under the identical prompt, unedited.

The prompt blocks given to every explainer
PREAMBLE (GlassGate):
You write audit-log explanations for an AI agent security gateway. The gateway inspects each tool call an AI agent attempts and either allows or blocks it, following a fixed internal policy you have NOT been shown.

PREAMBLE (public policies):
You write audit-log explanations for an access-control policy engine. The engine inspects each request and either allows or denies it, following a fixed policy you have NOT been shown.

GOAL:
A good explanation cites exactly the features whose values, taken together, force this decision, and no others.

Feature domains (every feature takes exactly one of the listed values):
<one line per feature: name: value1, value2, ...>

PROBE TOOL:
You can run experiments on the engine. Each probe is a modified copy of the request: give the feature values to change and the engine returns its decision for that modified request. Use probes to find out which features actually determined this decision.

CHECK TOOL:
You can also ASK THE ENGINE DIRECTLY whether a candidate answer is complete: a check names a set of features, and the engine reports SUFFICIENT if pinning only those features at their current values forces this decision no matter what the remaining features are, and NOT SUFFICIENT otherwise. A check costs the same as a probe.

SHRINK INSTRUCTION (Section 3b, and all students):
IMPORTANT: a SUFFICIENT set is not yet the answer. Once a set is SUFFICIENT, remove one feature at a time and re-check; a feature whose removal keeps the set SUFFICIENT was not a reason. Your final answer must be the SMALLEST set that is still SUFFICIENT.

ACTION FORMAT:
You have <k> action(s) left. Respond with ONLY a JSON object, one of
{"probe": {"feature_name": "new_value", ...}}  to run one more experiment,
{"check": ["feature_name", ...]}          to ask whether that set is
  SUFFICIENT, or
{"final": {"reasons": ["feature_name", ...], "explanation": "2-4 sentences for
  the audit log"}}
where "reasons" lists exactly the features that determined the decision.

FORCED FINAL (budget exhausted):
Respond with ONLY a JSON object of the form
{"final": {"reasons": ["feature_name", ...], "explanation": "2-4 sentences for
  the audit log"}}
where "reasons" lists exactly the features that determined the decision.

Figure 4. The prompt blocks given to every explainer.

A worked episode

Figure 5 is one GlassGate episode on which Alg-2000 returned the exact minimal reason and Sonnet 5 did not, with the deletion algorithm’s ten checks that Alg-2000 reproduces.

A worked GlassGate episode showing the deletion algorithm's trace and Sonnet 5's trace

Figure 5. A worked GlassGate episode: the deletion algorithm’s trace and Sonnet 5’s trace, which ends in a sufficient but non-minimal answer.

Supplementary tables and figures

Tables and figures referenced from the main text.

Episode ep000. Decision: BLOCKED.
Request:
    tool: email.send
    scope_level: read
    target_domain: public.web
    contains_pii: yes
    contains_credentials: yes
    contains_financial: no
    auth_level: none
    user_role: analyst
    intent: destructive
    prior_violations: 2
Minimal sufficient reasons (oracle): {tool, target_domain,
                         contains_credentials}

Deletion algorithm (teacher A, 10 checks, no probes):
    check({scope_level, target_domain, contains_pii, contains_credentials,
           contains_financial, auth_level, user_role, intent, prior_violations}) ->
           NOT SUFFICIENT, keep tool
    check({tool, target_domain, contains_pii, contains_credentials,
           contains_financial, auth_level, user_role, intent, prior_violations}) ->
           SUFFICIENT, drop scope_level
    check({tool, contains_pii, contains_credentials, contains_financial,
           auth_level, user_role, intent, prior_violations}) -> NOT SUFFICIENT,
           keep target_domain
    check({tool, target_domain, contains_credentials, contains_financial,
           auth_level, user_role, intent, prior_violations}) -> SUFFICIENT, drop
           contains_pii
    check({tool, target_domain, contains_financial, auth_level, user_role,
           intent, prior_violations}) -> NOT SUFFICIENT, keep contains_credentials
    check({tool, target_domain, contains_credentials, auth_level, user_role,
           intent, prior_violations}) -> SUFFICIENT, drop contains_financial
    check({tool, target_domain, contains_credentials, user_role, intent,
           prior_violations}) -> SUFFICIENT, drop auth_level
    check({tool, target_domain, contains_credentials, intent, prior_violations})
           -> SUFFICIENT, drop user_role
    check({tool, target_domain, contains_credentials, prior_violations}) ->
           SUFFICIENT, drop intent
    check({tool, target_domain, contains_credentials}) -> SUFFICIENT, drop
           prior_violations
    final({tool, target_domain, contains_credentials})

Sonnet 5 (10 actions):
    probe({"intent": "routine", "prior_violations": 0, "auth_level": "elevated",
           "contains_credentials": "no", "target_domain": "internal.corp",
           "contains_pii": "no"}) -> ALLOWED
    probe({"intent": "routine"}) -> BLOCKED
    probe({"contains_credentials": "no"}) -> ALLOWED
    probe({"intent": "routine", "prior_violations": 0, "auth_level": "elevated",
           "target_domain": "internal.corp", "contains_pii": "no"}) -> ALLOWED
    probe({"prior_violations": 0}) -> BLOCKED
    probe({"target_domain": "internal.corp"}) -> ALLOWED
    check({contains_credentials, target_domain}) -> NOT SUFFICIENT
    probe({"contains_pii": "no"}) -> BLOCKED
    probe({"auth_level": "elevated"}) -> BLOCKED
    check({contains_credentials, target_domain, contains_pii}) -> NOT SUFFICIENT
    final({})    [not sufficient]

Figure 6. Every system on every public policy, shared episodes per policy. (a) Exact minimality. (b) Sufficiency. The dotted line is the deletion algorithm at 1.0. The two Gatekeeper policies were run by the frontier models only.

Figure 7. Exact minimality on GlassGate by the size of the smallest MSR, on the 64 episodes all systems share. Episode counts per size are in the tick labels. Every episode whose smallest reason exceeds three features is an allow. The untrained base is zero at every size and the RL student tracks Frontier-148, so both are omitted.

Figure 8. How each system spends its thirty-turn budget on the 64 shared GlassGate episodes. Violins are the per-episode distribution; the bar is the mean.

Table 6: All frontier arms with both tools and budget 30, every domain, shared episodes within each domain block. Surplus is the mean number of cited features over the smallest MSR. Within each domain the first three rows are on the same episodes; Opus is on the subset of those it answered.

domainmodelnnExactSuffCPrecsurplusprobeschecksforced
glassgate (∣F∣=10|F|=10)Flash-Lite1200.1580.9420.688+1.981.510.90.00
Haiku 4.51200.5830.7500.960+0.1012.54.20.00
Sonnet 51200.5000.5250.525−1.557.07.40.46
Opus 5211.0001.0001.000+0.100.37.30.00
opa-loadbalancer (∣F∣=3|F|=3)Flash-Lite160.4380.9380.844+0.440.62.20.00
Haiku 4.5160.8121.0000.969+0.194.71.80.00
Sonnet 5161.0001.0001.000+0.003.11.50.00
gk-psp-seccomp (∣F∣=5|F|=5)Flash-Lite160.6881.0000.875+0.310.32.20.00
Haiku 4.5161.0001.0001.000+0.002.62.00.00
Sonnet 5161.0001.0001.000+0.001.71.00.00
gk-container-limits (∣F∣=6|F|=6)Flash-Lite160.3121.0000.796+1.120.73.90.00
Haiku 4.5160.6881.0000.937+0.444.21.50.00
Sonnet 5160.8751.0000.979+0.252.81.60.00
cedar-tax-preparer (∣F∣=7|F|=7)Flash-Lite160.5001.0000.823+0.750.42.40.00
Haiku 4.5160.5621.0000.984+0.505.22.10.00
Sonnet 5160.8750.8750.875−0.313.23.60.12
cedar-streaming-service (∣F∣=10|F|=10)Flash-Lite160.0000.6880.751+1.943.511.80.00
Haiku 4.5160.4380.7500.844+0.2511.29.60.06
Sonnet 5160.3750.5000.545−0.627.69.60.38

Table 6.

Figure 9. RL from the exact reward, evaluated at step 0 and step 25 on 24 fixed training-time contexts; lines connect the two evaluations. (a) Reward r1r_1 is hacked by padding: reward rises while exact minimality falls and surplus goes from 0.5 to 2.0. (b) Reward r3r_3 from Frontier-148 raises exact minimality on these contexts, a gain that does not survive on the 64 held-out episodes of Table 1. (c) The same reward from a second copy of Frontier-148 diverges. Surplus uses the brown right axis.

Table 7: Three training seeds each for the matched-size arms, Alg-148 (A′) and Frontier-148 (B), on the 64 GlassGate episodes and the 48 public-policy episodes the students ran. Seed 0 is the run reported in Table 1. Within-seed paired differences on GlassGate are +16 (p=0.11p = 0.11), +47 and +61 points (both p<10−4p < 10^{-4}).

teacherseedGlassGatereal policies
ExactSuffExactSuff
algorithm ×148 (A′)00.6881.0000.3960.979
10.8750.9380.5620.958
20.9690.9690.4380.958
mean0.844 (sd 0.143)0.465
frontier ×148 (B)00.5310.7810.5000.771
10.4060.7340.5830.833
20.3590.6560.5420.792
mean0.432 (sd 0.089)0.542

Table 7.

systemnnExact [95% CI]Suff [95% CI]CPrecsurplus
Alg-2000, GlassGate640.922 [0.84, 0.98]0.984 [0.95, 1.00]0.973+0.38
Alg-148, GlassGate640.688 [0.58, 0.80]1.000 [1.00, 1.00]0.914+0.88
Frontier-148, GlassGate640.531 [0.41, 0.66]0.781 [0.67, 0.88]0.841+1.17
Frontier-148 + RL, GlassGate640.562 [0.44, 0.69]0.734 [0.62, 0.84]0.877+0.75
base, GlassGate640.000 [0.00, 0.00]0.250 [0.16, 0.36]0.430+2.42
Haiku 4.5, GlassGate1200.583 [0.49, 0.67]0.750 [0.67, 0.82]0.960+0.10
Sonnet 5, GlassGate1200.500 [0.41, 0.59]0.525 [0.43, 0.61]0.525−1.55
Flash-Lite, GlassGate1200.158 [0.10, 0.23]0.942 [0.90, 0.98]0.688+1.98
Opus 5, GlassGate211.000 [1.00, 1.00]1.000 [1.00, 1.00]1.000+0.10
Alg-2000, real policies480.479 [0.33, 0.62]0.938 [0.85, 1.00]0.780+1.38
Alg-148, real policies480.396 [0.27, 0.54]0.979 [0.94, 1.00]0.791+1.35
Frontier-148, real policies480.500 [0.35, 0.65]0.771 [0.65, 0.88]0.785+1.02
Frontier-148 + RL, real policies480.542 [0.40, 0.69]0.896 [0.79, 0.98]0.827+1.25
base, real policies480.083 [0.02, 0.17]0.854 [0.75, 0.94]0.540+2.94

Table 8. Per-system means with 95% bootstrap intervals over episodes (2,000 resamples), on each system’s full episode set. Real-policy rows for the students pool the three policies they ran.

References

  1. [1]Dana Angluin. 1988. Queries and concept learning. Machine Learning, 2(4):319–342.
  2. [2]Pepa Atanasova et al. 2023. Faithfulness tests for natural language explanations. In ACL (Volume 2: Short Papers), pages 283–294.
  3. [3]Peter Belcak, Greg Heinrich, Shizhe Diao, Yonggan Fu, Xin Dong, Saurav Muralidharan, Yingyan Celine Lin, and Pavlo Molchanov. 2025. Small language models are the future of agentic AI. arXiv preprint arXiv:2506.02153.arxiv.org/abs/2506.02153
  4. [4]Guy Blanc, Jane Lange, and Li-Yang Tan. 2021. Provably efficient, succinct, and precise explanations. arXiv preprint arXiv:2111.01576.arxiv.org/abs/2111.01576
  5. [5]David Campbell, Neil Kale, Udari Madhushani Sehwag, Bert Herring, Nick Price, Dan Borges, Alex Levinson, and Christina Q Knight. 2026. Defensive refusal bias: How safety alignment fails cyber defenders. arXiv preprint arXiv:2603.01246.arxiv.org/abs/2603.01246
  6. [6]Yanda Chen et al. 2024. Do models explain themselves? counterfactual simulability of natural language explanations. In ICML, volume 235, pages 7880–7904.arxiv.org/abs/2307.08678
  7. [7]Sanjiban Choudhury. 2025. Process reward models for LLM agents: Practical framework and directions. arXiv preprint arXiv:2502.10325.arxiv.org/abs/2502.10325
  8. [8]Adnan Darwiche and Auguste Hirth. 2020. On the reasons behind decisions. arXiv preprint arXiv:2002.09284.arxiv.org/abs/2002.09284
  9. [9]Edoardo Debenedetti, Ilia Shumailov, Tianqi Fan, Jamie Hayes, Nicholas Carlini, Daniel Fabian, Christoph Kern, Chongyang Shi, Andreas Terzis, and Florian Tramèr. 2025. Defeating prompt injections by design. arXiv preprint arXiv:2503.18813.arxiv.org/abs/2503.18813
  10. [10]Edoardo Debenedetti, Jie Zhang, Mislav Balunović, Luca Beurer-Kellner, Marc Fischer, and Florian Tramèr. 2024. AgentDojo: A dynamic environment to evaluate prompt injection attacks and defenses for LLM agents. In NeurIPS Datasets and Benchmarks.arxiv.org/abs/2406.13352
  11. [11]Aradhya Dixit, Tianxi Liang, and Jai Telang. 2026. Project Aletheia: Verifier-guided distillation of backtracking for small language models. arXiv preprint arXiv:2601.14290.arxiv.org/abs/2601.14290
  12. [12]Kazuki Egashira, Mark Vero, Jasper DeKoninck, Florian E. Dorner, Robin Staab, and Martin Vechev. 2026. Delay, plateau, or collapse: Evaluating the impact of systematic verification error on rlvr. arXiv preprint arXiv:2605.02909.arxiv.org/abs/2605.02909
  13. [13]Kanishk Gandhi, Denise Lee, Gabriel Grand, Muxin Liu, Winson Cheng, Archit Sharma, and Noah D. Goodman. 2024. Stream of search (sos): Learning to search in language. arXiv preprint arXiv:2404.03683.arxiv.org/abs/2404.03683
  14. [14]Jiayi Geng, Howard Chen, Dilip Arumugam, and Thomas L. Griffiths. 2025. Are large language models reliable ai scientists? assessing reverse-engineering of black-box systems. arXiv preprint arXiv:2505.17968.
  15. [15]Arnav Gudibande, Eric Wallace, Charlie Snell, Xinyang Geng, Hao Liu, Pieter Abbeel, Sergey Levine, and Dawn Song. 2023. The false promise of imitating proprietary LLMs. arXiv preprint arXiv:2305.15717.arxiv.org/abs/2305.15717
  16. [16]Yoav Gur-Arieh, Ana Marasović, and Mor Geva. 2026. Faithfulness metrics don’t measure faithfulness: A meta-evaluation with ground truth. arXiv preprint arXiv:2605.25052.
  17. [17]Lukas Helff, Quentin Delfosse, David Steinmann, Ruben Härle, Hikaru Shindo, Patrick Schramowski, Wolfgang Stammer, Kristian Kersting, and Felix Friedrich. 2026. Llms gaming verifiers: Rlvr can lead to reward hacking. arXiv preprint arXiv:2604.15149.arxiv.org/abs/2604.15149
  18. [18]Arthur Hoarau, Chenrui Zhu, and Vu-Linh Nguyen. 2026. OPTIMUS-Prime: Minimal and sufficient concept explanations for deep vision models. arXiv preprint arXiv:2606.07180.arxiv.org/abs/2606.07180
  19. [19]Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yunzhang Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. LoRA: Low-rank adaptation of large language models. In ICLR.arxiv.org/abs/2106.09685
  20. [20]Alexey Ignatiev, Nina Narodytska, and Joao Marques-Silva. 2019. Abduction-based explanations for machine learning models. In AAAI, volume 33, pages 1511–1519.arxiv.org/abs/1811.10656
  21. [21]Ulrich Junker. 2004. QuickXPlain: Preferred explanations and relaxations for over-constrained problems. In Proceedings of the Nineteenth National Conference on Artificial Intelligence (AAAI-04), pages 167–172. AAAI Press.
  22. [22]Dong-Hee Kim, Reuben Tan, and Donghyun Kim. 2026. Diversity over frequency: Rethinking tool use in visual chain-of-thought agents. arXiv preprint arXiv:2606.00096.arxiv.org/abs/2606.00096
  23. [23]Lucas Lehnert, Sainbayar Sukhbaatar, DiJia Su, Qinqing Zheng, Paul Mcvay, Michael Rabbat, and Yuandong Tian. 2024. Beyond a*: Better planning with transformers via search dynamics bootstrapping. arXiv preprint arXiv:2402.14083.arxiv.org/abs/2402.14083
  24. [24]Anas Mahmoud, MohammadHossein Rezaei, Zihao Wang, Anisha Gunjal, Bing Liu, and Yunzhong He. 2026. Reward hacking in rubric-based reinforcement learning. arXiv preprint arXiv:2605.12474.arxiv.org/abs/2605.12474
  25. [25]Joao Marques-Silva and Alexey Ignatiev. 2022. Delivering trustworthy AI through formal XAI. In AAAI, volume 36, pages 12342–12350.
  26. [26]Harry Mayne, Ryan Othniel Kearns, Yushi Yang, Andrew M. Bean, Eoin Delaney, Chris Russell, and Adam Mahdi. 2025. Llms don’t know their own decision boundaries: The unreliability of self-generated counterfactual explanations. arXiv preprint arXiv:2509.09396.arxiv.org/abs/2509.09396
  27. [27]Seungyong Moon, Bumsoo Park, and Hyun Oh Song. 2024. Learning to better search with language models via guided reinforced self-training. arXiv preprint arXiv:2410.02992.arxiv.org/abs/2410.02992
  28. [28]Jaideep Ray. 2026. Before the model learns the bug:fuzzing rlvr verifiers. arXiv preprint arXiv:2606.01066.arxiv.org/abs/2606.01066
  29. [29]Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. 2018. Anchors: High-precision model-agnostic explanations. In AAAI, volume 32, pages 1527–1535.DOI
  30. [30]Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. 2024. DeepSeekMath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300.arxiv.org/abs/2402.03300
  31. [31]Andy Shih, Arthur Choi, and Adnan Darwiche. 2018. A symbolic approach to explaining Bayesian network classifiers. In IJCAI, pages 5103–5111.arxiv.org/abs/1805.03364

Paper details

vlnc:W_6sff6yrp
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 1

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

LLM assistance

View statement
Looking for related papers…
Contents