Can autoregressive models learn faithful translation to logical representations without semantic loss?
This explores whether autoregressive language models can translate natural language into formal logic (autoformalisation) while preserving the original meaning — and whether the failures we see are surface slips or something deeper in how these models reason.
This explores whether autoregressive models can faithfully turn natural language into logical representations without losing meaning along the way. The most direct answer in the corpus is sobering: models produce logic that *looks* right but *means* the wrong thing. Can large language models translate natural language to logic faithfully? finds LLMs generate syntactically valid logical expressions that are semantically incorrect, with errors clustering around scope ambiguity, quantifier precision, and predicate granularity — exactly the places where meaning lives. Intriguingly, the same work suggests models can *recognize* correct formalizations better than they can *produce* them, so the bottleneck is generation, not comprehension.
Why does generation break down? Two notes point at the underlying mechanism rather than the symptom. Do large language models reason symbolically or semantically? shows that when you strip the familiar semantic content out of a reasoning task and leave only the formal rules, performance collapses — models lean on commonsense token associations, not symbolic manipulation. Faithful logical translation demands exactly the symbolic discipline these models lack. Reinforcing this, Do language models really understand meaning or just surface frequency? finds models systematically prefer high-frequency surface phrasings over semantically equivalent rare ones, even when meaning is identical. A model tracking statistical mass rather than meaning will quietly drift toward the common reading of an ambiguous sentence rather than the logically precise one — which is precisely the "semantic loss" the question asks about.
There's a deeper, almost philosophical thread here. Do transformer models store knowledge or generate it continuously? argues transformers hold knowledge as flowing activations rather than fixed, retrievable symbols — closer to oral performance than to a written archive. Logic is the opposite: discrete, stable, composable. If knowledge in these models is fundamentally continuous and context-bound, faithful mapping onto crisp logical form may be working against the grain of the architecture itself. And Why do language models ignore information in their context? shows that strong training priors can override what's actually in the prompt — so even a correctly stated premise can get silently "corrected" toward what the model expects.
But the corpus isn't entirely pessimistic, and this is where it gets interesting. The capability may be present yet buried. Do transformers hide reasoning before producing filler tokens? finds models compute correct answers in early layers and then *overwrite* them to produce format-compliant output — the right reasoning is recoverable, just suppressed. And Can LLMs actually forecast time series better than we think? shows that separating distinct kinds of reasoning into structured workflows surfaces abilities that monolithic prompting hides. Read together, these suggest the question "can autoregressive models do this?" might be the wrong frame — the latent competence may exist, but it's lost in a single greedy left-to-right pass.
That reframing makes Can diffusion language models match autoregressive inference speed? the quiet surprise of this collection: it questions whether strict autoregression is even the right generation paradigm, hybridizing block-wise AR with parallel decoding. If faithfulness suffers because each token is committed irreversibly before the global logical structure is settled, a less strictly sequential approach — or a workflow that lets the model revise scope and quantifiers — may be where faithful formalization actually becomes reachable. The honest bottom line: today's autoregressive models fail at semantically faithful logic translation, and the corpus suggests the cause is architectural and statistical, not a bug to be patched away — but the same notes hint the latent ability is realer than the output looks.
Sources 8 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 show consistent preference for higher-frequency surface forms over semantically equivalent rare paraphrases across math, machine translation, commonsense reasoning, and tool calling. This suggests models track statistical mass from pretraining rather than meaning-recognition as their primary mechanism.
Transformers organize knowledge as flowing activations rather than retrievable archives, mirroring oral cultures where knowledge exists only in performance. This explains why model knowledge is contextual, difficult to edit, and inseparable from generation.
Research demonstrates that LMs generate outputs inconsistent with their context because parametric knowledge from training dominates over in-context information. Textual prompting alone cannot override strong priors; causal intervention in representations is required.
Logit lens analysis shows models trained with hidden CoT tokens compute correct answers in layers 1-3, then actively suppress these representations in final layers to produce format-compliant filler output. The reasoning is fully recoverable from lower-ranked token predictions.
LLMs have stronger intrinsic forecasting ability than recognized, but only when workflows separate numerical reasoning from contextual reasoning. Monolithic prompting obscures this capability; structured decomposition surfaces it.
Discrete Diffusion Forcing breaks the speed barrier through block-wise autoregressive generation with KV cache reuse and inter-block parallel decoding. This hybrid approach recovers both the compute efficiency of AR and the parallelism advantage of diffusion.