What makes an argument fallacious according to formal linguistic criteria?
This explores whether "fallacious" can be pinned to formal-linguistic structure in an argument itself — rather than to who's arguing, or to the back-and-forth of debate — and the corpus has a surprisingly specific proposal for that.
This explores whether what makes an argument fallacious can be located in the formal-linguistic structure of the argument itself, rather than in social context or the dynamics of a debate. The sharpest answer in the collection comes from Wagemans' first-order vs. second-order argument distinction Do first-order and second-order arguments unify classical and modern divisions?. The claim is bold: this single structural distinction lines up with both the classical split between internal and external topoi *and* the modern split between reasonable and fallacious arguments. If that holds, fallacy isn't just a matter of dialectical rules-of-engagement — it has a specifiable linguistic shape you can read off the form of the inference.
But the corpus immediately complicates the dream of a clean formal test. Reconstructing what argument a text is even making turns out to be underdetermined Why do different people reconstruct the same argument differently?: the same passage supports multiple valid formalizations with no ground truth, and that's a feature of the task, not annotation sloppiness. And classifying which *scheme* an argument follows carries unusually high cognitive load Why does argument scheme classification stumble where other NLP tasks succeed? — recognizing inferential patterns requires integrating cues spread across the whole text, not spotting local surface features. So even if fallacy has formal structure, that structure lives in distributed inferential relationships, not in tidy keyword signals.
Where's the thing you might not have expected to learn: a lot of what *feels* fallacious operates below the level of the explicit argument entirely — in presupposition. Presuppositions persuade more effectively than direct assertions Why are presuppositions more persuasive than direct assertions? precisely because they smuggle new claims in as already-accepted background, bypassing the scrutiny we'd apply to an open assertion. This is a formal-linguistic mechanism — factive, additive, and iterative triggers — and it's a vulnerability: language models accept false presuppositions even when they demonstrably know the facts Why do language models accept false assumptions they know are wrong?, and their performance halves on questions built on false assumptions Why do language models struggle with questions containing false assumptions?. So one honest answer to "what makes an argument fallacious" is: it often isn't the argument at all, it's the unargued frame the argument rides in on.
The corpus also suggests the formal-criteria view has limits worth naming. LLMs fall for fallacies far more than humans do Why do LLMs accept logical fallacies more than humans? because they respond to rhetorical persuasiveness over logical validity — and chain-of-thought offers no defense. Part of what humans bring that a text-only model can't is the social weight of *who* is arguing Can language models distinguish expert arguments from common assumptions? — reputation and track record that no formal structure encodes. The most practical takeaway is that forcing the structure to the surface helps: prompting that makes warrants and backing explicit (a Toulmin-style move) catches inferential gaps that ordinary reasoning glosses over Can structured argument prompts make LLM reasoning more rigorous?, and Dung-style argumentation frameworks turn arguments into attack/defense graphs you can actually contest premise by premise Can formal argumentation make AI decisions truly contestable?. Fallacy may have formal structure — but you mostly catch it by dragging the hidden parts of the argument into the open.
Sources 10 notes
Wagemans proposes that the first-order vs second-order argument distinction reflects both the classical internal-external topoi divide and the modern reasonable-fallacious distinction. This suggests fallacy theory operates through specifiable formal-linguistic structure rather than purely dialectical criteria.
Multiple valid argument reconstructions exist for the same text with no ground truth. This is not annotation error but an inherent feature of the task—different formalization schemas are each internally valid.
Scheme classification requires recognizing inferential patterns across distributed text spans, not local surface features. Models plateau at F1 0.55–0.65 while the same systems exceed 0.80 on component tagging and stance, suggesting the integrative reasoning demand is fundamentally different.
Experimental evidence shows presuppositions with additive, iterative, and factive triggers persuade audiences more than assertions, especially for discourse-new content. The mechanism: presuppositions bypass evaluative scrutiny by presenting claims as already-accepted background.
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.
The (QA)2 benchmark found that zero-shot LLMs halve their performance when questions contain false or unverifiable assumptions compared to valid questions. Even top models reached only 56% acceptability, and the gap persists despite model scaling, suggesting false presuppositions embedded in plausible language are systematically difficult to reject.
The LOGICOM benchmark shows LLMs are susceptible to rhetorical persuasiveness over logical validity, even in reasoning-optimized models. Chain-of-thought reasoning provides no meaningful defense against well-elaborated invalid arguments.
LLMs lose the social context that gives expert claims their force—reputation, track record, and standing—because they process only text, not the social world where expertise is built and evaluated.
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.
Dung-style argumentation structures AI outputs as traversable attack/defense graphs, allowing users to identify and contest specific premises. Standard LLM outputs lack this structure, making it impossible to pinpoint which claims users actually reject.