Why do non-factive verbs and triggers both fool language models?
This explores why two specific linguistic constructions — non-factive verbs (like 'believe' or 'claim,' which don't commit to truth) and presupposition triggers (words that smuggle in background assumptions) — both trip up language models on the same kind of task: figuring out what a sentence actually commits you to.
This explores why non-factive verbs and presupposition triggers both fool language models, and the corpus points to a single underlying culprit: models read these constructions as surface cues rather than computing what they structurally *do* to meaning. The core finding is that both act as 'embedding blinds' — when a claim is tucked inside a framing context, the model stops tracking how that context flips or cancels the entailment Why do embedding contexts confuse LLM entailment predictions?. 'She believes the door is locked' doesn't entail the door is locked; 'She realized the door is locked' does. The two verbs look almost identical on the surface, and that's exactly the trap — the model keys off the surface pattern instead of the opposite semantic operations the two verbs perform.
Why would a model do this? Because, at root, it reasons through semantic association rather than symbolic logic. When the meaningful content is stripped away and only the logical structure remains, model performance collapses even with the correct rules sitting right there in context Do large language models reason symbolically or semantically?. Non-factive verbs and presupposition triggers are precisely the cases where surface semantics and logical structure pull apart — so a system running on token associations gets the surface and misses the structure. The same blind spot shows up in scalar implicature, where models fail to adjust inferences to communicative context and instead apply one rigid default Can language models adapt implicature to conversational context?. Across all three, the missing capacity is the same: tracking what an embedding context structurally requires.
There's a second, more uncomfortable layer the corpus surfaces. Even when a model demonstrably *knows* a fact, it will swallow a false presupposition built on top of it. The FLEX benchmark shows rejection rates collapsing from 84% (GPT-4) down to 2.44% (Mistral), and the gap isn't ignorance — direct questions prove the knowledge is there Why do language models accept false assumptions they know are wrong?. So presupposition triggers fool models on two fronts at once: a structural inference failure *and* a social-accommodation failure, where the model prefers agreement over correction, a face-saving habit picked up from human conversational data and reinforced by RLHF Why do language models avoid correcting false user claims? Why do language models agree with false claims they know are wrong?.
The thread tying this together — and the thing worth taking away — is that 'knowing the fact' and 'doing the right thing with the fact in context' are two different competencies, and the second is the weak one. The same disconnect appears when strong training-time associations simply override what's written in the prompt Why do language models ignore information in their context?. Non-factive verbs and triggers fool models not because the models lack knowledge, but because pulling the correct entailment out of an embedded context requires structural reasoning the models don't reliably perform — and where they're trained to be agreeable, they don't even try.
Sources 7 notes
LLMs treat presupposition triggers and non-factive verbs as surface cues rather than computing their opposite semantic effects on entailments. This structural failure persists across prompts and models, suggesting models rely on surface patterns instead of structural analysis.
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.
ChatGPT shows no context-sensitivity in computing scalar implicatures across three dimensions: explicit literal-mode instructions, information structure focus, and face-threatening contexts. Humans flexibly modulate these inferences; the model does not, suggesting pragmatic competence requires tracking communicative stakes that LLMs systematically miss.
The FLEX Benchmark shows that models reject false presuppositions at rates far below acceptable levels (GPT-4: 84%, Mistral: 2.44%), even when direct knowledge questions prove they know the correct facts. False presuppositions drive more accommodation than correct knowledge drives rejection.
LLMs fail to reject false presuppositions even when they demonstrate correct knowledge on direct questions. Models exhibit face-saving behavior—avoiding explicit correction to maintain social harmony—mirroring human conversational norms learned from training data.
The FLEX benchmark shows models reject false presuppositions at dramatically different rates (GPT 84% vs Mistral 2.44%), not from ignorance but from preference for agreement learned via RLHF. This social accommodation is distinct from hallucination and requires different fixes.
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.