🤖 AI

Plausible Reasoning and First-Order Plausible Logic

This paper introduces Plausible Logic (PL), a first-order non-probabilistic logic designed for defeasible reasoning that adheres to 17 proposed principles and employs eight distinct reasoning algorithms to derive sensible conclusions from facts and defeasible statements.

Original authors: David Billington

Published 2026-04-22

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: David Billington

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 trying to navigate a city where the map is incomplete, the traffic signs are sometimes wrong, and the weather is unpredictable. You can't rely on perfect, mathematical certainty (like "the sun will rise at 6:03 AM"). Instead, you have to make plausible guesses based on what is usually true, what is likely, and what the evidence suggests.

This paper by David Billington is about building a formal "rulebook" for making those kinds of guesses without using numbers (like percentages or probabilities). It's about creating a logic for "common sense" reasoning.

Here is the breakdown of the paper using simple analogies:

1. The Problem: The "Usually" Trap

In standard math or computer logic, things are black and white. If A is true, then B is true. But in real life, we say things like:

"Birds usually fly."
"Tweety is a bird."
"Therefore, Tweety probably flies."

But what if Tweety is a penguin? The logic breaks if we treat "usually" the same as "always." The author argues that we need a special kind of logic that handles these "usually" statements without turning them into hard facts or assigning them a 90% probability score.

2. The 17 Rules of the Game

The author proposes 17 "principles" (rules) that any good "plausible reasoning" system must follow. Think of these as the laws of physics for common sense.

Fact vs. Guess: You must be able to tell the difference between a hard fact ("Water is wet") and a guess ("It will probably rain").
No Magic Information: You can't conjure up new facts out of thin air. Your conclusion can't contain more information than your starting clues.
Changing Your Mind (Non-Monotonicity): This is crucial. In normal math, if you prove A, adding more facts never makes A false. In plausible reasoning, adding new info can make you change your mind.
- Analogy: You think "Nancy is a cephalopod, so she probably has no shell." (True for octopuses). But then you learn "Nancy is a nautilus." Now you must change your mind: "Nancy does have a shell." A good logic system must allow you to retract conclusions when new evidence arrives.
The "Ambiguity" Puzzle: Sometimes the evidence is perfectly balanced.
- Analogy: You have two witnesses. One says "The light was green," the other says "The light was red." Both are equally credible. Do you conclude the light was green? No. You conclude the situation is ambiguous. The paper argues a good logic system needs two modes: one that says "Stop, it's ambiguous" (cautious) and one that says "Go with the best bet" (risky).

3. The Solution: Plausible Logic (PL)

The author builds a specific system called Plausible Logic (PL). Think of this as a sophisticated courtroom or a detective agency.

The Three Types of Rules

PL uses three types of "laws" to process information:

Strict Rules (The Iron Laws): "If it's a triangle, it has 3 sides." These never break.
Defeasible Rules (The General Rules): "If it's a bird, it flies." These work unless there is evidence to the contrary (like a penguin).
Warning Rules (The "Be Careful" Signs): "If it's a scared quail, it might fly." This doesn't prove it will fly, but it warns you not to conclude that it definitely won't fly. It stops you from being too confident in a negative.

The 8 "Detectives" (Algorithms)

This is the most unique part of the paper. The author realized that depending on the situation, you might want different levels of caution. So, PL doesn't just have one "brain"; it has 8 different reasoning algorithms (detectives), arranged in a hierarchy of strictness:

The Fact-Checker (φ): Only deals with hard facts. 100% reliable, but very limited.
The Best-Bet Detective (π): Tries to prove things if the evidence is strong. It blocks ambiguity. If the evidence is slightly against you, it might still say "Yes, go for it."
The Cautious Detective (ψ): A bit more careful. It won't jump to conclusions if there's a tiny bit of doubt.
The "Thwarting" Detective (θ): Even more careful. It stops conclusions if there's any chance of being wrong.
The "Blocking" Detective (β): The most cautious. It propagates ambiguity. If there is any doubt, it refuses to give an answer.
(And three variations of these for specific technical needs).

The Analogy: Imagine a jury.

