💻 computer science

The Dynamic Turn in Paraconsistency

This paper introduces a dynamic framework for paraconsistency by defining action and public announcement logics (AMLFI1 and PALFI1) that extend existing epistemic paraconsistent systems, enabling the formalization of obtaining and resolving provisional contradictions while proving their soundness and completeness.

Original authors: Rafael Ongaratto, Hans van Ditmarsch

Published 2026-07-23

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Rafael Ongaratto, Hans van Ditmarsch

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 a detective trying to solve a mystery, but your notebook is a bit glitchy. Sometimes, two different witnesses tell you opposite things about the same clue. In the old days of logic, if you heard "The suspect is at the park" and "The suspect is NOT at the park," your entire notebook would explode. The system would crash, and you'd be forced to conclude that everything is true and nothing is true, making your investigation useless. This is called the "explosion principle." But real life isn't like that. We deal with contradictions all the time without losing our minds. We just say, "Okay, there's a conflict here, let's figure out who is lying or who made a mistake."

This is where paraconsistency comes in. It's a branch of logic designed to handle these messy, contradictory situations without crashing the system. It allows you to hold two opposing ideas in your head at once, treating them as a temporary glitch rather than a total disaster. Then, there's dynamic logic, which is like adding a "rewind" and "fast-forward" button to your detective story. It doesn't just look at a static picture of the world; it tracks how your beliefs change when you get new information, like when a witness changes their story or you find a new piece of evidence.

The big question this paper tackles is: What happens when you combine these two? How do we build a logical system that can not only handle contradictions but also show us how those contradictions appear, evolve, and eventually get fixed as we learn more? The authors, Rafael Ongaratto and Hans van Ditmarsch, argue that we need a "dynamic turn" in paraconsistency. They want to move away from just staring at a frozen, contradictory picture and instead create a movie where we can see the contradiction being born and then resolved.

The Paper's Big Idea: The "Glitch-Proof" Detective Story

In this paper, the authors introduce a new set of logical tools called AMLFI1 and UMLFI1. Think of these as a super-powered, glitch-proof operating system for a team of detectives (or agents) who are trying to solve a case together.

The Setup: The Glitchy Database

