defeasible arguments

original reasoning:
birds typically fly
tweety is a bird
∴ tweety probably flies

after learning new information:
birds typically fly
tweety is a bird
tweety is a penguin
∴ tweety probably does not fly (conclusion defeated)

it's 3:00 pm and mail usually arrives by 2:00 pm
∴ the mail has probably already arrived

this conclusion is reasonable given normal circumstances
but can be defeated by learning today is a postal holiday

generalization: students who attend class regularly tend to perform better
application: maria attends class regularly
presumption: maria will probably perform well

potential defeaters:
- maria has severe test anxiety
- maria doesn't understand the material despite attendance
- maria is dealing with personal crises affecting concentration

default argument:
academic conferences are usually valuable for research
this is an academic conference
∴ this conference is probably valuable

rebutting defeater:
this conference has been identified as predatory
∴ this conference is probably not valuable

the defeater directly opposes the original conclusion

default argument:
the witness identified the suspect
∴ the suspect is probably guilty

undercutting defeater:
the identification occurred under poor lighting conditions
∴ the identification is unreliable (breaks inference link)

the defeater doesn't claim innocence directly,
but undermines the reliability of the identification

default reasoning:
restaurants are typically open during dinner hours
it's 7:00 pm (dinner time)
∴ the restaurant is probably open

exceptional defeater:
today is christmas day
∴ normal operating hours may not apply

the exception doesn't contradict the general rule,
but identifies a context where it doesn't hold

general form: P(x) : M Q(x) / Q(x)

reads as: "if P(x) is known and Q(x) is consistent
          with current beliefs, then conclude Q(x)"

example:
Bird(x) : M Flies(x) / Flies(x)
"if x is a bird and it's consistent to believe x flies,
 then conclude x flies"

class Argument:
    def __init__(self, premises, conclusion):
        self.premises = premises
        self.conclusion = conclusion

class ArgumentationFramework:
    def __init__(self):
        self.arguments = []
        self.attack_relations = []  # (attacker, attacked)

    def add_attack(self, attacker, attacked):
        self.attack_relations.append((attacker, attacked))

    def compute_extensions(self):
        # find sets of arguments that can stand together
        # considering attack relations
        pass

P(conclusion | evidence) = high initially

new evidence arrives:
P(conclusion | evidence, defeater) = low

bayesian updating naturally handles defeasibility
through conditional probability revision

circumscription example:
minimize abnormal cases

Flies(x) ← Bird(x) ∧ ¬Abnormal(x)
Abnormal(x) ← Penguin(x)
Bird(tweety)
Penguin(tweety)

conclusion: ¬Flies(tweety)

legal presumption: defendants are innocent until proven guilty
evidence: defendant had motive and opportunity
presumption: defendant is probably innocent (default)

prosecution evidence:
- dna at crime scene
- witness testimony
- incriminating communications
result: presumption of innocence defeated

defense evidence:
- alibi witnesses
- evidence tampering claims
- alternative suspect theory
result: attempt to defeat prosecution case

default rule: chest pain in older adults suggests cardiac cause
patient: 65-year-old with chest pain
presumption: probably cardiac-related

additional information:
- pain occurs only when lying down
- relieved by antacids
- no cardiac risk factors
result: cardiac presumption defeated, gerd more likely

further information:
- abnormal ekg discovered
- elevated cardiac enzymes
result: gerd explanation defeated, back to cardiac cause

default: people keep their appointments
expectation: friend will meet me at arranged time
presumption: friend will probably show up

potential defeaters:
- friend calls to cancel → direct cancellation
- severe weather conditions → exceptional circumstances
- friend has history of unreliability → undermines trust
- emergency situation → exceptional circumstances

default assumption: network requests succeed
program logic: send request, process response
presumption: response will arrive successfully

exception handling:
try:
    response = send_request()
    process_response(response)
except NetworkError:
    # default assumption defeated
    handle_failure()
except TimeoutError:
    # another type of defeat
    retry_or_fail()

reasoning: most meetings scheduled for today will occur as planned
conclusion: 10 am meeting will probably happen
evaluation: reasonable given normal circumstances

new information: building evacuation due to fire alarm
revised evaluation: conclusion no longer reasonable

argument: this medication usually helps with anxiety
conclusion: patient will probably benefit from medication

defeat conditions:
- patient has allergy to medication (safety defeater)
- patient has condition contraindicated for drug (medical defeater)
- patient already taking incompatible medication (interaction defeater)
- patient prefers non-pharmaceutical treatment (preference defeater)

strong presumption:
gravity causes objects to fall downward
very few potential defeaters (magnetic forces, etc.)

weak presumption:
traffic will be light during rush hour
many potential defeaters (accidents, weather, events, etc.)

appropriate context:
default: restaurants serve food
application: planning dinner at restaurant
context match: fits normal dining expectations

inappropriate context:
default: restaurants serve food
application: expecting food at restaurant museum exhibit
context mismatch: museum context changes expectations

