The Equivalence of Logic Programming and Formal Argumentation

50 concepts27 papers2 proposals

In knowledge representation, two distinct paradigms have historically coexisted for handling conflict and incomplete information. On one side sits Logic Programming (LP), particularly Answer Set Programming (ASP), which uses declarative rules and mathematical fixpoints to calculate stable models. On the other side sits Formal Argumentation Theory, which models reasoning as a dialectical game of arguments, attacks, and defenses.

For years, these fields were treated as separate approaches to non-monotonic reasoning. However, a deep body of research has revealed that they are fundamentally two sides of the same coin. By establishing a formal, bidirectional correspondence between logic programming and argumentation, researchers have unlocked a powerful synergy: we can use the raw computational power of logic solvers to resolve complex argumentative debates, and we can use the intuitive, dialectical nature of argumentation to explain the "black box" outputs of logic programs.

The Core Intuition: Negation as an Attack

To understand why logic programming and argumentation map to each other so perfectly, we must look at how both frameworks handle disagreement.

In logic programming, non-monotonicity is achieved through Negation as Failure (NAF). Consider a simple rule:

$$\text{fly} \leftarrow \text{bird}, \sim \text{injured}$$

Here, $\sim \text{injured}$ means we assume the bird is not injured simply because we cannot prove that it is injured.

As explored by Toni in From Logic Programming to Argumentation and Back, this mechanism is inherently dialectical. Saying "assume the bird is not injured unless proven otherwise" is functionally identical to making an assumption that stands until it is successfully attacked.

In an Assumption-Based Argumentation (ABA) framework, this rule is translated directly into an argumentative structure:

  1. The NAF literal $\sim \text{injured}$ is treated as a formal assumption.
  2. The rule itself forms an argument for $\text{fly}$, backed by that assumption.
  3. Any separate logical derivation that proves the bird is $\text{injured}$ acts as a direct attack on the assumption $\sim \text{injured}$.

This structural alignment means that calculating whether a set of logic rules is consistent is mathematically identical to determining which arguments can collectively defend themselves against all opposing attacks.

Bridging the Semantics

The correspondence is not just a surface-level analogy; it is an exact mathematical equivalence between the foundational semantics of both fields.

In logic programming, an interpretation of a program can be evaluated using three-valued logic (where a statement is true, false, or undefined). In argumentation, arguments are evaluated using labellings (where an argument is in if it is accepted, out if it is rejected, or undecided if it is neutral).

Logic Programming Semantics             Argumentation Framework Semantics
┌───────────────────────────┐           ┌────────────────────────────────┐
│ 3-Valued Stable Models    │  ◄─────►  │ Complete Labellings            │
├───────────────────────────┤           ├────────────────────────────────┤
│ Answer Sets (Stable)      │  ◄─────►  │ Stable Extensions              │
├───────────────────────────┤           ├────────────────────────────────┤
│ Partial Stable Models     │  ◄─────►  │ Bipolar Extensions             │
└───────────────────────────┘           └────────────────────────────────┘

Schulz et al. demonstrated in Logic Programming in Assumption-Based Argumentation Revisited - Semantics and Graphical Representation that the 3-valued stable semantics of a logic program correspond one-to-one with the complete assumption labellings of its argumentative counterpart. Furthermore, Schulz showed in Graphical Representation of Assumption-Based Argumentation that these complex 3-valued models can be entirely visualized as labeling states within an argumentation graph, making abstract logical states tangible.

This correspondence scales up as both formalisms become more complex:

The Pragmatic Payoff: Computation and Explanation

Why spend the effort translating between these two worlds? The answer lies in a fundamental trade-off in artificial intelligence: the tension between raw computational efficiency and human-readable explainability.

1. Using Logic to Solve Argumentation (Computation)

Finding a winning set of arguments (a stable extension) in a complex, cyclic debate is computationally hard—often sitting at the higher levels of the polynomial hierarchy. Writing a custom graph-traversal algorithm to solve this from scratch is highly inefficient.

Because of the semantic correspondence, we can instead compile an argumentation framework into an Answer Set Program or a Boolean Satisfiability (SAT) problem. As highlighted by Cerutti et al. in Argumentation Extensions Enumeration as a Constraint Satisfaction Problem: a Performance Overview and Summary Report of The First International Competition on Computational Models of Argumentation, general-purpose SAT and ASP solvers consistently outperform custom argumentation algorithms.

By leveraging logic programming primitives like counting aggregates, as explored by Brewka et al. in Solving Advanced Argumentation Problems with Answer-Set Programming, solvers can process complex acceptance thresholds and weighted argument structures in a single execution pass.

2. Using Argumentation to Explain Logic (Explanation)

Conversely, while ASP solvers are incredibly fast at finding stable models, they act as a "black box." An answer set tells you what literals are true, but it does not give you a narrative explaining why they are true.

By mapping the logic program's answer sets back into an argumentation framework, we can automatically construct Attack Trees. As detailed by Schulz in Explaining Answer Set Programming in Argumentative Terms and Schulz et al. in Justifying answer sets using argumentation, these trees provide a step-by-step dialectical justification. If a user asks why a certain conclusion was reached, the system can display the winning argument and show how it successfully defended itself against every possible counter-argument (or logical constraint) in the program.

Applications and Extensions

This correspondence has moved beyond pure theory, serving as a foundational middleware layer (Cerutti et al. in Foundations of Implementations for Formal Argumentation) that powers diverse AI applications.

Inductive Learning

Instead of manually writing rules, can an AI learn an explainable argumentation framework directly from data? De Angelis et al. tackled this in ABA Learning via ASP and Learning Brave Assumption-Based Argumentation Frameworks via ASP. By framing the learning process as a "brave reasoning" task inside an ASP solver, their system searches through potential rule combinations, using the speed of ASP to verify which learned rules yield the correct argumentative extensions.

Real-World Dialectics

The correspondence also enables structured reasoning over unstructured data. In automated fake news detection, Kotonya demonstrated in Gradual Argumentation Evaluation for Stance Aggregation in Automated Fake News Detection that mapping text classifications to formal support and attack relations yields more accurate veracity predictions than simple statistical averages.

In education, Hong et al. utilized this duality in "My Grade is Wrong!": A Contestable AI Framework for Interactive Feedback in Evaluating Student Essays. By mapping natural language student challenges onto a formal abstract argumentation framework, the system ensures that multi-agent grading debates remain logically consistent and stable.

Ultimately, the logic-argumentation correspondence proves that deduction and debate are not competing paradigms, but mathematically identical strategies for navigating conflict and uncertainty.

Key Foundational Work

A Constructive semantic characterization of aggregates in answer set programming (2007) — contributed 2 concept elements to this direction.
A Generalized Gelfond-Lifschitz Transformation for Logic Programs with Abstract Constraints (2007) — contributed 1 concept elements to this direction.
An Operational Semantics for Knowledge Bases (1994) — contributed 1 concept elements to this direction.
History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 26 papers
  2. Version 1 · 2026-10-04 · 24 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_logic_argumentation_correspondence_c0eebe45,
  title = {logic-argumentation correspondence},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/logic-argumentation-correspondence/rdr_c0eebe45eb254002a6daa975ce7a61e0},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 2, frozen text):

@misc{lacuna_logic_argumentation_correspondence_c0eebe45_v2,
  title = {logic-argumentation correspondence},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/logic-argumentation-correspondence/rdr_c0eebe45eb254002a6daa975ce7a61e0/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake