The MatrixX Solver For Argumentation Frameworks

by   Maximilian Heinrich, et al.

MatrixX is a solver for Abstract Argumentation Frameworks. Offensive and defensive properties of an Argumentation Framework are notated in a matrix style. Rows and columns of this matrix are systematically reduced by the solver. This procedure is implemented through the use of hash maps in order to accelerate calculation time. MatrixX works for stable and complete semantics and was designed for the ICCMA 2021 competition.


page 1

page 2

page 3


The matrices of argumentation frameworks

We introduce matrix and its block to the Dung's theory of argumentation ...

Fudge: A light-weight solver for abstract argumentation based on SAT reductions

We present Fudge, an abstract argumentation solver that tightly integrat...

Web-based Argumentation

Assumption-Based Argumentation (ABA) is an argumentation framework that ...

The pyglaf argumentation reasoner (ICCMA2021)

The pyglaf reasoner takes advantage of circumscription to solve computat...

Handling controversial arguments by matrix

We introduce matrix and its block to the Dung's theory of argumentation ...

A matrix approach for computing extensions of argumentation frameworks

The matrices and their sub-blocks are introduced into the study of deter...

1 Introduction

Main idea for the MatrixX solver is the observation that an Argumentation Framework (AF) can be represented as a matrix, where the offensive and defensive properties of the AF are displayed as rows and columns. The solver shrinks the matrix in a systematic way, which is inspired by Knuth’s Algorithm X [Knuth00]. Therefore, matrix approach plus Algorithm X results in the chosen solver name. The solver and instructions for use can be found at:

MatrixX supports stable and complete semantics according to ICCMA specifications [LagniezLMR20]. The paper starts with a very short recap about AFs, then the operating principle of the solver is explained via a practical example.

2 Argumentation Frameworks

An AF, first introduced by Dung [Dung95], is a directed graph with a set of arguments and an attack relation . Regarding semantics, we state that a set is conflict-free () if does not attack any of its elements and is admissible () if is conflict-free and defends all its elements against their attackers. A node is defended if all of its attackers are counterattacked. In addition, the set is complete () if it is admissible and contains all elements it defends. The set is stable () if it is conflict-free and each argument which is not in is getting attacked [GagglLMW20]. For further specification we say that for a node the set contains all nodes which attacks, formally stated as . In the paper we will refer to as the offensive properties of node . Vice versa, with defensive properties we denote the set of all nodes which are attacking , stated as . The nodesize of an AF is specified as , which is the number of arguments in . For a better illustration of the solver mechanics we take Figure 1 with as running example, which has the stable interpretations and complete interpretations .


Figure 1: An Example AF
nodes Table 1: Matrix
The AF and its matrix representation . If we look in the matrix e.g. at the row for we see an entry at , meaning that attacks and vice versa that is attacked by

3 Matrix Representation of AFs

A matrix representation for an AF with nodesize is a matrix, where each row and column represents a corresponding node of the AF. For better orientation we use the nodes directly as indizes for the matrix. If a node attacks another node the entry in the matrix is marked with otherwise

is used. More formally, we start with a zero matrix and add the entries

. Because offensive and defensive properties are closely related, we also obtain the defensive properties of all nodes with this construction process. If we look at the rows of the created matrix we can see the offensive properties of the corresponding node and if we look at a column, we get the defensive properties of the represented node, every existing relation is marked with . The solver operates on shrinking the offensive and defensive entries in , where the rows and columns are removed independently. In order to talk about the removal procedure we introduce the sets and , where is representing all rows and the columns of the matrix. If a node is contained in or then the corresponding row respectively column is still considered for the following operations. In addition, offensive and defensive properties of the nodes are calculating w.r.t. to the existing rows and columns. In this context, for a node , and . At the beginning we have . Also we start with the current extension . The set is the storage for nodes which are obtained during the calculation. For our example Figure 1, which has nodesize , the corresponding matrix representation is stated in Table 1. The stable semantics can now be obtained by repeatedly applying Algorithm 1.

