Fine-Grained Inconsistency Resolution in Knowledge Bases

48 concepts37 papers1 proposal

When a logic-based knowledge base encounters new information that contradicts its existing beliefs, it faces a fundamental crisis. In classical logic, an inconsistent system suffers from the "principle of explosion"—it can logically derive absolutely anything, rendering it useless. To remain functional, the system must restore consistency.

As Hirofumi Katsuno et al. observe in A Unified View of Propositional Knowledge Base Updates, this requires a principled mechanism to determine exactly which beliefs to sacrifice. Historically, traditional belief revision frameworks handled this by treating logical statements as atomic units: if an axiom or fact contributed to a contradiction, the system simply deleted it.

However, this coarse-grained, syntax-based deletion acts as a blunt instrument. It triggers massive, unnecessary information loss, often discarding valid implicit knowledge, unrelated facts, or rich data attributes that had nothing to do with the core conflict.

To solve this, a major research direction focuses on fine-grained inconsistency resolution. The core intuition is that knowledge is not atomic; it has internal structure. By decomposing axioms, tracking logical dependencies, and shifting from binary deletion to surgical modification, we can resolve contradictions while preserving the maximum possible utility of the original data.


The Collateral Damage of Coarse Deletion

To understand why fine-grained resolution works, we must first look at how traditional "all-or-nothing" deletion breaks down across different knowledge structures.

1. Destruction of Implicit Knowledge

Knowledge bases contain both explicit statements (axioms) and implicit consequences that can be logically deduced from them. In Belief Contraction in the Description Logic EL, Maurice Pagnucco et al. point out that if a removal operation only targets explicit statements without considering the full deductive closure, it risks inadvertently destroying valuable implicit knowledge. Zhe Wang et al. echo this in Instance-driven TBox Revision in DL-Lite, noting that deleting entire axioms frequently discards valid underlying rules that do not directly contradict the new data.

2. The Drowning Effect

In prioritized knowledge bases, facts are ranked by certainty or importance. When a contradiction occurs at a high-certainty level, naive revision operators often suffer from what Guilin Qi terms the drowning effect in A Semantic Approach for Iterated Revision in Possibilistic Logic. Because the system detects an inconsistency at a high level, it aggressively discards all information at lower certainty levels, even if those lower-priority formulas are completely unrelated to the conflict.

3. Collateral Attribute Loss

In real-world data environments, facts are rarely simple propositions; they are multi-attribute tuples (e.g., a patient record containing name, age, diagnosis, and address). As Sergio Greco et al. argue in Computing Approximate Query Answers over Inconsistent Knowledge Bases, traditional repair mechanisms delete the entire fact if even a single attribute causes a conflict. This discards massive amounts of clean, non-conflicting data.


Mechanism 1: Axiom Weakening and Concept Forgetting

Instead of deleting a general rule when a counterexample appears, why not surgically alter the rule to accommodate the exception?

In Repairing Ontologies via Axiom Weakening, Nicolas Troquard et al. introduce the concept of axiom weakening. Instead of a binary choice to keep or drop a rule like $\text{Bird} \sqsubseteq \text{CanFly}$ upon encountering a penguin, the framework uses refinement operators to make the problematic rule less restrictive. It structurally modifies the axiom to preserve the broader taxonomic structure while safely carving out the contradiction.

Traditional Deletion:
[Bird ⊑ CanFly]  ──(Encountered Penguin)──>  [Deleted Entirely] (All bird knowledge lost)

Axiom Weakening:
[Bird ⊑ CanFly]  ──(Encountered Penguin)──>  [Bird ⊓ ─Penguin ⊑ CanFly] (Taxonomy preserved)

A parallel approach involves concept forgetting. When resolving conflicts in distributed systems, Guilin Qi et al. demonstrate in A Forgetting-based Approach for Reasoning with Inconsistent Distributed Ontologies that a system can selectively "forget" or ignore only the specific concept names causing the contradiction. This allows the system to restore consistency locally without discarding entire ontologies or schemas.


Mechanism 2: Fact Decomposition via Deductive Closures

At the instance level (the specific facts or data points), fine-grained resolution changes how we handle conflicting assertions.

In A New Operator for ABox Revision in DL-Lite, Guilin Qi et al. propose a graph-based approach that breaks a conflicting fact down into its deductive closure—the full set of logical implications that the fact entails. Instead of deleting the fact wholesale, the mechanism filters out only the specific components of the deductive closure that directly contradict the new data, retaining all safe, non-conflicting implications.

This aligns with the foundational framework established by Giuseppe De Giacomo et al. in On the Update of Description Logic Ontologies at the Instance Level. When new information contradicts existing assertions, their update process removes the conflicting facts but explicitly calculates and retains all logical consequences of those facts that do not violate the new constraints.


Mechanism 3: Attribute-Value Updates

For database-driven knowledge bases, Sergio Greco et al. (Computing Approximate Query Answers over Inconsistent Knowledge Bases) propose shifting the repair paradigm entirely from tuple deletion to value modification.

Consider a scenario where a database schema dictates that an employee can only have one manager, but the system receives two conflicting records: (Alice, Dept_A, Manager_X) and (Alice, Dept_A, Manager_Y).

Tuple Deletion Repair (Information Loss):
❌ Delete both records or pick one arbitrarily. (Loses the fact that Alice works in Dept_A)

Value-Update Repair (Fine-Grained):
Keep the tuple structure, but update the conflicting attribute to a disjunctive or approximate value:
──> (Alice, Dept_A, {Manager_X, Manager_Y})

By updating values within the facts rather than deleting the rows, the system preserves the rich, non-conflicting attributes (like Alice's department), enabling highly informative, approximate query answering in polynomial time.


Prioritizing Logical Relevance Over Geometric Distance

Why do these fine-grained approaches succeed where traditional methods fail? The answer lies in how they define "minimal change."

Traditional belief revision often relies on geometric distance metrics between possible worlds to find a consistent state that is closest to the original. However, as Hai Wan et al. argue in Dependence in Propositional Logic: Formula-Formula Dependence and Formula Forgetting, minimizing geometric distance can still result in the unnecessary loss of relevant information.

Instead, modern fine-grained frameworks prioritize logical relevance. By explicitly mapping formula-formula dependencies, the system ensures that only the parts of the knowledge base that are logically dependent on the negated new information are discarded or modified.

This directly solves the "clean-slate" problem highlighted by Yi Jin 0006 et al. in Iterated Belief Revision, Revised, where a single contradiction in standard frameworks could force an agent to irrationally abandon an entire history of learned, unrelated facts. By bounding the repair to strict logical dependencies, independent beliefs remain completely untouched across successive updates.

Key Foundational Work

Default Reasoning through Belief Revision Strategy (1987) — contributed 2 concept elements to this direction.
Reasoning about Action Using a Possible Models Approach (1988) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_information_loss_in_belief_revision_134968bc,
  title = {information loss in belief revision},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/information-loss-in-belief-revision/rdr_134968bc816e4f15a3e4d5a48b52f1f9},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_information_loss_in_belief_revision_134968bc_v1,
  title = {information loss in belief revision},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/information-loss-in-belief-revision/rdr_134968bc816e4f15a3e4d5a48b52f1f9/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake