When a language model solves a physics or chemistry problem step by step, the visible reasoning usually mixes two different things. One is the choice of scientific premises: the gas is ideal, the surface is frictionless, the reaction is first order. The other is the arithmetic that follows from those premises. College-level evaluations show that the arithmetic improves with step-by-step prompting while the premises often stay wrong. A second, quieter problem is that a correct final answer on a public benchmark may be recalled from training data rather than derived from any premise at all. This proposal forces scientific reasoning through an explicit layer of named premises, which we call a premise bottleneck. The answer stage sees only those premises and the extracted quantities, not the original problem text. The premise labels needed to supervise and check this layer are produced automatically, from solution programs that are verified against reference answers, so no expert has to annotate them.
The payoff is twofold. Premise errors become visible and correctable: a user, or a checker, can fix one premise and recompute the answer. More importantly, the premise layer gives a way to generate fresh test items from old benchmarks. We swap one premise in a problem, rewrite the text, and recompute the correct answer from the edited program. A model that reasons from its stated premises must track the edit. A model that recalls the answer will not. The result is a contamination probe for natural-language scientific reasoning, a domain that graph-generated dynamic benchmarks have so far not reached.
Core Claim
We claim that a two-stage scientific reasoner can match tool-augmented chain-of-thought on standard scientific problems while answering premise-edited counterfactual versions of those problems far more reliably. In this reasoner, stage one maps the problem to a set of premises drawn from a fixed vocabulary plus the given quantities, and stage two computes the answer from that set alone. We further claim that the drop in accuracy from original to counterfactual items, which we call the recall gap, is a usable per-model and per-item measure of memorization. It should grow with signs of training exposure.
The contribution draws on all four directions in the file, though not equally. Concept bottlenecks supply the core mechanism. Chain-of-thought is the object being restructured. The annotation bottleneck is a constraint we must get around. Contamination is the main evaluation lens. Scientific literature plays a supporting role as the source of the premise vocabulary.
How This Relates to Prior Work
The motivating evidence comes from SciBench, which evaluates college-level science problems. It finds that chain-of-thought and Python tools reduce calculation errors but leave models misreading the underlying physical setup, peaking at 43.22% on its textbook set. We take that failure as the target and isolate the premise step that SciBench identifies as broken.
The mechanism comes from concept bottleneck models, which predict human-readable intermediate concepts and then predict the label only from those concepts. Label-free Concept Bottleneck Models removed the need for manual concept labels by having an LLM propose concepts and CLIP score them. Concept Bottleneck Large Language Models moved bottlenecks into LLMs for classification and generation. That work also found that a parallel unconstrained pathway leaks task information unless adversarial training blocks it. Both apply bottlenecks to single-step labeling such as topic classification, not to multi-step derivation. We borrow the bottleneck idea but make the separation hard: stage two is a separate call that physically cannot see the problem text. This avoids the leakage that CB-LLM had to fight with adversarial losses.
Causally Reliable Concept Bottleneck Models constrain our vocabulary design. That work warns that concept sets produced by prompting alone are incomplete and redundant, and it grounds them by retrieving from scientific abstracts. We follow it by grounding the premise vocabulary in literature. SPARK supplies the extraction idea: it distills papers into skeletons of conclusions, evidence and boundary conditions. Boundary conditions and stated assumptions are exactly the premises we need named. SPARK, however, feeds its skeletons into an ordinary end-to-end model as training text and never makes them an inspectable intermediate state.
On contamination, DyVal generates fresh problems from directed acyclic graphs. It shows that models strong on static benchmarks, such as phi-1.5 and WizardMath-13B, fall to near zero on structurally equivalent new problems. Its own stated limit is that it only works for formal domains like arithmetic, logic and reachability. Our premise edits are a way to do structure-preserving generation for natural-language science problems, with answers that can still be computed.
Unveiling Causal Reasoning in Large Language Models and LiveBench handle contamination by collecting post-cutoff material. That approach works but needs a constant supply of new human-authored content. It also says that scores dropped without saying which step failed.
Research Program
Premise vocabulary. The first component is the premise vocabulary. Using SPARK-style extraction, we pull stated assumptions and boundary conditions from textbook-level and open-access scientific text in physics, chemistry and the mathematical parts of SciBench. We cluster them into a few hundred canonical premises, for example "ideal gas," "isothermal," "rigid body," "steady state," "first-order kinetics," and "neglect air resistance." Where possible, each premise is paired with an alternative it can be swapped for, such as "kinetic friction with coefficient μ" for "frictionless." As in C²BM, each vocabulary entry must be supported by at least one retrieved literature passage, which filters out invented premises.
Labels without manual annotation. The second component replaces manual annotation. For each SciBench problem with a reference answer, a strong LLM proposes a decomposition: a premise set from the vocabulary, a table of given quantities, and a short program that computes the answer from those alone. We keep a decomposition only if the program reproduces the reference answer within SciBench's tolerance. Several proposals are sampled per problem, and premise sets that disagree across passing programs are flagged. This answer-checked filter is the label source. We report its cost against an estimate of expert annotation time, and we measure its precision on a human-audited sample of a few hundred problems.
The two-stage reasoner. Stage one reads the problem and emits premises plus quantities. It may reason freely before committing, but only its committed output is passed on. Stage two receives only that output and writes and runs code to produce the answer. The reasoner runs zero-shot on frontier and open models. A fine-tuned variant on an open model such as Qwen3-8B is trained on the verified decompositions.
Counterfactual edits. The third component is the counterfactual generator. For a verified item, we swap one premise for its paired alternative, edit the program accordingly, and recompute the answer. An LLM then rewrites the problem text so that it states the new condition. A different model checks that the rewritten text implies the edited premise set. A human audit sample estimates how often edited items are wrong. Each original item yields several counterfactuals.
The recall-gap metric. We define the recall gap of a model as follows. Let $A_{\text{orig}}$ be its accuracy on original items. Let $A_{\text{cf}}$ be its accuracy on counterfactual items whose original it answered correctly.
$$ \text{RG} = A_{\text{orig}} - A_{\text{cf}} $$
A model that derives answers from premises should have RG near the intrinsic difficulty difference between originals and edits. That difference is measured separately as the RG of the oracle-premise pipeline. Large excess RG signals recall.
Baselines
The naive reference points are direct answering with no intermediate reasoning and standard free-form chain-of-thought. Both are run with the same models, the same sampling settings and a matched cap on reasoning tokens. The cap stays below the roughly 16,384-token point beyond which the Humanity's Last Exam study reports accuracy degrading. These baselines tell us how much of any counterfactual drop is generic.
The strongest existing prompting method for this question is chain-of-thought with Python execution, the configuration SciBench evaluated. SciBench reports a peak of 43.22% accuracy on its textbook problems for GPT-4 with CoT and Python. It is the strongest competitor because it already removes arithmetic errors and so isolates exactly the premise step we claim to fix. We rerun it ourselves on current models with the same prompt-tuning budget we give our method: the same number of prompt variants tried on a held-out development split. To count as beating it, the premise bottleneck must be within two points of it on original items and clearly better on counterfactual items, with non-overlapping bootstrap intervals on $A_{\text{cf}}$.
For the fine-tuned variant, the strongest training-based reference is SPARK. Qwen3-8B fine-tuned on Spark-234K reports an average of 60.83 across GPQA, SciBench and MMLU-Pro, against 56.36 for the larger MegaScience set. No isolated SciBench number for SPARK was found on Lacuna. We therefore compare on the original-versus-counterfactual split by fine-tuning the same base model on matched-size chain-of-thought data and on our verified decompositions, with equal steps and compute. If Spark-234K is available, we also evaluate a SPARK-trained checkpoint directly.
Three ablations isolate the key ingredient, which is the hard separation of premises from text. In the soft bottleneck, stage two also sees the original problem text. In the prompted-premise variant, a single chain of thought is told to list its assumptions first. In the free-vocabulary variant, premises are written in free text rather than drawn from the vocabulary. The oracle-premise pipeline, which feeds verified premises to stage two, gives the upper bound and calibrates RG.
Why not just…?
Why not just prompt the model to state its assumptions before solving? This is the most serious threat, and the prompted-premise ablation exists to test it. Listing assumptions makes premises visible, but nothing forces the answer to depend on them. The model can write "assume frictionless" and then reproduce a memorized number. The CB-LLM finding that unconstrained pathways absorb the task signal suggests this will happen. Still, it is possible that strong models do follow their own stated premises. The deciding measurement is the premise-intervention test: we edit the stated premise inside the prompted chain and check whether the answer changes as recomputed. If prompted chains track edits as well as the hard bottleneck does, then the architecture adds nothing beyond the vocabulary and the counterfactual benchmark. We would report the contribution as those two pieces.
Why not just give the model a Python interpreter? SciBench already did this and found that models attend to code mechanics while misreading the physical setup. Our stage two uses code too. The difference lies entirely in stage one, and comparing CoT+Python with the bottleneck isolates it.
Why not just evaluate on newer or post-cutoff benchmarks like LiveBench or HLE? Fresh benchmarks are the right external check, and we use the oldest-versus-newest comparison below. But HLE needed a rolling update mechanism to stay ahead of saturation, and each refresh costs expert authoring. Fresh sets also show that scores fall without showing which step failed. Premise edits produce new items from existing verified ones at small cost, and they localize the failure to a named assumption. A real risk is that the edited items are simply harder or worded oddly. The oracle-premise calibration and the human audit are there to rule that out.
Why not just retrieve relevant literature (RAG)? Retrieval can supply the right premise text, but it does not make the answer depend on it. C²BM reports that associative models with literature access still take shortcuts. We include a retrieval-augmented CoT baseline that has the same vocabulary passages available.
Proposed Experiments and Decisive Checks
The main experiment runs all methods on SciBench originals and on their premise-edited counterfactuals, across physics, chemistry and math subsets. It reports $A_{\text{orig}}$, $A_{\text{cf}}$, RG, and premise accuracy against verified labels.
The first decisive check is the interaction. Free-form chain-of-thought and CoT+Python should show large excess RG. The hard bottleneck should show excess RG near zero at comparable $A_{\text{orig}}$. If the bottleneck's excess RG is not clearly smaller, the core claim fails.
The second check is intervention. We take items where stage one chose a wrong premise and replace it with the verified one. This should recover a large share of the errors, which would show that SciBench's premise failures are fixable at the layer we expose. We report recovered accuracy per premise class.
The third check validates RG as a contamination measure. Per-item recall gap should correlate with low token-level surprise on the original problem text, the signal Studying and improving reasoning in humans and machines used to detect memorized puzzles. RG should also be larger for older public items than for a small set of problems newly written by contributors after the evaluated models' cutoffs. If RG does not track either signal, we report it as a robustness measure rather than a contamination measure.
Finally, we test the annotation-bottleneck claim directly. We measure verified-label precision on the audit sample and report what fraction of SciBench items receive a verified decomposition. We then check whether fine-tuning on those automatic labels matches fine-tuning on the human-corrected subset. If it does, premise supervision for scientific reasoning can be obtained from reference answers alone.
References
- SciBench: Evaluating College-Level Scientific Problem-Solving Abilities of Large Language Models
- Label-free Concept Bottleneck Models
- Concept Bottleneck Large Language Models
- Causally Reliable Concept Bottleneck Models
- SPARK: Skeleton-Guided Reasoning Synthesis from Large-Scale Scientific Literature
- DyVal: Dynamic Evaluation of Large Language Models for Reasoning Tasks
- Unveiling Causal Reasoning in Large Language Models: Reality or Mirage?
- LiveBench: A Challenging, Contamination-Limited LLM Benchmark
- A benchmark of expert-level academic questions to assess AI capabilities
- Studying and improving reasoning in humans and machines