1:Matrix , with information about and the current extension
3:if , where  then a node which is not attacked exists
4:     select
5:      = node_choosen(,) apply Node_Chosen function to copy of
6:     return = [] return matrix
8:     select , where select node with least attackers
9:      = node_choosen(,) apply Node_Chosen function to copy of
10:      = node_not_choosen(,) apply Node_Not_Chosen function to copy of
11:     return = [,] return matrices and
12:end if
14:function node_chosen(matrix , node )
15:      add node to extension
16:      erase node with its offensive and defensive properties
17:      erase node and its offensive properties
18:     return
19:end function
21:function node_not_chosen(matrix , node )
22:      erase node
23:     return
24:end function
Algorithm 1 MatrixX - Iteration for Stable Semantics

The algorithm is applied iteratively for each obtained matrix in . If , a stable interpretation is found and the current extension is marked as a valid interpretation. If is empty but not , we abandon the current matrix. In the following, we illustrate the procedure with Table 1 as example. As we start no offensive or defensive information have been erased, resulting in and

. No node is unattacked. We therefore choose the node with the least number of attackers, due to heuristic reasons. In our case we have multiple options, we decide to use node

and create two copies of , further referenced as submatrices. For the first submatrix we apply the function Node_Chosen. Hence we add to our current extension , remove from and erase from . The set is representing possible node combinations, which can be chosen from. Therefore if is chosen to be in the extension we remove it from . Node attacks and gets attacked by . This means that and cannot be together with in the same extension and are getting removed from too. is representing the extensionality of the AF. In order to attain stable semantics all nodes must be either in the extension or get attacked. For that reason only and can be removed from . Node is is removed because it is in the extension and because it is getting attacked. This means that needs to be eliminated from by another node later in order to obtain a stable interpretation. For the second submatrix we apply the function Node_Not_Chosen. For this submatrix we have decided that shall not be included in the extension , therefore this node is not able to attack any other nodes. Consequently we just remove from . No elements from are getting erased. The two obtained submatrices are shown in Table 3 and 3. We continue to apply Algorithm 1 for the generated submatrices till all stable extensions are obtained.

Table 2: after Node_Chosen function
Table 3: after Node_Not_Chosen function

For complete semantics a slight variation of Algorithm 1 is used. Here the function Node_Not_Chosen removes node from , but for all following defensive properties evaluations of other nodes node is still considered. The complete semantics demands that all attackers must be attacked from the elements in , therefore offensive properties of nodes can only be erased in case a node is selected to be in the extension. In order to obtain the complete interpretations for each generated submatrix the elements in are checked. If contains no unattacked nodes and each node in the current extension is unattacked, we found a complete interpretation. If the former condition is removed one could also easily calculate the admissible interpretations, though this is not supported by the solver.

4 Conclusion

Goal of the solver is that rows and columns of a matrix are erased as fast as possible. With increasing nodesize the size of the matrix grows quadratically, aggravating the evaluation. In order to do this more efficiently the solver works with hash maps. Consequently an entry for a node only contains information about its defensive and offensive properties. This way zero entries in the corresponding matrix are omitted. This procedure was also inspired by Knuth’s Algorithm X, which uses the concept of dancing links. In addition the solver copies the matrix after each step, therefore backtracking and restoring of previous configurations is not required in order to test all node combinations for an extension. For additional speed-up of the calculation time we first evaluate the grounded extension of the AF, which is used as initial input. Self-attacking nodes are also handled separately. Despite these optimizations, the solver had to fight with time-outs in the competition and performed rather slow. All of its competitors are using compiled languages such as C++ in some form, showing that MatrixX, which exclusively uses Python as an interpreted language, cannot successfully compete against such approaches. On the other hand MatrixX proposes an interesting approach for solving AFs, which has not been proceeded so far. Hence it would be interesting to see how fast a compiled version of MatrixX could perform in order to compare solvers which are operating on the same hardware level. Also it seems interesting to modify the described matrix shrinking procedure w.r.t. other semantics.