AFSynth

Synthesizing Argumentation Frameworks from Examples

AFSynth is developed by the Constraint Reasoning and Optimization Group at the Department of Computer Science, University of Helsinki, and implemented by Andreas Niskanen.

About

Argumentation frameworks (AFs) provide a knowledge representation formalism for abstract argumentation, where arguments are represented as nodes and attacks between arguments as directed edges. Extensions are subsets of the set of arguments fulfilling certain conditions as specified via semantics.

AF synthesis [1] is a natural generalization of realizability in abstract argumentation. Given a semantics and a set of extensions, realizability is the problem of deciding whether there exists an AF which exactly represents the extensions. The AF synthesis problem allows for studying realizability under incomplete and noisy information. In AF synthesis, we are given a set of positive and a set of negative examples, corresponding to extensions and non-extensions, along with weights associated to each example, expressing the relative trust. The task is to find an AF which optimally represents the examples by minimizing the costs, incurred by including a negative example or not including a positive example in the set of extensions.

AFSynth implements AF synthesis under the conflict-free, admissible and stable semantics via encoding the problem as a weighted partial MaxSAT instance and calling the corresponding solver.

Usage

USAGE: ./afsynth <file> [options]

COMMAND LINE ARGUMENTS:

<file>	: Input filename for AF synthesis instance in apx format.

COMMAND LINE OPTIONS:
-h        : Display this help message.
-v        : Display the version of the program.
-o <out>  : Output clauses to file <out> in wcnf format and exit.

Input format

arg(X).      ... X is an argument
pos(i,X).    ... X is in the positive example i
neg(i,X).    ... X is in the negative example i
sem(i,S).    ... the example i has semantics S={cf|adm|stb}
weight(i,n). ... the example i has weight n

The following example declares three arguments {a,b,c}, two positive examples {a,c} (conflict-free semantics) and {b,c} (stable semantics), and one negative example {a} (admissible semantics). All examples have unit weights.

arg(a).
arg(b).
arg(c).
pos(1,a).
pos(1,c).
weight(1,1).
sem(1,cf).
pos(2,b).
pos(2,c).
weight(2,1).
sem(2,stb).
neg(3,a).
weight(3,1).
sem(3,adm).

In this particular case the cost is zero due to all positive examples being included and all negative examples not included as extensions. The output of AFSynth is the following.

Positive example 1 included.
Positive example 2 included.
Negative example 3 not included.
arg(a).
arg(b).
arg(c).
att(b,a).

Downloads

AFSynth

Version 2016-08-10 available here.

Benchmarks

Benchmarks used in [1] are available here for ICCMA instances and here for random instances. For more details on the benchmarks, see [1].

References

[1] Synthesizing Argumentation Frameworks from Examples. Andreas Niskanen, Johannes P. Wallner, and Matti Järvisalo. In ???, editors, Proceedings of the 22nd European Conference on Artificial Intelligence (ECAI 2016), volume ??? of Frontiers in Artificial Intelligence and Applications, pages ???--???. IOS Press, 2016.
[pdf] [abstract/bibtex]