Algorithm φ is the judge (only follows the law).
Algorithm π is a jury in a civil case ("Preponderance of evidence" – if it's 51% likely, we say yes).
Algorithm β is a jury in a criminal case ("Beyond reasonable doubt" – if there is any doubt, we say not guilty).

The paper argues that a single logic system should be able to switch between these "jurors" depending on the stakes.

4. How It Works: The "Tree" of Thought

To prove a conclusion, the system builds a Rooted Acyclic Digraph (RAD).

Analogy: Imagine a family tree, but upside down. The root is your conclusion. The branches are the evidence.
If a branch leads to a contradiction or a dead end, the system cuts it off.
If the branches keep growing forever (a loop), the system has a built-in "stop sign" to prevent it from thinking forever.
The system checks every branch: Is the evidence for this stronger than the evidence against it? If yes, the branch survives. If no, it's pruned.

5. The Truth Values

In normal logic, a statement is True or False. In Plausible Logic, the author introduces 4 truth values:

True (t): It's usually true.
False (f): It's usually false.
Ambiguous (a): The evidence for and against is equal. (We don't know).
Undetermined (u): We don't have enough evidence either way.

This solves the "Included Middle" problem. In real life, things aren't just black or white; they can be "maybe" or "we don't know."

Summary

David Billington has created a formal rulebook for common sense.

The Goal: To make computers (or humans) reason about the world the way we actually do—using "usually," "likely," and "probably"—without needing to calculate complex probabilities.
The Innovation: It handles contradictions by allowing you to change your mind, it handles "maybe" situations by having different levels of caution (from "best bet" to "beyond reasonable doubt"), and it uses a tree-like structure to map out every possible argument.
The Result: A logic system that is flexible enough to handle the messy, uncertain nature of real life, while still being mathematically rigorous enough to be trusted.

In short, it's a logic system that understands that being right is good, but being sure when you shouldn't be is dangerous.

Based on the paper "Plausible Reasoning and First-Order Plausible Logic" by David Billington, here is a detailed technical summary covering the problem, methodology, key contributions, results, and significance.

1. Problem Statement

The paper addresses the limitations of classical logic in handling plausible reasoning—situations involving statements that are "likely," "usually true," or "probable" but not certain. Classical logic is monotonic (adding information never invalidates previous conclusions) and binary (true/false), making it unsuitable for:

Defeasible reasoning: Where new evidence can overturn previous conclusions (e.g., "Birds fly" vs. "Penguins don't fly").
Non-quantified uncertainty: Situations where precision is lacking, but no numerical probabilities are available (e.g., "Most mammals have fur").
Ambiguity: Scenarios where evidence for and against a conclusion is balanced, requiring different reasoning strategies (e.g., "ambiguity blocking" vs. "ambiguity propagating").

Existing logics often fail to satisfy a comprehensive set of intuitive principles required for plausible reasoning, such as non-monotonicity, specific handling of conjunctions/disjunctions, and the ability to distinguish between factual and plausible truths.

2. Methodology

The author employs a rigorous, principle-driven methodology to define a new logic:

Principle Formulation: The author identifies 17 principles that a logic for plausible reasoning must satisfy.
- 14 Necessary Principles: If a logic fails these, it cannot perform plausible reasoning (e.g., Representation, Non-Monotonicity, Non-Conjunctive, Strong 2-Consistency).
- 3 Desirable Principles: If a logic fails these, it is limited but may still function (e.g., Decisiveness, No Loops).
Formal Definitions:
- Plausible-Representations: Situations are modeled as $R = (Fact(R), Plaus(R))$, distinguishing factual sentences from plausible ones.
- Plausible-Descriptions ( $D$ ): A formal structure $(Ax, R, >)$ consisting of axioms ($Ax$), a set of rules ( $R$ ), and a priority relation ( $>$ ).
- Rule Types:
  - Strict Rules ( $\to$ ): Material implication (facts).
  - Defeasible Rules ( $\Rightarrow$ ): "Usually" statements (e.g., $A \Rightarrow C$ ).
  - Warning Rules ( $;$ ): Prevent risky conclusions without supporting the negation.
Proof Theory Construction:
- The logic utilizes 8 distinct proof algorithms ( $\phi, \pi, \psi, \theta, \theta', \beta, \psi', \pi'$ ).
- Algorithms:
  - $\phi$ : Factual proof (classical).
  - $\pi, \psi, \theta, \theta', \beta$ : Plausible algorithms with varying strengths regarding ambiguity handling (blocking vs. propagating).
  - $\pi', \psi'$ : Co-algorithms used to evaluate evidence against a conclusion.
- Mechanism: Proofs are defined via a recursive function $P(\alpha, H, f)$ $P (α, H, f)$ returning $+1$ $+ 1$ (proved) or $-1$ (disproved).
  - Evidence: A formula is proved if there is evidence for it (a rule instance) and all evidence against it is defeated (either by a superior rule or by showing the opposing rule's antecedents are unprovable).
  - History ( $H$ ): To prevent infinite loops, the proof process tracks the history of used algorithms and rule instances.
- Structure: Proofs are modeled as Rooted Acyclic Digraphs (Rads), allowing for complex dependency structures and infinite paths (though finite decisiveness is desirable).

3. Key Contributions

Plausible Logic (PL): The definition of a First-Order Plausible Logic that satisfies all 14 necessary principles and 13 of the 14 desirable principles (failing only two specific desirable ones regarding loop prevention in infinite cases, though it handles them via history). The author claims this is the only known logic to satisfy this specific set of criteria.
The 17 Principles: A comprehensive framework characterizing plausible reasoning, including:
- Non-Conjunctive Principle: The conjunction of two plausible statements is not necessarily plausible.
- Not Right Disjunctive Principle: If a disjunction is plausible, it does not imply one disjunct is plausible.
- Included Middle Principle: A truth theory for plausible reasoning requires at least 3 truth values (True, False, and "Undetermined/Ambiguous").
Linear Hierarchy of Algorithms: The introduction of 8 algorithms forming a linear hierarchy of reliability.
- $\phi$ (Factual) > $\pi$ (Strongest Plausible) > $\psi$ > $\theta$ > $\beta$ (Weakest Plausible).
- This hierarchy allows users to select the appropriate level of caution (e.g., "beyond reasonable doubt" vs. "balance of probabilities").
Truth Theory: A 4-valued truth system $\{t, f, a, u\}$ (usually true, usually false, ambiguous, undetermined) derived directly from the proof algorithms.
Rad-Based Proofs: A novel structural induction method on Rooted Acyclic Digraphs to define and analyze proofs, accommodating non-layered structures and infinite paths.

4. Results

Satisfaction of Principles: The paper demonstrates through construction and theorems that PL satisfies the Representation, Information, Factual Subclassicality, Evidence, Non-Monotonicity, Non-Conjunctive, Plausibly Conjunctive, Not Right Disjunctive, Not Left Factual Disjunction, Plausible Right Weakening, Strong 2-Consistency, Non-3-Consistency, Many Proof Algorithms, and Included Middle principles.
Coherence and Consistency: Theorem 5.6 proves the algorithms are coherent (a formula cannot be both proved and disproved by the same algorithm). Theorem 5.7 proves Strong 2-Consistency (any two proved formulas are jointly satisfiable with the facts).
Handling Ambiguity: The logic successfully models the "Ambiguity Puzzle" (Example 3.27), distinguishing between algorithms that block ambiguity (concluding a result if evidence slightly outweighs the counter-evidence) and those that propagate it (refusing to conclude if evidence is balanced).
Correctness: The logic yields "correct" answers for standard signpost examples (e.g., the 3-lottery, the Nautilus/Cephalopod example) where other logics fail.

5. Significance

Theoretical Advancement: PL provides a rare, fully formalized first-order logic specifically designed for non-monotonic, plausible reasoning without relying on numerical probabilities. It bridges the gap between classical logic and defeasible reasoning.
Practical Applicability: The hierarchy of algorithms allows for flexible application in domains requiring different standards of proof (e.g., legal reasoning, medical diagnosis, AI decision-making).
Foundational Clarity: By explicitly listing 17 principles, the paper offers a benchmark for evaluating existing and future reasoning systems.
Handling of Loops and Infinity: The use of "history" in the proof function and the Rad-based structure provides a robust mechanism for handling potentially infinite reasoning chains without crashing, a common issue in non-monotonic logics.

In summary, this paper presents Plausible Logic (PL) as a comprehensive, mathematically rigorous solution to the problem of reasoning with uncertain, defeasible information, distinguished by its adherence to a strict set of 17 logical principles and its unique multi-algorithm hierarchy.