formal fallacies

overview

formal fallacies are errors in the logical structure of arguments. they make arguments invalid - even if all premises are true, the conclusion doesn’t necessarily follow. these are “formal” because the error lies in the form or pattern of reasoning, not the content.

understanding formal fallacies is crucial for constructing valid arguments, building sound reasoning systems, and identifying structural errors in automated logical reasoning.

characteristics

structural errors

formal fallacies violate rules of valid inference:

valid form (modus ponens):
P → Q    (if P then Q)
P        (P is true)
∴ Q      (therefore Q)

invalid form (affirming the consequent):
P → Q    (if P then Q)
Q        (Q is true)
∴ P      (therefore P)  (INVALID)

content independence

the same formal structure is invalid regardless of content:

example 1:
if it rains, the ground is wet
the ground is wet
∴ it's raining  (INVALID)

example 2:
if socrates is human, he is mortal
socrates is mortal
∴ socrates is human  (INVALID)

both use the invalid “affirming the consequent” form.

detectability

formal fallacies can be identified through:

• logical analysis: examining argument structure
• truth tables: showing invalidity
• counterexamples: finding cases where premises are true but conclusion false
• automated checking: using logical proof systems

common formal fallacies

affirming the consequent

pattern: $P \rightarrow Q, Q \vdash P$ (INVALID)

example:

if john studied hard, he passed the exam
john passed the exam
∴ john studied hard

why invalid: john might have passed through luck, prior knowledge, or cheating.

counterexample method: find case where premises are true but conclusion false:

• premise 1 (true): “if john studied hard, he passed”
• premise 2 (true): “john passed”
• conclusion (false): “john studied hard” (he actually got lucky)

denying the antecedent

pattern: $P \rightarrow Q, \neg P \vdash \neg Q$ (INVALID)

example:

if it rains, the ground gets wet
it's not raining
∴ the ground is not wet

why invalid: sprinklers, flooding, or spilled water could wet the ground.

valid alternative: contrapositive reasoning

if it rains, the ground gets wet
the ground is not wet
∴ it's not raining  ✓ (modus tollens)

undistributed middle

pattern (in syllogisms): when the middle term isn’t distributed in either premise

example:

all cats are mammals
all dogs are mammals
∴ all cats are dogs

why invalid: sharing a common property doesn’t make things identical.

formal analysis:

• middle term: “mammals”
• not distributed in either premise (doesn’t refer to all mammals)
• conclusion doesn’t follow

illicit major term

pattern: major term distributed in conclusion but not in major premise

example:

all politicians are public figures
some public figures are corrupt
∴ all politicians are corrupt

why invalid: the major term “corrupt” is distributed in conclusion (refers to all corrupt things) but not in the premise.

illicit minor term

pattern: minor term distributed in conclusion but not in minor premise

example:

no saints are sinners
some humans are not saints
∴ no humans are sinners

why invalid: “humans” is distributed in conclusion but not in the minor premise.

detection methods

structural analysis

1. identify argument form

   premise 1: P → Q
   premise 2: Q
   conclusion: P
   
   form: affirming the consequent (invalid)

2. check against valid inference rules

   • does the pattern match modus ponens, modus tollens, etc.?
   • if not, likely a formal fallacy

3. apply logical transformations

   • convert to standard logical notation
   • use proof methods to test validity

truth table method

construct truth table to show invalidity:

affirming the consequent: P → Q, Q ⊢ P

| P | Q | P→Q | premises true? | conclusion P |
|---|---|-----|----------------|-------------|
| T | T |  T  |      ✓        |      T      |
| T | F |  F  |      (INVALID)        |      T      |
| F | T |  T  |      ✓        |      F (INVALID)    |
| F | F |  T  |      (INVALID)        |      F      |

row 3 shows premises can be true while conclusion is false → invalid.

counterexample method

find concrete case where:

• all premises are true
• conclusion is false
• if possible, argument is invalid

claim: "all good students study hard; mary studies hard; therefore mary is a good student"

counterexample:
- mary studies hard (true)
- if good students study hard, then mary studying means she's good (premise true)
- but mary might study hard yet perform poorly due to learning disabilities
- so mary could study hard but not be a good student
- therefore: premises true, conclusion false → invalid

formal systems and validity

propositional logic

uses truth tables and natural deduction:

# pseudocode for validity checking
def is_valid_propositional(premises, conclusion):
    for assignment in all_truth_assignments():
        if all_premises_true(premises, assignment):
            if not conclusion_true(conclusion, assignment):
                return False  # counterexample found
    return True  # valid

predicate logic

uses proof methods and model theory:

valid syllogism:
∀x(P(x) → Q(x))  (all P are Q)
P(a)             (a is P)
∴ Q(a)           (therefore a is Q)

invalid form:
∀x(P(x) → Q(x))  (all P are Q)
Q(a)             (a is Q)
∴ P(a)           (therefore a is P) (INVALID)

modal logic

handles necessity and possibility:

valid:
□P        (P is necessarily true)
∴ ◊P      (therefore P is possibly true)

invalid:
◊P        (P is possibly true)
∴ □P      (therefore P is necessarily true) (INVALID)

automated detection

logic programming

% define invalid forms
invalid_form(affirming_consequent, [implies(P,Q), Q], P).
invalid_form(denying_antecedent, [implies(P,Q), not(P)], not(Q)).

