💻 computer science

Defeasible Conditional Obligation in a Two-tiered Preference-based Semantics (Extended Version)

This paper proposes a two-tiered, preference-based semantic framework that extends Hansson-Lewis style dyadic deontic logic with nonmonotonic reasoning to model defeasible conditional obligations, utilizing distinct ideal and normal world orderings to address prior shortcomings and establish a connection with constrained input/output logic.

Original authors: Xavier Parent

Published 2026-05-01

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Xavier Parent

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

The Big Picture: Fixing a Broken Rulebook

Imagine you are the judge of a very strict club. You have a rulebook that tells members what they ought to do.

Rule 1: "You ought not to eat with your fingers."
Rule 2: "If you are served asparagus, you ought to eat with your fingers."

In the real world, this makes perfect sense. If you get asparagus, the specific rule (eat with fingers) overrides the general rule (don't use fingers). But for decades, computer scientists and logicians struggled to build a mathematical system that could handle this without breaking.

The author, Xavier Parent, argues that old systems were too rigid. They couldn't handle "exceptions" properly. If you told the computer "Don't use fingers," and then "If asparagus, use fingers," the old computers would get confused and conclude something silly like, "Therefore, you ought not to be served asparagus." This is called the "Fallacy of the Prohibited Exception." It's like saying, "You shouldn't drive fast," and then "If you are in a race, you should drive fast," and the computer concludes, "Therefore, you shouldn't enter a race."

This paper proposes a new, two-layered way to think about rules to fix this.

The Solution: A Two-Layered Filter System

The author suggests we stop looking at the world through just one lens. Instead, we need two different filters to judge what is happening. Think of it like a security checkpoint at an airport that uses two different scanners.

Layer 1: The "Normality" Scanner (What usually happens)

This layer asks: "Is this a typical situation?"

The Analogy: Imagine a library. The rule is "Be quiet."
The Exception: If a baby starts crying, that's an exception to the rule.
How it works: The system ranks worlds (scenarios) based on how "normal" they are. A world where the baby is crying is "less normal" than a world where the baby is sleeping.
The Trick: The system uses a special "Lexicographic" (dictionary-style) ranking. It cares more about specific rules than general ones. If a specific rule says "Babies cry," the system prioritizes that over the general rule "Be quiet." This prevents the system from getting confused when an exception occurs.

Layer 2: The "Ideality" Scanner (What is best)

This layer asks: "Given the situation, what is the best thing to do?"

The Analogy: Imagine a chef.
- General Rule: "Don't burn the food."
- Specific Rule: "If you are cooking steak, you must burn the outside slightly to get a crust."
The Problem with Old Systems: Old systems would say, "You burned the food, so you broke the 'Don't burn' rule." They treated the specific rule as a violation of the general one.
The New Fix: This layer looks at the "most normal" scenarios first. If the scenario is "cooking steak," the system ignores the "Don't burn" rule because the "Steak" rule overrides it. It only checks if you followed the relevant rule for that specific context.

How the Two Layers Work Together

The paper combines these two scanners to solve the "Asparagus Problem" (the example from the beginning):

The Setup:
- General Rule: Don't eat with fingers.
- Specific Rule: If asparagus, eat with fingers.
- Another Rule: Put your napkin on your lap.
The Old System's Mistake:
It would try to apply the "Don't eat with fingers" rule to the asparagus scenario. Since you are eating with fingers, it thinks you broke the rule. Worse, it might conclude that you shouldn't have been served asparagus at all (the "Prohibited Exception" fallacy).
The New System's Logic:
- Step 1 (Normality): The system sees that "being served asparagus" is a specific, slightly unusual situation. It creates a special category for it.
- Step 2 (Ideality): Inside that "asparagus" category, the system checks the rules. It sees the specific rule ("Eat with fingers") overrides the general one.
- Result:
  - Did you break the "Napkin" rule? No, because that rule applies to everyone, even with asparagus.
  - Did you break the "Fingers" rule? No, because the specific rule allowed it.
  - Did you break the "No Asparagus" rule? No, because the system never concluded you shouldn't have asparagus. It simply accepted the asparagus scenario and applied the correct rule for it.

Why This Matters (The "Drowning" Effect)

The paper mentions a problem called the "Drowning Effect."
Imagine a swimmer who is drowning. If you have a rule "Don't swim in the ocean" and a rule "If you are drowning, swim to shore," an old system might get so confused by the conflict that it ignores both rules. The swimmer gets "drowned" by the logic itself.

The author's new system prevents this. By separating "what is normal" from "what is ideal," the system ensures that:

Specific rules (like "eat with fingers for asparagus") don't accidentally kill the general rules (like "use a napkin").
The system doesn't conclude that the exception (asparagus) should never happen.

The Connection to "Input/Output" Logic

Finally, the paper shows that this new, fancy two-layer system is mathematically equivalent to a well-known, simpler system called Input/Output (I/O) Logic.

The Analogy: Think of the new system as a high-end, custom-built car engine. The author proves that if you take the engine apart and rebuild it using standard, off-the-shelf parts (the I/O logic), it drives exactly the same way.
Why this is good: It means we can use the powerful, flexible new system but still rely on the trusted, proven tools that engineers already use to build rule-based systems.

Summary

This paper builds a smarter way for computers to understand rules. It stops computers from getting confused when exceptions happen. By using two different ways to rank situations (how normal they are vs. how good they are), it ensures that specific rules override general ones correctly, without accidentally banning the exceptions themselves.

1. Problem Statement

The paper addresses a fundamental tension in deontic logic between preference-based systems (which model obligations via world orderings) and norm-based systems (which model obligations via explicit rules and non-monotonic reasoning).

The Core Issue: Preference-based systems (e.g., Hansson, Lewis) are excellent at handling Contrary-to-Duty (CTD) reasoning but suffer from monotonicity. Once an obligation is derived, it cannot be withdrawn by new information. This leads to the Strengthening Problem: if "You ought not to eat with fingers" ( $\bigcirc \neg f$ ) and "If served asparagus, you ought to eat with fingers" ( $\bigcirc (f|a)$ ) are both present, standard preference semantics forces the conclusion that "You ought not to be served asparagus" ( $\bigcirc \neg a$ ).
The Fallacy of the Prohibited Exception: This outcome treats the exception (asparagus) as a global prohibition, which is counter-intuitive. The exception should only override the general rule in specific contexts, not negate the existence of the exception itself.
The Drowning Effect: In many non-monotonic approaches, if a general obligation is overridden, it "drowns" (disappears entirely), making it impossible to check if the general rule was violated in the specific context.
Horty's Critique: John Horty argued that preference-based systems cannot adequately model defeasible normative reasoning because they cannot distinguish between "ideal" worlds (where obligations are met) and "normal" worlds (where exceptions occur) without collapsing the logic.

2. Methodology: A Two-Tiered Framework

Parent proposes a bi-preferential, two-tiered semantic framework that integrates a non-monotonic reasoning mechanism into a preference-based dyadic deontic logic.

A. Two Distinct Orderings

The framework employs two separate orderings on possible worlds ( $W$ ):

Normality Ordering ( $\leq_N$ ): Ranks worlds based on how well they conform to normality conditionals (e.g., "Normally, if A then B").
- Method: Uses LEX (Lexicographic ordering), based on Lehmann's work.
- Mechanism: Worlds are ranked by the number of violated conditionals, prioritizing specificity. A world violating a specific rule is ranked lower than one violating a general rule. This prevents the "f-DIS" (flat distance-based) error where specific and general violations are treated equally.
Ideality Ordering ( $\leq_I$ ): Ranks worlds based on how well they conform to conditional obligations (e.g., "If A, then you ought to B").
- Method: Uses DEL (Delgrande's method).
- Mechanism: A world is "better" if it violates fewer obligations. Crucially, an obligation is not considered violated if a more specific overriding obligation is triggered and complied with. This solves the "drowning" problem.

B. The Truth Conditions

The logic introduces a normality conditional ( $\triangleright$ ) and a conditional obligation ( $\bigcirc$ ).

Normality ( $A \triangleright B$ ): True if all most normal $A$ -worlds are $B$ -worlds.
Conditional Obligation ( $\bigcirc(B|A)$ ): True if the set of most normal $A \land B$ $A \land B$ -worlds is strictly better (under $\leq_I$ $\leq_{I}$ ) than the set of most normal $A \land \neg B$ $A \land \neg B$ -worlds.
- Key Innovation: By restricting the evaluation of obligations to the most normal worlds, the framework filters out "abnormal" scenarios (like being served asparagus) when assessing the general obligation. This prevents the general obligation from being "drowned" by the exception.

C. Non-Monotonic Layer

The entailment relation ( $\vdash$ ) is defined over a theory $\Delta = (\Gamma, R)$ , where $R$ contains normality conditionals and obligations.

Defeasibility: New information (e.g., "You are served asparagus") changes the set of "most normal" worlds, thereby altering which obligations hold.
Postulates: The system satisfies key non-monotonic postulates:
- Inclusion: Explicit conditionals are entailed (unless inconsistent).
- Defeasible Strengthening of Antecedent (SA): Allows inferring $\bigcirc(B|A \land C)$ from $\bigcirc(B|A)$ unless $C$ triggers a specific defeater.
- No-Drowning: Ensures that overridden obligations do not disappear; they remain valid for checking compliance in the specific context.

3. Key Contributions

Resolution of the Prohibited Exception Fallacy: By separating normality and ideality, the framework allows a world where "asparagus is served and fingers are used" to be less ideal (violating the general rule) but still normal (satisfying the specific rule). It avoids concluding that "asparagus should not be served."
Elimination of the Drowning Effect: The framework ensures that when a specific obligation overrides a general one, the general obligation is not erased. It remains applicable for normative compliance checks (e.g., determining if a violation occurred).
Faithful Embedding into Constrained I/O Logic: The author proves that the deontic fragment of this preference-based system can be faithfully embedded into Constrained Input/Output (I/O) Logic (a norm-based system).
- This bridges the gap between the model-theoretic (preference) and operational (norm-based) approaches.
- The embedding maps conditional obligations to I/O pairs where the body includes the negation of all defeaters (more specific obligations).
Complexity Analysis: The embedding implies that entailment in this system has a $\Pi^P_2$ complexity bound, comparable to skeptical reasoning in default logic, which is higher than the co-NP complexity of monotonic bases.

4. Results

Theoretical Validation: The paper provides formal proofs (in the appendices) for the smoothness of the normality ordering, the validity of the non-monotonic postulates (Inclusion, No-Drowning), and the faithfulness of the embedding into Constrained I/O Logic.
Case Study (The Asparagus Example): The framework successfully derives:
- $\bigcirc(\neg f | \text{asparagus})$ is false (the exception overrides).
- $\bigcirc(n | \text{asparagus})$ is true (the general rule to use a napkin holds).
- $\bigcirc(\neg a)$ is false (it is not obligatory to avoid being served asparagus).
- $\bigcirc(\neg f)$ is true (the general rule holds in normal contexts).

5. Significance

Unification: This work represents a significant step toward unifying the two dominant paradigms in deontic logic: preference-based semantics (good for CTD) and norm-based semantics (good for defeasibility).
Practical Application: By solving the "drowning" and "prohibited exception" issues, the framework is better suited for real-world normative reasoning tasks, such as legal reasoning and compliance checking, where distinguishing between a violation and an exception is critical.
Foundational Impact: It establishes a new standard for modeling defeasible conditional obligations, offering a model-theoretic perspective on constrained I/O logic that was previously lacking.

In summary, Parent's paper successfully constructs a robust semantic framework that retains the intuitive strengths of preference-based logic while incorporating the necessary non-monotonic machinery to handle exceptions and conflicting norms without logical collapse.