Defeasible Reasoning

A conclusion is drawn based on the currently available information and is considered tentatively valid. It stands unless defeated by contrary evidence. This contrasts with deductive logic, where a conclusion is irrevocable once proven.

• Default Rule: 'If it's a bird, it flies' yields the conclusion that a given bird flies.
• Defeater: The information that the bird is a penguin defeats the initial conclusion.
• Legal Application: A contract clause creates a prima facie obligation that can be defeated by a force majeure event.

The core mechanism for retracting a conclusion. A defeater is a piece of evidence or a rule that invalidates the support for a prima facie conclusion. There are two primary types:

• Rebutting Defeater: Directly contradicts the conclusion (e.g., 'This bird does not fly').
• Undercutting Defeater: Attacks the inferential link between the premise and the conclusion without contradicting the conclusion itself (e.g., 'The witness claiming the bird flies is unreliable').

When two rules conflict, a superiority relation determines which one prevails. This is not a simple true/false binary but a structured ordering.

• Lex Specialis: A more specific rule defeats a more general one.
• Lex Superior: A rule from a higher authority defeats one from a lower authority.
• Lex Posterior: A later-enacted rule defeats an earlier one.
• Explicit Ordering: A knowledge engineer can manually define that rule_1 > rule_2.

Defeasible logic uses a proof theory based on conclusion tagging to indicate the epistemic status of a statement. A conclusion is not just 'true' or 'false'.

• +Δ (Definitely Provable): Proven using only strict, non-defeasible rules and facts.
• -Δ (Definitely Not Provable): Cannot be proven using strict rules.
• +∂ (Defeasibly Provable): Proven after considering all applicable rules and defeaters; the conclusion survives the conflict.
• -∂ (Defeasibly Not Provable): The conclusion is not warranted after the defeasible analysis.

A key design choice in defeasible logics is how to handle a conflict between two rules that both support a conclusion, when one rule is defeated by an external source.

• Ambiguity Propagation: If the support for a conclusion is 'tainted' by a defeated rule, the conclusion itself is considered ambiguous and not warranted.
• Ambiguity Blocking: The conclusion is still warranted if there is at least one undefeated rule supporting it, even if another supporting rule is defeated. Most legal implementations use ambiguity blocking to prevent a single technicality from collapsing an otherwise sound argument.

A practical, open-source implementation of defeasible logic. SPINdle (Scalable and Practical Inference eNgine for Defeasible Logic) converts a theory of facts, strict rules, defeasible rules, and defeaters into a set of conclusions with their proof tags.

• Input: A structured text file defining rules and superiority relations.
• Process: Applies the proof theory to compute all warranted conclusions.
• Output: A list of all tagged literals (+∂, -∂, etc.).
• Use Case: Used in academic and commercial legal reasoning systems to compute regulatory compliance outcomes.

The formal logical foundation for defeasible reasoning. Unlike classical logic, where adding premises never invalidates existing conclusions, non-monotonic logic allows a conclusion to be retracted when new information is introduced. This is critical for legal AI, where a general rule (e.g., 'contracts are valid if signed') is defeated by a specific exception (e.g., 'unless signed under duress'). Key formalisms include default logic, circumscription, and autoepistemic logic.

The legal principle that a specific rule overrides a general rule. This is the primary trigger for defeasible reasoning in normative systems. In computational terms, it is implemented as a specificity-based preference ordering: when Rule A (general) and Rule B (specific) both apply to a case, the system defeases Rule A in favor of Rule B. This requires an algorithmic mechanism to compare the scope and applicability conditions of competing rules.

An extension of default logic that formalizes prima facie obligations—duties that hold by default but can be defeated. A typical default rule takes the form: 'If α is true, and it is consistent to believe β, then conclude β.' In legal AI, this models reasoning like: 'If a contract exists, payment is due (by default), unless a force majeure clause is triggered (the exception).' This directly encodes defeasible normative reasoning into a computable structure.

The algorithmic prerequisite to defeasible reasoning. Before a conclusion can be retracted, the system must detect that two applicable rules yield contradictory deontic conclusions. This involves classifying the collision type:

• Obligation-Obligation Conflict: Two mandatory but mutually exclusive actions are required.
• Obligation-Prohibition Conflict: One rule mandates an action another forbids.
• Permissive-Prohibitive Conflict: A permission is contradicted by a prohibition. Detection triggers the defeasance mechanism.

A directed acyclic graph encoding the precedence relationships that govern defeasibility. Nodes represent legal rules; edges represent defeat relations (e.g., 'Rule X defeats Rule Y'). The graph is structured by three axes:

• Lex Superior: Higher authority defeats lower.
• Lex Specialis: Specific defeats general.
• Lex Posterior: Later enactment defeats earlier. When a conflict is detected, the system traverses this graph to determine which rule survives and which is defeased, ensuring deterministic resolution.

A deontic logic construct specifying what an agent must do after violating a primary obligation. This is a classic test case for defeasible reasoning systems. Example: 'You ought not to breach a contract. But if you do breach, you ought to pay damages.' The secondary obligation (pay damages) only activates when the primary obligation (do not breach) is violated and defeased. Modeling these chains is essential for realistic legal compliance reasoning.