% check if argument matches invalid pattern
is_formal_fallacy(Premises, Conclusion) :-
    invalid_form(Fallacy, Pattern, ConclusionPattern),
    match_pattern(Premises, Pattern),
    match_pattern(Conclusion, ConclusionPattern),
    !,
    write('Formal fallacy detected: '), write(Fallacy).

theorem provers

# using automated theorem prover
def check_validity_automated(premises, conclusion):
    theorem_prover = LogicalProver()

    # try to prove conclusion from premises
    result = theorem_prover.prove(premises, conclusion)

    if result.provable:
        return "valid"
    elif result.disprovable:
        return "invalid (formal fallacy)"
    else:
        return "undecidable"

pattern matching

# detect common formal fallacy patterns
def detect_formal_fallacies(argument):
    patterns = {
        'affirming_consequent': r'if (.+) then (.+)\. (.+)\. therefore (.+)\.',
        'denying_antecedent': r'if (.+) then (.+)\. not (.+)\. therefore not (.+)\.'
    }

    for fallacy_type, pattern in patterns.items():
        if re.match(pattern, argument):
            return f"formal fallacy: {fallacy_type}"

    return "no formal fallacy detected"

real-world examples

legal reasoning

fallacious legal argument:
if the defendant committed the crime, there would be fingerprints
there are fingerprints
∴ the defendant committed the crime

problem: affirming the consequent
reality: fingerprints could be from innocent earlier presence

medical diagnosis

fallacious diagnostic reasoning:
if patient has disease X, they show symptoms Y
patient shows symptoms Y
∴ patient has disease X

problem: affirming the consequent
reality: many diseases can cause the same symptoms

scientific reasoning

fallacious hypothesis testing:
if theory T is true, we observe effect E
we observe effect E
∴ theory T is true

problem: affirming the consequent
reality: multiple theories might predict the same effect

political arguments

fallacious policy reasoning:
if policy P is good, experts will support it
experts support policy P
∴ policy P is good

problem: affirming the consequent
reality: experts might support bad policies for other reasons

avoiding formal fallacies

use valid inference rules

learn and apply only valid patterns:

valid patterns:

• modus ponens: $P \rightarrow Q, P \vdash Q$
• modus tollens: $P \rightarrow Q, \neg Q \vdash \neg P$
• hypothetical syllogism: $P \rightarrow Q, Q \rightarrow R \vdash P \rightarrow R$
• disjunctive syllogism: $P \lor Q, \neg P \vdash Q$

check logical structure

before accepting conclusions:

1. identify the logical form
2. verify it matches a valid inference rule
3. if unsure, construct truth table or find counterexample

use proof methods

for complex arguments:

1. convert to formal logical notation
2. apply systematic proof methods
3. use automated theorem provers when available

distinguish form from content

remember:

• validity depends only on logical structure
• soundness requires both validity and true premises
• formal fallacies make arguments invalid regardless of content truth

relationship to informal fallacies

key differences

interaction

arguments can contain both:

combined fallacy:
if john is a good person, he tells the truth    (premise)
john tells the truth                            (premise)
therefore john is a good person                 (formal fallacy: affirming consequent)

also, john is ugly and smells bad              (informal fallacy: ad hominem)
so don't trust his claims about anything

detection strategies

1. first check formal structure

   • is the logical form valid?
   • use mechanical checking methods

2. then check content and context

   • are premises relevant and adequate?
   • apply informal fallacy analysis

computational complexity

decidability

• propositional logic: validity checking is decidable but np-complete
• first-order logic: validity checking is undecidable in general
• restricted fragments: many useful fragments are decidable

practical approaches

# efficient validity checking strategies
def check_validity_efficiently(premises, conclusion):
    # try fast heuristics first
    if quick_pattern_match(premises, conclusion):
        return "likely valid"

    # use sat solvers for propositional logic
    if is_propositional(premises, conclusion):
        return sat_solver_validity_check(premises, conclusion)

    # use theorem prover with timeouts for first-order
    return bounded_theorem_proving(premises, conclusion, timeout=30)

scalability

for large knowledge bases:

• indexing: organize rules by logical patterns
• caching: store validity results
• approximation: use sound but incomplete fast checks
• parallelization: check multiple inferences simultaneously

teaching formal fallacies

progression

1. basic patterns: start with affirming/denying patterns
2. truth tables: mechanical validity checking
3. natural deduction: formal proof methods
4. practical examples: apply to real arguments
5. automated tools: use theorem provers and logic checkers

common student errors

• confusing validity with truth
• thinking invalid arguments are always “wrong”
• not recognizing pattern instances
• conflating formal and informal fallacies

exercises

exercise 1: identify the formal fallacy
"if sarah is a lawyer, she's intelligent. sarah is intelligent. therefore sarah is a lawyer."

exercise 2: create counterexample
show why the above argument is invalid by finding a case where premises are true but conclusion false.

exercise 3: construct valid alternative
rewrite the argument to make it formally valid.

further reading

foundational texts

• irving copi: “symbolic logic” (formal logical systems)
• patrick suppes: “introduction to logic” (formal methods)
• elliott mendelson: “mathematical logic” (advanced formal systems)

computational approaches

• mordechai ben-ari: “mathematical logic for computer science”
• steven roman: “introduction to the mathematics of computer graphics”
• michael huth: “logic in computer science”

automated reasoning

• alan robinson: “logic: form and function” (automated theorem proving)
• wolfgang bibel: “automated theorem proving” (comprehensive treatment)
• handbook of automated reasoning (multiple volumes)