class DefeasibleRule:
    def __init__(self, condition, conclusion, exceptions):
        self.condition = condition
        self.conclusion = conclusion
        self.exceptions = exceptions

    def applies(self, facts, beliefs):
        # check if condition holds
        if not self.condition.satisfied(facts):
            return False

        # check for exceptions (defeaters)
        for exception in self.exceptions:
            if exception.satisfied(facts, beliefs):
                return False

        return True

# example usage
bird_flies_rule = DefeasibleRule(
    condition=lambda facts: 'bird' in facts,
    conclusion='flies',
    exceptions=[
        lambda facts, beliefs: 'penguin' in facts,
        lambda facts, beliefs: 'injured_wing' in facts,
        lambda facts, beliefs: 'in_cage' in facts
    ]
)

class PrioritizedArgument:
    def __init__(self, premises, conclusion, priority):
        self.premises = premises
        self.conclusion = conclusion
        self.priority = priority

def resolve_conflicts(arguments):
    # when arguments conflict, use priority to decide
    active_args = []
    for arg in arguments:
        defeated = False
        for other_arg in arguments:
            if (conflicts(arg, other_arg) and
                other_arg.priority > arg.priority):
                defeated = True
                break
        if not defeated:
            active_args.append(arg)
    return active_args

import numpy as np
from scipy.stats import beta

class ProbabilisticDefeasibleReasoning:
    def __init__(self):
        self.beliefs = {}  # conclusion -> probability

    def add_evidence(self, evidence, conclusion, strength):
        # update beliefs using bayesian updating
        prior = self.beliefs.get(conclusion, 0.5)

        # simple beta-binomial updating
        # (real implementations would be more sophisticated)
        likelihood = strength if evidence else 1 - strength
        posterior = (prior * likelihood) / (
            prior * likelihood + (1 - prior) * (1 - likelihood)
        )

        self.beliefs[conclusion] = posterior

    def is_defeated(self, conclusion, threshold=0.5):
        return self.beliefs.get(conclusion, 0.5) < threshold

class ArgumentationSystem:
    def __init__(self):
        self.arguments = {}
        self.attacks = []

    def add_argument(self, arg_id, premises, conclusion):
        self.arguments[arg_id] = {
            'premises': premises,
            'conclusion': conclusion,
            'status': 'undecided'
        }

    def add_attack(self, attacker_id, attacked_id):
        self.attacks.append((attacker_id, attacked_id))

    def compute_grounded_extension(self):
        # compute grounded extension (unique minimal fixed point)
        in_set = set()
        out_set = set()

        changed = True
        while changed:
            changed = False

            # add unattacked arguments
            for arg_id in self.arguments:
                if arg_id not in in_set and arg_id not in out_set:
                    attackers = [att for att, def_ in self.attacks if def_ == arg_id]
                    if all(att in out_set for att in attackers):
                        in_set.add(arg_id)
                        changed = True

            # remove arguments attacked by accepted arguments
            for arg_id in self.arguments:
                if arg_id not in out_set:
                    attackers = [att for att, def_ in self.attacks if def_ == arg_id]
                    if any(att in in_set for att in attackers):
                        out_set.add(arg_id)
                        changed = True

        return in_set

medical expert system:
rule: if patient has fever and cough, then probably viral infection
exception: if white blood cell count is very high, then probably bacterial

implementation handles conflicting evidence through
defeasible reasoning rather than absolute rules

sentence: "the bank is closed"

default interpretation: financial institution
context: "we're going fishing" → riverbank interpretation
contextual defeat: fishing context overrides financial default

default: doors are unlocked during business hours
plan: walk through door to reach destination
assumption: door will open when pushed

exception handling:
if door doesn't open:
- try pulling instead of pushing
- check if door is locked
- find alternative route
- ask for assistance

class DefeasibleClassifier:
    def __init__(self, base_model, confidence_threshold=0.7):
        self.model = base_model
        self.threshold = confidence_threshold
        self.exceptions = []

    def predict_defeasible(self, x):
        prediction = self.model.predict(x)
        confidence = self.model.predict_proba(x).max()

        # check for known exceptions
        for exception_pattern, override in self.exceptions:
            if exception_pattern.matches(x):
                return override, "exception"

        if confidence < self.threshold:
            return prediction, "uncertain"
        else:
            return prediction, "confident"

problematic reasoning:
birds fly
penguins are birds
∴ penguins fly (ignores exceptions)

better defeasible reasoning:
birds typically fly
penguins are birds
but penguins are a known exception
∴ penguins probably do not fly

initial reasoning: meeting is scheduled for 2 pm, so it will probably occur
new information: building fire alarm requires evacuation
error: continuing to believe meeting will occur as scheduled
correction: meeting presumption is defeated by emergency circumstances

reasonable conclusion: this medication helps with depression
irrelevant defeater: some people don't like taking pills
error: letting preference defeat medical effectiveness
correction: distinguish between efficacy and acceptability

problematic:
rule a: if p then q, unless r
rule b: if q then r, unless p
result: neither conclusion can be established

better: establish priority or context for rule application