Transfer of semantics from argumentation frameworks to logic programming A preliminary report

There are various interesting semantics’ (extensions) designed for argumentation frameworks. They enable to assign a meaning, e.g., to odd-length cycles. Our main motivation is to transfer semantics’ proposed by Baroni, Giacomin and Guida for argumetation frameworks with odd-length cycles to logic programs with odd-length cycles through default negation. The developed construction is even stronger. For a given logic program an argumentation framework is defined. The construction enables to transfer each semantics of the resulting argumentation framework to a semantics of the given logic program. Weak points of the construction are discussed and some future continuations of this approach are outlined.

💡 Research Summary

The paper investigates a systematic method for transferring semantics from abstract argumentation frameworks (AFs) to normal logic programs (LPs) that contain default negation, with a particular focus on handling odd-length cycles. The authors start by recalling Dung’s foundational AF model and a variety of extensions (preferred, stable, CF1, CF2, AD1, AD2) that have been proposed to address the shortcomings of classical semantics, especially the inability of stable semantics to assign extensions to odd cycles. They then present the SCC‑recursive approach introduced by Baroni, Giacomin, and Guida, which treats strongly connected components (SCCs) of an AF as units that can be processed hierarchically: initial SCCs (those without parents) are evaluated first, and the result influences the evaluation of downstream SCCs. This recursive schema enables symmetric treatment of even and odd cycles and gives rise to the four new semantics AD1, AD2, CF1, and CF2.

The core contribution of the paper is a construction that, given a logic program P, builds an associated argumentation framework AFₚ. The arguments of AFₚ are precisely the rules of P. An attack (r₁, r₂) exists when the head of r₁ appears negatively in the body of r₂ and r₁ has an empty positive body (i.e., body⁺(r₁)=∅). This syntactic restriction guarantees that only “pure” rules—those that do not depend on other atoms—can act as attackers, simplifying the mapping but also limiting expressiveness.

With AFₚ in place, any argumentation semantics σ (e.g., AD1, AD2, CF1, CF2, preferred, stable) can be applied to obtain a set of σ‑extensions Eσ(AFₚ). Each extension corresponds to a set of rules, called Rule_in^σ, that are “enabled” under σ. From Rule_in^σ the authors define a derived atom set I_nAS^σ by a fixed‑point construction: first, heads of rules with empty positive bodies are added; then, iteratively, the head of a rule whose positive body literals already belong to I_nAS^σ is added. This mirrors the usual derivation process in logic programming but is guided by the chosen argumentation semantics.

A crucial consistency check follows: the derived atom set must be compatible with the enabled rule set, meaning no atom in I_nAS^σ may appear negatively in the body of any rule in Rule_in^σ. If this condition fails, the extension is discarded as semantically invalid for the program. The authors illustrate the mechanism with two examples. In the first, a program with a chain of default negations yields a preferred extension that coincides with the program’s stable model {a, c}. In the second, a program where attacks are absent leads to a preferred extension that violates the consistency condition, demonstrating that not every argumentation extension yields a meaningful program semantics.

The paper discusses how the SCC‑recursive semantics handle odd cycles more gracefully than classical stable semantics. For instance, CF2 can assign extensions to an odd cycle by selecting maximal conflict‑free subsets within the SCC, and this selection is directly transferred to the logic program via the construction.

In a later section the authors sketch a reverse translation: given an AF, one can construct a logic program whose stable models correspond exactly to the AF’s extensions. This bidirectional correspondence underscores the theoretical robustness of the approach.

Weaknesses are openly acknowledged. The restriction that only rules with empty positive bodies may attack limits the applicability to many realistic programs where rules depend on other atoms. The consistency check can produce “bugs” where intuitive extensions are rejected, and the proposed remedy—maximizing consistent subsets—breaks the uniformity of the transfer because it would need to be tailored for each semantics. Moreover, the paper does not provide empirical evaluation of computational overhead, nor does it compare the resulting semantics with existing ASP encodings of CF2 or other SCC‑recursive semantics.

Future work outlined includes: (1) generalizing the attack relation to allow rules with non‑empty positive bodies to attack, (2) designing efficient algorithms for the consistency maximization step, (3) extending the framework to additional argumentation semantics (e.g., semi‑stable, stage), and (4) implementing the construction in an ASP solver to assess performance and practical usefulness.

In conclusion, the authors demonstrate that any argumentation semantics can, in principle, be transferred to a logic program via a systematic construction of an argumentation framework over the program’s rules. This provides a unified theoretical bridge between two rich research areas and offers a promising avenue for handling odd‑cycle problems in logic programming, albeit with several technical challenges that remain to be solved.