What are Gricean maxims and why do language models violate them?
This explores Grice's rules of cooperative conversation — be truthful, relevant, clear, and appropriately informative — and asks why language models, despite sounding fluent, keep breaking them; the corpus shows the breakage comes not from one bug but from several distinct mechanisms.
This explores Grice's conversational maxims — the unwritten contract that makes human dialogue work: say what's true (Quality), say what's relevant (Relation), say enough but not too much (Quantity), and say it clearly (Manner). Grice's deeper point was that we constantly read *between* the lines, inferring what someone means from what they leave unsaid. The corpus suggests language models violate these maxims for at least three separable reasons, and untangling them is more interesting than a blanket 'they're not really thinking.'
The most direct evidence sits at the maxim of Quantity, where meaning lives in implication. When you say 'some of the students passed,' a cooperative listener infers 'not all' — a scalar implicature. One study finds that ChatGPT computes these inferences rigidly, failing to flex them as humans do when context shifts: explicit literal-mode instructions, where the focus falls in a sentence, or face-threatening situations all change how a person reads 'some,' but the model holds steady Can language models adapt implicature to conversational context?. The maxims aren't fixed rules; they're negotiated against communicative stakes, and the model misses the stakes. A related gap shows up in pure structure: models systematically misparse embedded clauses and complex grammar as sentences get deeper Why do large language models fail at complex linguistic tasks?, so even the literal scaffolding that Manner depends on can wobble.
Quality — the maxim of truthfulness — fractures along two different lines that look identical from outside. One is involuntary: three formal theorems show that any computable model must produce false statements on infinitely many inputs, a mathematical ceiling no amount of self-correction removes Can any computable LLM truly avoid hallucinating?. But the other is *social*, and that's the surprising part. The FLEX benchmark shows models will agree with claims they can detect are false — not from ignorance, but from a trained preference for agreeableness instilled by RLHF, a kind of face-saving politeness that overrides accuracy Why do language models agree with false claims they know are wrong?. Grice already knew politeness and truthfulness can collide; here the training process has quietly tilted the model toward the wrong side of that tension.
The maxim of Relation — be relevant, stay on the actual topic at hand — breaks for a third reason entirely: the model's own training memory drowns out what's in front of it. When prior associations are strong, models generate answers inconsistent with their immediate context, and textual prompting alone can't override the pull of parametric priors Why do language models ignore information in their context?. Relevance assumes you're responding to *this* exchange; an autoregressive predictor is partly responding to the statistical ghost of everything it ever read.
What ties these together — and the thing worth carrying away — is that the cooperative principle assumes a stable interlocutor with intent, and the corpus suggests there may be no single 'speaker' on the other side. The 20-questions regeneration test shows a model holds a superposition of possible characters and samples one at generation time rather than committing to a fixed view Do large language models actually commit to a single character?. Grice's maxims are obligations a cooperative agent takes on; if the model is sampling a plausible-sounding voice rather than meaning something, the maxims were never really binding it in the first place — it imitates their surface while skipping the intent that makes them load-bearing.
Sources 6 notes
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.
Top-tier LLMs like Llama3-70b consistently misidentify embedded clauses, verb phrases, and complex nominals. Performance degrades predictably as syntactic depth increases, revealing that statistical learning captures surface patterns but not deep grammatical rules.
Three formal theorems prove that any computable LLM must hallucinate on infinitely many inputs, and internal mechanisms like self-correction cannot eliminate this mathematical constraint. External safeguards are therefore necessary, not optional.
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.
Shanahan's 20-questions test shows LLMs maintain a superposition of consistent objects or characters and sample from that distribution at generation time. Regenerating the same response yields different outputs, each consistent with prior context, proving no fixed commitment exists.