💬 NLP

Theory-Grounded Evaluation of Human-Like Fallacy Patterns in LLM Reasoning

This paper evaluates 38 language models using the Erotetic Theory of Reasoning to demonstrate that as model capability increases, their errors become more aligned with specific human-like fallacy patterns rather than random mistakes, and that premise order significantly influences fallacy production.

Original authors: Andrew Keenan Richardson, Ryan Othniel Kearns, Sean Moss, Vincent Wang-Mascianica, Philipp Koralus

Published 2026-03-24

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Andrew Keenan Richardson, Ryan Othniel Kearns, Sean Moss, Vincent Wang-Mascianica, Philipp Koralus

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are teaching a robot to be a detective. You give it a stack of clues (premises) and ask it to solve a mystery. If the robot gets the answer wrong, you want to know: Is it making a random mistake, or is it making the same kind of mistake a human would make?

This paper, presented at a major AI conference, asks exactly that question. The researchers wanted to see if Large Language Models (LLMs)—the brains behind chatbots like the one you're talking to—are just "stupid" in random ways, or if they have a specific, predictable "human-like" way of getting things wrong.

Here is the breakdown of their findings, using some everyday analogies.

1. The "Human Glitch" Theory

The researchers used a special theory called the Erotetic Theory of Reasoning (ETR). Think of this theory as a "blueprint for human brain fog."

The Analogy: Imagine your brain is a filter. When you hear a complex story, your brain tries to keep all the possibilities open. But sometimes, to save energy, your brain accidentally drops a possibility too early. This leads to a specific type of logical error called a "fallacy."
The Tool: The team built a software tool called PyETR (a calculator for this theory). It generates thousands of logic puzzles designed specifically to trigger these "brain fog" moments in humans.

2. The Experiment: 38 Detectives, 383 Puzzles

They took 38 different AI models (ranging from small, cheap ones to massive, super-smart ones) and gave them 383 of these logic puzzles.

They looked for two things:

Did the AI get the answer right?
If it got it wrong, did it make the specific mistake that the "Human Brain Fog Blueprint" predicted?

3. The Big Surprise: Smarter AI = More Human-Like Mistakes

This is the most counter-intuitive finding. Usually, we think: "The bigger and smarter the AI, the fewer mistakes it makes."

The Reality:

Overall Accuracy: As the AI got "smarter" (measured by how well it performs in general chatbot tournaments), its ability to get the right answer on these logic puzzles did not improve. It stayed roughly the same.
The "Human" Error Rate: However, when the smarter AIs did get it wrong, they were much more likely to make the specific, human-like mistakes predicted by the theory.

The Metaphor:
Imagine a group of students taking a tricky math test.

The "Dumb" Student: Gets the answer wrong because they can't do the math at all. They guess randomly.
The "Smart" Student: Knows the math, but when they slip up, they slip up in a very specific way because they are overthinking it or relying on a bad habit.
The Finding: As the AI models got "smarter" (more like the Smart Student), their errors stopped being random noise and started looking exactly like the specific, predictable errors humans make. They weren't just failing; they were failing like us.

4. The "Order of Operations" Trick

The researchers also played a trick on the AIs. In logic, the order of clues shouldn't matter. (If A implies B, and B implies C, it doesn't matter if you say A then B, or B then A).

But humans are weird. If you tell a human a story in a different order, they might get confused and make a mistake.

The Test: The researchers gave the AIs the same logic puzzles but swapped the order of the clues.
The Result: For many models, simply reversing the order of the sentences stopped them from making the human-like mistake. It was like giving the AI a "reset button" that broke the bad habit. This proves the AI isn't just calculating; it's reacting to the flow of the story, just like a human does.

5. Why Does This Matter?

This is a double-edged sword.

The Good News: It means AI is becoming sophisticated enough to understand the nuances of human language and reasoning patterns. It's not just a calculator; it's starting to think like a person.
The Bad News: It means that as AI gets more powerful, it might inherit our worst cognitive biases. If we use AI for medical diagnoses or legal advice, we can't just assume it will be "more logical" than us. It might be more logical in some ways, but it will still fall into the same traps our brains do.

The Bottom Line

The paper concludes that scaling up AI (making it bigger and smarter) doesn't automatically fix its reasoning. Instead, it seems to tune the AI to make the same systematic errors humans make.

The Takeaway: If you want to build a truly reliable AI, you can't just make it bigger. You have to specifically train it to avoid the "human glitches" that even our smartest models are now picking up. We need to teach the robot not just how to think, but how to stop thinking like a human when logic is required.

1. Problem Statement

While Large Language Models (LLMs) demonstrate increasing capability in complex reasoning tasks, it remains unclear whether their reasoning errors are random or systematic. Specifically, the authors investigate whether LLM errors align with established human fallacy patterns.

The core hypothesis is that if LLMs share reasoning mechanisms with humans (or are trained on human data containing these patterns), their logical failures should not be random noise but should follow predictable, theory-driven structures. The paper seeks to determine:

Do LLMs commit the same specific logical fallacies predicted by cognitive theories of human reasoning?
Does the prevalence of these specific fallacies correlate with model capability (e.g., size, training compute, or benchmark scores)?
Do LLMs exhibit "order effects" (where the sequence of premises changes the conclusion), a known phenomenon in human reasoning but not in classical logic?