Imagine a shared digital database where different agents (let's call them Anne, Bill, and Cath) are swapping information. In the real world, databases sometimes get messy. Maybe Anne thinks a file is "Blue," but Bill thinks it's "Red." In a normal, strict logic system, this conflict would break the whole database. But in the world of LFI1 (the base logic the authors are building on), the database can handle this. It has a special "inconsistency switch" (a symbol like •) that says, "Hey, this data is contradictory, but don't panic. We can still work with it."

The authors take this static idea and add Action Models. Imagine these as little "event cards" that the agents play. When an agent plays a card, it updates the database.

AMLFI1 is the first version of this system. It lets agents play cards that change what they know. For example, if Cath says, "I have the Clubs card," the system updates Anne's knowledge. Even if Cath is lying and actually has the Spades card, the system doesn't crash. It just records that Anne now believes "Clubs" while the reality might be "Spades," creating a temporary, manageable contradiction.
UMLFI1 is the upgraded version. It adds Factual Change. This is the "magic wand" that doesn't just change what people think, but changes the facts themselves. If Cath was lying and then gets caught, she can show her card. The system doesn't just update Anne's belief; it actually rewrites the database entry to match the truth. The contradiction is resolved, and the system is back to normal.

The "Liar" Problem and the "Byzantine" Agent

The paper uses a game called Coup to explain why this is cool. In Coup, players hold cards and can lie about what they have to win. If you lie, you create a contradiction between what you say and what you hold.

Old Logic: If you try to model a liar, the system usually breaks because it can't handle the lie without assuming the liar is "crazy" (knowing everything and nothing at once).
This Paper's Logic: The authors show that you can model a liar perfectly. The system can say, "Cath claims to have the Clubs, but she actually has Spades." It keeps both pieces of information in a "contradictory state" (marked as 1/2 or "maybe/both") without exploding.
The Twist: The paper distinguishes between a Liar (someone who knows the truth but says the opposite) and a Byzantine Agent (someone who is just broken, confused, or malfunctioning). In their system, a broken agent might genuinely believe they have both cards at once. The logic handles this "brokenness" gracefully, keeping the rest of the system running while the broken agent is fixed or ignored.

The "Resolution" Mechanism

The most exciting part of the paper is how they show contradictions getting fixed.

The Conflict: Anne hears Cath say "I have Clubs," but then Cath says "I have Spades." Anne is now confused. Her database has a contradiction.
The Fix: Cath is challenged to show her card. She reveals she has Spades.
The Update: In the UMLFI1 system, this isn't just Anne changing her mind. The system performs a "factual change." It updates the reality of the card. The contradiction vanishes because the "Spades" fact overwrites the "Clubs" lie. The system proves mathematically that this process is sound (it never leads to nonsense) and complete (it can prove everything that is true in this system).

What They Proved

The authors didn't just guess this would work; they built a rigorous mathematical proof.

They showed that their new logics (AMLFI1 and UMLFI1) are sound: If you follow the rules, you won't end up with a broken conclusion.
They showed they are complete: If something is true in the system, you can prove it using their rules.
They showed they are decidable: There is a step-by-step recipe (an algorithm) that can tell you, in a finite amount of time, whether a specific statement is true or false in this system.
They also showed that their version of "Public Announcement Logic" (a specific type of update where everyone hears the same thing) is mathematically equivalent to another recent version, just written with slightly different rules.

What They Don't Claim

It's important to note what this paper doesn't do. They don't claim to have solved the problem of lying in all human interactions, nor do they claim to have built a working AI that can lie and recover yet. They haven't tested this on a real-world database or a live game of Coup. They have built the blueprint and the mathematical engine that says, "Yes, this is a valid way to think about contradictions and updates." They leave the heavy lifting of applying this to complex, real-world distributed systems (like massive internet databases) as a job for future researchers.

The Takeaway

In simple terms, this paper gives us a new way to write the rules for a world where things go wrong. It shows that we don't have to choose between a world that is perfectly consistent (and therefore fragile) and a world that is chaotic. We can have a world that accepts contradictions as temporary glitches, tracks how they happen, and provides a logical path to fix them. It's like giving a detective a notebook that doesn't tear when you write two different things on the same page, but instead highlights the conflict and waits for the next clue to solve it.

Technical Summary: The Dynamic Turn in Paraconsistency

Problem Statement
The paper addresses a fundamental limitation in the current state of paraconsistent logic: its static nature. While paraconsistent logics (such as LFI1) successfully model inconsistent but non-trivial states, they typically offer only a "static image" of contradiction. In the epistemic approach to paraconsistency, contradictions are often viewed as "provisional"—arising from cognitive limitations, measurement errors, or stages in theory development—and are expected to be resolved over time. However, standard paraconsistent logics cannot represent the process of model change (updating information) within the logical language itself. Instead, such updates must be described in the metalanguage (e.g., "at time $t_1$ the model is $M_1$ , and after action $k$ , it becomes $M_2$ "). The authors argue that a "dynamic turn" is necessary to formalize the obtaining and resolving of provisional contradictions, similar to the "dynamic turn" achieved in classical epistemic logic through Dynamic Epistemic Logic (DEL).

Methodology
The authors extend the three-valued paraconsistent logic LFI1 (Logic of Formal Inconsistency) with dynamic modalities derived from the Dutch school of dynamic logics. The methodology involves:

Logic Foundation: Utilizing LFI1, which extends the Logic of Paradox (LP) with a consistency operator ( $\circ$ ) and an inconsistency operator ( $\bullet$ ). LFI1 is a three-valued logic (values: 1, 1/2, 0) where 1 and 1/2 are designated. Crucially, LFI1 possesses a "strong equivalence" ( $\equiv$ ) that functions as a congruence relation, a property lacking in other many-valued logics like LP or K3.
Dynamic Extension (AMLFI1): The authors introduce AMLFI1 (Action Model LFI1), a dynamic epistemic logic extending S5LFI1. It incorporates action models where actions have preconditions but no postconditions (factual changes). The semantics are defined via a restricted modal product of Kripke models and action models.
Factual Change Extension (UMLFI1): The authors further introduce UMLFI1 (Update Model LFI1), which extends AMLFI1 by allowing actions to have postconditions. This enables "ontic change" (changing the truth value of atomic facts), which is essential for modeling the resolution of contradictions.
Axiomatization and Reduction: The core technical approach involves defining reduction axioms. Unlike standard DELs where reduction axioms are often equivalences, the authors utilize strong equivalences (based on the congruence of $\equiv$ ) to reduce formulas containing dynamic modalities into formulas within the static epistemic language (LK). This reduction strategy is used to prove completeness.
Comparative Analysis: The paper compares the proposed PALFI1 (Public Announcement LFI1, a special case of AMLFI1) with a recently published alternative axiomatization, PALFI1C.

Key Contributions

Formalization of Dynamic Paraconsistency: The paper proposes AMLFI1 and UMLFI1, the first dynamic epistemic logics specifically designed for the three-valued paraconsistent logic LFI1.
Handling Provisional Contradictions: By integrating action models with preconditions and postconditions, the framework allows for the formal representation of agents receiving conflicting information (entering a state of inconsistency) and subsequently resolving it (returning to consistency) through factual changes.
Equivalence of Axiomatizations: The authors demonstrate that their public announcement logic (PALFI1), which uses a rule of replacement of equivalents (RE) and lacks a composition axiom, is logically equivalent to the recently published PALFI1C, which uses a composition axiom but lacks RE. They prove the admissibility of RE in PALFI1C and the composition axiom in PALFI1.
Technical Novelty in Reduction: The reduction axioms are formulated as strong equivalences rather than simple equivalences. This is a necessary adaptation for the three-valued setting of LFI1, where standard equivalence does not induce a congruence.

Results
The paper establishes the following meta-theoretic properties for the introduced logics (AMLFI1, PALFI1, and UMLFI1):

Soundness: The axioms and rules are sound with respect to the defined Kripke semantics.
Strong Completeness: The logics are strongly complete with respect to their semantics. This is proven via the reduction strategy, showing that any formula in the dynamic language is provably equivalent to a formula in the static language, which is already known to be complete.
Compactness: The logics satisfy the compactness property.
Decidability: The logics are decidable, following from the decidability of the underlying static logic (S5LFI1) and the terminating nature of the reduction procedure.
Subsystem Relations: The dynamic logics properly extend the static epistemic paraconsistent logics KLFI1, KB4LFI1, and S5LFI1.

Significance and Claims
The authors claim that their work provides a "dynamic turn" for paraconsistency, moving beyond static models of contradiction to a framework where contradictions are treated as transient states that can be updated and resolved.

Application to Lying and Byzantine Behavior: The paper applies these logics to the analysis of lying, mistakes, and "Byzantine" behavior (e.g., in the context of the Coup game). It argues that dynamic paraconsistency offers a more nuanced view than classical dynamic epistemic logic, where lying often leads to "explosion" or triviality. In the proposed framework, agents can hold contradictory information without becoming "crazy" (trivial), and factual changes (postconditions) allow for the recovery from such inconsistencies.
Distributed Systems: The authors suggest that these results are transferable to distributed database management, particularly for handling local inconsistencies where different agents may hold conflicting views that are later resolved.
Modesty: The paper modestly frames its contribution as a foundational step. It acknowledges that fully modeling the distinction between lying (intentional) and error (unintentional) or handling complex belief contraction (adding accessibility arrows) requires further research and more complex encodings, which are left for future work. The authors emphasize that the beauty of their approach lies in providing "economical" encodings for local inconsistencies compared to more complex belief revision frameworks.