Why can LLMs interpret formal logic better than they generate it?
This explores why LLMs can read and check formal logic more reliably than they can write it — and what that asymmetry reveals about how they reason underneath.
This explores why LLMs can read and check formal logic more reliably than they can write it — and what that asymmetry reveals about how they reason underneath. The cleanest evidence comes from translation: when LLMs are asked to turn natural language into formal logic, they produce expressions that are syntactically valid but semantically wrong, with errors clustering at quantifier precision, scope ambiguity, and predicate granularity Can large language models translate natural language to logic faithfully?. The same work notes the flip side directly — models seem to understand formal language better than they can generate it. Reading logic is recognition; generating it is committing to exact structure, and that's where they break.
The deeper reason is that LLMs don't actually run logic — they run meaning. When researchers strip the semantic content away and leave only the formal rules, performance collapses, suggesting models lean on commonsense associations and token patterns rather than symbolic manipulation Do large language models reason symbolically or semantically?. You can watch this happen inside the network: syllogistic reasoning runs through a real, content-independent three-stage circuit, but extra attention heads carrying world knowledge keep tilting conclusions toward what sounds plausible rather than what's logically valid — and the contamination gets worse at larger scale How do language models perform syllogistic reasoning internally?. Interpretation tolerates this fuzziness; generation doesn't.
This is really a specific case of a broader split the corpus documents everywhere: models can articulate a principle correctly yet fail to execute it. That's the "knowing-doing gap" (correct rationales 87% of the time, correct actions only 64%) Why do language models fail to act on their own reasoning?, the "comprehension without competence" split-brain pattern Can language models understand without actually executing correctly?, and Potemkin understanding, where explanation and application run on functionally disconnected pathways Can LLMs understand concepts they cannot apply?. Interpreting logic taps the explanation pathway; generating faithful logic demands the execution one. The asymmetry you're asking about is the logic-flavored version of this structural disconnect How do LLMs fail to know what they seem to understand?.
The fixes that work all respect this. Logic-LM lets the model do the part it's good at — formulating a representation — and hands inference to a deterministic solver that returns machine-checkable error messages, which catch translation mistakes the model can't catch itself Can symbolic solvers fix how LLMs reason about logic?. Tellingly, full formalization isn't even the goal: partial symbolic augmentation beats both pure language and complete formalization, because forcing everything into formal structure throws away the semantic information the model actually reasons with Why does partial formalization outperform full symbolic logic?. And there's a clean theoretical reason the model can't just fix its own generation: self-improvement is bounded by a generation-verification gap — reliable correction needs an external checker, exactly what the solver provides What stops large language models from improving themselves?.
The thing you might not have expected to learn: the gap isn't a knowledge deficit you could train away with more logic examples. It's architectural — reasoning lives in latent hidden-state trajectories that surface text only partially exposes Where does LLM reasoning actually happen during generation?. Which is why the most reliable interventions don't try to make the model a better logician; they bolt structure onto it from outside — a solver, or scaffolds like Toulmin-style critical questions that force the warrants to be made explicit Can structured argument prompts make LLM reasoning more rigorous?.
Sources 12 notes
LLMs generate well-formed logical expressions that are semantically incorrect, with errors clustering at scope ambiguity, quantifier precision, and predicate granularity. The asymmetry suggests LLMs understand formal language better than they can generate it.
When semantic content is decoupled from reasoning tasks, LLM performance collapses even with correct rules in context. Models rely on parametric commonsense and token associations rather than formal logical manipulation, constraining reasoning to training distribution semantics.
LLMs implement a content-independent three-stage reasoning mechanism—recitation, middle-term suppression, mediation—that works across architectures. However, additional attention heads encoding world knowledge systematically bias conclusions toward semantically plausible rather than logically valid answers, with contamination increasing at larger scales.
LLMs generate correct reasoning 87% of the time but follow it only 64% of the time. Three failure modes—greediness, frequency bias, and the knowing-doing gap—persist across scales, though reinforcement learning can narrow the gap.
Large language models can articulate correct principles but systematically fail to apply them due to dissociated instruction and execution pathways. The 87% accuracy in explanations versus 64% in actions reveals this is not knowledge deficit but structural disconnect.
Models can explain concepts accurately, fail to apply them, and recognize the failure—a triple pattern incompatible with human cognition. This indicates functionally disconnected explanation and execution pathways rather than simple knowledge gaps.
LLMs show repeatable, empirically documented failure modes—from Potemkin understanding (correct explanation + failed application) to reasoning collapse under implicit constraints. These failures reveal gaps between statistical pattern-tracking and actual epistemic competence.
Logic-LM divides cognitive labor by having LLMs formulate symbolic representations while deterministic solvers execute inference and provide machine-verifiable error messages. This structured feedback loop catches translation errors better than LLM self-critique, improving faithful reasoning without requiring perfect formalization.
QuaSAR and Logic-of-Thought both achieve 4-8% accuracy gains by enriching natural language with selective symbolic elements rather than replacing it. Full formalization loses semantic information; pure language lacks structure. Augmentation preserves both.
Self-improvement in LLMs is formally bounded by the generation-verification gap, meaning every reliable fix requires something external to validate and enforce it. Models cannot escape this constraint through metacognition alone.
Evidence from CoT faithfulness tests, feature steering, and layer analysis suggests latent-state dynamics drive reasoning, while surface chain-of-thought serves as a partial interface. Hidden reasoning processes should be the default focus of study.
Applying Toulmin's argument model as explicit prompting steps (CQoT) improves LLM reasoning by forcing models to identify warrants and backing rather than skipping implicit premises. The method catches failures that standard chain-of-thought prompting allows.