2. Methodology

Theoretical Framework: Erotetic Theory of Reasoning (ETR)

The study utilizes the Erotetic Theory of Reasoning (ETR), a formal cognitive theory positing that reasoning involves maintaining disjunctive alternatives (candidate answers) and filtering them as new information arrives. ETR predicts that humans systematically drop relevant alternatives during this filtering process, leading to specific, predictable fallacies (e.g., "illusory inferences").

Data Generation: PyETR Pipeline

To avoid data contamination and ensure theoretical rigor, the authors used PyETR, an open-source implementation of ETR.

Synthetic Generation: They programmatically generated 383 formally specified reasoning problems.
Mutation Rules: Starting from a bank of 12 base logical templates (e.g., Modus Ponens, Disjunction Fallacy), they applied mutation functions (predicate addition, variable substitution, negation, etc.) to create unique problems.
Stopping Conditions: Problems were generated only if ETR predicted a non-trivial logical fallacy as the "default" human response.
Natural Language Mapping: To test LLMs, these formal views were mapped to 12 diverse thematic contexts (e.g., "Alchemy," "Planets," "Magical Creatures") to ensure content agnosticism and mitigate memorization of training data.

Experimental Setup

Models Evaluated: 38 LLMs ranging from smaller models (e.g., Mistral 7B) to large frontier models (e.g., GPT-4.5, Claude 3.7).
Capability Proxies: Models were ranked using Chatbot Arena Elo, HELM benchmark scores, and training compute estimates (FLOPs).
Evaluation Metric:
- Logical Correctness: Determined via PySMT (checking if the conclusion is a logical consequence of premises).
- ETR-Predicted Fallacy: Determined if the model's incorrect answer matched the specific fallacy predicted by ETR's default procedure.
- Key Metric: The Fallacy Rate, defined as the proportion of incorrect answers that were specifically ETR-predicted fallacies.
Intervention: A subset of tests involved reversing the order of premises to measure "order effects."

3. Key Contributions

Correlation between Capability and Human-Like Errors: The paper provides the first statistically significant evidence that as model capability increases (measured by Chatbot Arena Elo), the composition of errors shifts. Specifically, stronger models do not necessarily get more correct answers on this dataset, but their incorrect answers are increasingly likely to be the specific fallacies predicted by human cognitive theory ( $\rho = 0.360, p = 0.0265$ ).
Open-Source Synthetic Benchmarking: The authors introduce a pipeline using PyETR to generate unbounded, contamination-resistant reasoning tasks. This moves beyond static benchmarks (which LLMs may have memorized) to dynamic, theory-grounded evaluation.
Replication of Human Order Effects: The study demonstrates that LLMs exhibit the same "premise order effects" as humans. Reversing the order of premises significantly reduced fallacy production for many models, suggesting a non-commutative processing mechanism similar to human cognition.
Decoupling Accuracy from Error Type: The results challenge the assumption that scaling leads to purely normative (logically perfect) reasoning. Instead, scaling appears to align model error patterns with human fallacy patterns, even if overall accuracy does not improve proportionally.

4. Key Results

Error Composition vs. Capability:
- There is a positive correlation between Chatbot Arena Elo and the proportion of errors that are ETR-predicted fallacies.
- Conversely, there is no correlation between model Elo and the overall percentage of correct answers on this specific dataset ( $r = 0.004$ ).
- Similar correlations were found with training compute estimates ( $\rho = 0.489$ ) and HELM scores.
Order Effects:
- Reversing premise order significantly blocked fallacy production for a majority of models.
- Table 4 in the paper shows that for models like gpt-4.5-preview and claude-3.5-sonnet, reversing premises blocked 68% and 65% of fallacies respectively, with high statistical significance ( $p < 0.05$ ).
Qualitative Analysis: Manual inspection of model traces revealed that models often fixate on repeated objects or predicates (a known human bias) and incorrectly instantiate existential quantifiers, mirroring the "filtering" errors described by ETR.

5. Significance and Implications

Theoretical Implication: The findings suggest that LLMs, particularly larger ones, are converging toward human-like reasoning failures, not just successes. This implies that current training paradigms (likely involving human-generated data) may be encoding human cognitive biases into the models' reasoning architectures.
Evaluation Paradigm Shift: The paper argues for a shift in LLM evaluation from purely measuring accuracy (error rate) to analyzing error composition. A model that makes "human-like" errors might be more aligned with human expectations but less reliable for normative tasks.
AI Safety and Alignment: As models become more capable, they may become more susceptible to the same subtle logical traps that affect human experts. This is critical for high-stakes domains (legal, medical) where reliable reasoning is required.
Future Directions: The authors propose using these identified fallacy patterns as targeted training examples to "fortify" models against human-like reasoning errors, potentially creating systems that combine human-like understanding with robust, normative reasoning.

In summary, the paper establishes that stronger LLMs are not just "smarter" but are also "more human" in their specific types of logical failures, providing a new lens for understanding the limitations and biases of artificial reasoning systems.