---
abstract: '> Abstract argumentation framework () is a unifying framework able to encompass a variety of nonmonotonic reasoning approaches, logic programming and computational argumentation. Yet, efficient approaches for most of the decision and enumeration problems associated to s are missing, thus potentially limiting the efficacy of argumentation-based approaches in real domains. In this paper, we present an algorithm for enumerating the preferred extensions of abstract argumentation frameworks which exploits parallel computation. To this purpose, the SCC-recursive semantics definition schema is adopted, where extensions are defined at the level of specific sub-frameworks. The algorithm shows significant performance improvements in large frameworks, in terms of number of solutions found and speedup.'
author:
- 'Federico Cerutti[^1]'
- 'Ilias Tachmazidis[^2]'
- 'Mauro Vallati[^3]'
- 'Sotirios Batsakis[^4]'
- 'Massimiliano Giacomin[^5]'
- 'Grigoris Antoniou[^6]'
bibliography:
- 'ref.bib'
title: 'Exploiting Parallelism for Hard Problems in Abstract Argumentation: Technical Report'
---

Introduction
============

Dung’s theory of abstract argumentation [@dung1995] is a unifying framework able to encompass a large variety of specific formalisms in the areas of nonmonotonic reasoning, logic programming and computational argumentation. It is based on the notion of argumentation framework (), consisting of a set of arguments and an *attack* relation between them. Different *argumentation semantics* introduce in a declarative way the criteria to determine which arguments emerge as ‘justified’ from the conflict, by identifying a number of *extensions*, sets of arguments that can . In [@dung1995] four semantics were introduced, namely *complete*, *grounded*, *stable*, and *preferred* semantics. For an introduction on alternative semantics, see [@KER2011]. The main computational problems in abstract argumentation include *decision* and *construction* problems, and turn out to be computationally intractable for most of argumentation semantics [@dw:2009]. In this paper we focus on the *extension enumeration* problem, constructing *all* extensions prescribed for a given : its solution provides complete information concerning the justification status of arguments and subsumes the solutions to the other problems.

In this paper we propose the first parallel approach for enumerating preferred extensions — a problem which lies at the second level of the polynomial hierarchy, thus justifying the quest for efficient solutions — which exploits the SCC-recursive schema [@AIJ05], a semantics definition schema where extensions are defined at the level of the sub-frameworks identified by the strongly connected components. A similar approach has been recently discussed in [@KR] and compared with the state-of-the-art approach [@tafa], but it does not exploit neither parallel nor dynamic programming techniques. As large-scale argumentation is vastly unexplored, there is no further work directly related to our approach. The closest work is in the context of Assumption-Based Argumentation (ABA) Frameworks [@Bondarenko1997], an abstract framework for default reasoning which can be instantiated with different deductive systems (e.g. logic programming, autoepistemic logic, default logic). [@Craven2012] describes a parallel implementation for credulous acceptance under the acceptablity semantics for some specific instances of ABAs in the medical domain. [@Craven2012] considers competitive parallel executions: multiple versions — equivalent w.r.t. their outcome — of a sequential process are created and then started in parallel. Once one version finds a solution to the problem, the others are killed.

Our work can be seen as part of a broader recent push towards large-scale reasoning which, among others, concerns simple semantic web reasoning [@g1], fuzzy ontologies [@g2] and logic programming [@g3]. Indeed, the fast-growing field of *argument mining* from content in the Web [@Grosse2012; @Cabrio2013] highlights the lack of large-scale reasoning approaches in formal argumentation, and thus increases the importance of our research.

The paper is organised as follows. In the first section we recall some necessary background on Dung’s , the SCC-recursive schema and the existing algorithmic approach exploiting it. In the subsequent section we present our approach for exploiting the SCC-recursive schema in a parallel fashion, and we discuss the theoretical remarks granting the correctness of the approach. An exhaustive experimental analysis is then presented in the forthcoming section. The last section concludes the paper and discusses future work.

Background
==========

Dung’s Argumentation Framework
------------------------------

An argumentation framework [@dung1995] consists of a set of arguments[^7] and a binary attack relation between them.

An *argumentation framework* () is a pair $\anAFsymbol = \anAF$ where $\setargs$ is a set of arguments and $\setattacks \subseteq \setargs \times \setargs$. We say that *attacks* iff $\tuple{\argb,\arga} \in \setattacks$, also denoted as $\attacks{\argb}{\arga}$. The set of attackers of an argument $\arga$ will be denoted as $\attackers{\arga} \triangleq \set{\argb : \attacks{\argb}{\arga}}$, the set of arguments attacked by $\arga$ will be denoted as $\attacked{\arga} \triangleq \set{\argb : \attacks{\arga}{\argb}}$. We also extend these notations to sets of arguments, given $E \subseteq \setargs$, $\attackers{E} \triangleq \set{\argb \mid \exists \arga \in E, \attacks{\argb}{\arga}}$ and $\attacked{E} \triangleq \set{\argb \mid \exists \arga \in E, \attacks{\arga}{\argb}}$.

An argument $\arga$ without attackers, such that $\attackers{\arga} = \emptyset$, is said *initial*. Moreover, each argumentation framework has an associated directed graph where the vertices are the arguments, and the edges are the attacks.

The basic properties of ness, acceptability, and admissibility of a set of arguments are fundamental for the definition of argumentation semantics.

\[def:recall\] Given an $\AFname$ $\anAFsymbol = \anAF$:

-   a set $\aset \subseteq \setargs$ is a ** set of $\anAFsymbol$ if $\nexists~ \arga, \argb \in \aset$ s.t. $\attacks{\arga}{\argb}$;

-   an argument $\arga \in \setargs$ is ** with respect to a set $\aset \subseteq \setargs$ of $\anAFsymbol$ if $\forall \argb \in \setargs$ s.t. $\attacks{\argb}{\arga}$, $\exists~ \argc \in \aset$ s.t. $\attacks{\argc}{\argb}$;

-   a set $\aset \subseteq \setargs$ is an *set* of $\anAFsymbol$ if $\aset$ is a set of $\anAFsymbol$ and every element of $\aset$ is with respect to $\aset$ of $\anAFsymbol$.

An argumentation semantics $\gensem$ prescribes for any $\anAFsymbol$ a set of *extensions*, denoted as $\setgenext{\gensem}{\anAFsymbol}$, namely a set of sets of arguments satisfying the conditions dictated by $\gensem$. Here we recall the definitions of complete (denoted as $\CO$), grounded (denoted as $\GR$) and preferred (denoted as $\PR$) semantics.

\[def\_sem\_recall\] Given an $\AFname$ $\anAFsymbol = \anAF$:

-   a set $\aset \subseteq \setargs$ is a *extension* of $\anAFsymbol$, $\aset \in \setgenext{\CO}{\anAFsymbol}$, iff $\aset$ is and $\forall \arga \in \setargs$ s.t. $\arga$ is w.r.t. $\aset$, $\arga \in \aset$;

-   a set $\aset \subseteq \setargs$ is the *extension* of $\anAFsymbol$, $\aset \in \setgenext{\GR}{\anAFsymbol}$, iff $\aset$ is the minimal (w.r.t. set inclusion) extension of $\anAFsymbol$. Its existence and uniqueness have been proved in [@dungetal2006];

-   a set $\aset \subseteq \setargs$ is a *extension* of $\anAFsymbol$, $\aset \in \setgenext{\PR}{\anAFsymbol}$, iff $\aset$ is a maximal (w.r.t. set inclusion) extension of $\anAFsymbol$.

Each extension $\aset$ implicitly defines a three-valued *labelling* of arguments: an argument $\arga$ is labelled iff $\arga \in \aset$; iff $\exists~ \argb \in \aset$ s.t. $\attacks{\argb}{\arga}$; otherwise. Argumentation semantics can be equivalently defined in terms of labellings rather than of extensions [@Caminada2006; @KER2011].

\[def-gen-labelling\] Given a set of arguments $\aset$, a *labelling* of $\aset$ is a total function $\Labfun: \aset \longrightarrow \set{\textin, \textout, \textundec}$. The set of all *labellings* of $\aset$ is denoted as $\setoflabellingsset{\aset}$. Given an $\anAFsymbol = \anAF$, a *labelling* of $\anAFsymbol$ is a labelling of $\setargs$. The set of all *labellings* of $\anAFsymbol$ is denoted as $\setoflabellings{\anAFsymbol}$.

Complete labellings can be defined as follows.

\[def:complete-labelling\] Let $\anAFsymbol = \anAF$ be an argumentation framework. A labelling $\Labfun \in \setoflabellings{\anAFsymbol}$ is a *complete labelling* of $\anAFsymbol$ iff it satisfies the following conditions for any $\arga \in \setargs$:

-   $\Labfun(\arga) = \textin \Leftrightarrow \forall \argb \in \attackers{\arga} \Labfun(\argb) = \textout$;

-   $\Labfun(\arga) = \textout \Leftrightarrow \exists \argb \in \attackers{\arga}: \Labfun(\argb) = \textin$.

The grounded and preferred labelling can then be defined on the basis of complete labellings.

Let $\anAFsymbol = \anAF$ be an argumentation framework. A labelling $\Labfun \in \setoflabellings{\anAFsymbol}$ is *the grounded labelling* of $\anAFsymbol$ if it is the complete labelling of $\anAFsymbol$ minimizing the set of arguments labelled , and it is a *preferred labelling* of $\anAFsymbol$ if it is a complete labelling of $\anAFsymbol$ maximizing the set of arguments labelled .

The function $\ExtToLab$ provides the connection between extensions and labellings.

\[set-lab-corresp\] Given an $\anAFsymbol = \anAF$ and a set $\aset \subseteq \setargs$, the corresponding labelling $\ExtToLab(\aset)$ is defined as $\ExtToLab(\aset) \equiv \Labfun$, where

-   $\Labfun(\arga) = \textin \Leftrightarrow \arga \in \aset$

-   $\Labfun(\arga) = \textout \Leftrightarrow \exists~ \argb \in \aset$ s.t. $\attacks{\argb}{\arga}$

-   $\Labfun(\arga) = \textundec \Leftrightarrow \arga \notin \aset \wedge \nexists~ \argb \in \aset$ s.t. $\attacks{\argb}{\arga}$

[@Caminada2006] shows that there is a bijective correspondence between extensions and labellings for complete, grounded, and preferred semantics.

Given an $\anAFsymbol = \anAF$, $\Labfun$ is a complete (grounded, preferred) labelling of $\anAFsymbol$ if and only if there is a complete (grounded, preferred) extension $\aset$ of $\anAFsymbol$ such that $\Labfun = \ExtToLab(\aset)$.

The set of complete labellings of $\anAFsymbol$ is denoted as $\setgenlab{\CO}{\anAFsymbol}$, the set of preferred labellings as $\setgenlab{\PR}{\anAFsymbol}$, while $\setgenlab{\GR}{\anAFsymbol}$ denotes the set including the grounded labelling.

SCC-Recursiveness {#sec:sccrev}
-----------------

In [@Baroni2004] an extension-based semantics definition schema has been introduced, called *SCC (strongly connected component)-recursiveness*, based on the graph-theoretical notion of SCCs [@Tarjan72 Lemma 9] and on the observation that most argumentation semantics can be equivalently defined at the level of SCCs.

The following definitions introduce the SCC-recursive schema [@AIJ05]. First, let us recall the definition of *restriction* of an $\anAFsymbol$ to a set of arguments $I$, in symbol $\restargfram{\anAFsymbol}{I}$.

Given an argumentation framework $\anAFsymbol = \anAF$ and a set $I \subseteq \setargs$, the restriction of $\anAFsymbol$ to $I$ is defined as $\restargfram{\anAFsymbol}{I} \equiv (I, \setattacks \cap (I \times I))$.

Then, Definition \[def:SCCscheme\] introduces the function $\setextgenn{\anAFsymbol}{C}$ which recursively computes the semantics extensions on the basis of the SCCs of $\anAFsymbol$. Let us denote as $\scc{\anAFsymbol}$ the set including the SCCs of an argumentation framework $\anAFsymbol$.

\[def:SCCscheme\] A given argumentation semantics $\gensem$ is SCC-recursive if for any argumentation framework $\anAFsymbol = \anAF$, $\setgenext{\gensem}{\anAFsymbol} = \setextgenn{\anAFsymbol}{\setargs} \subseteq 2^{\setargs}$. For any $\anAFsymbol = \anAF$ and for any set $C \subseteq \setargs$, $E \in \setextgenn{\anAFsymbol}{C}$ if and only if

-   $E \in \setbasgenn{\anAFsymbol}{C}{\gensem}$ $\card{\scc{\anAFsymbol}} = 1$

-   $ \forall S \in \scc{\anAFsymbol} ~ (E \cap S) \in
                       \setextgenn{\restargfram{\anAFsymbol}{S \setminus \attacked{(E \setminus S)}}}{\pundfromset{\anAFsymbol}{S}{E} \cap C}$ otherwise

where

-   $\setbasgenn{\anAFsymbol}{C}{\gensem}$ is a function, called *base function*, that, given an argumentation framework $\anAFsymbol = \anAF$ such that $\card{\scc{\anAFsymbol}} = 1$ and a set $C \subseteq \setargs$, gives a subset of $2^\setargs$

-   $\pundfromset{\anAFsymbol}{S}{E} = \set{\arga \in S \setminus \attacked{(E \setminus S)} \mid
                             \forall \argb \in (\attackers{\arga} \setminus S),~\argb \in \attacked{E} }$

The schema is based on the notions of extension of an *in a set of arguments*.

\[def:extinc\] Given an $\anAFsymbol = \anAF$ and a set $C \subseteq \setargs$, a set $E \subseteq \setargs$ is: an *admissible set of $\anAFsymbol$ in $C$* if and only if $E$ is an admissible set of $\anAFsymbol$ and $E \subseteq C$; a *complete extension of $\anAFsymbol$ in $C$* if and only if $E$ is an admissible set of $\anAFsymbol$ in $C$, and every argument $\alpha \in C$ which is acceptable with respect to $E$ belongs to $E$; the *grounded extension of $\anAFsymbol$ in $C$* if and only if it is the least (w.r.t. set inclusion) complete extension of $\anAFsymbol$ in $C$; a *preferred extension of $\anAFsymbol$ in $C$* if and only if it is a maximal (w.r.t. set inclusion) complete extension of $\anAFsymbol$ in $C$.

The existence and uniqueness of the grounded extension in $C$, as well as the existence of at least a preferred extension in $C$, have been proved in [@AIJ05]. Moreover, [@AIJ05] proves that $\setextgenn{\anAFsymbol}{C}$, as defined in Def. \[def:SCCscheme\], returns the $\gensem$-extensions in $C$ (with $\gensem \in \set{\CO, \GR, \PR}$), provided that $\setbasgenn{\anAFsymbol}{C}{\gensem}$ returns the complete, grounded, and preferred extensions in $C$, respectively.

[@KR] introduces the notions of complete, grounded and preferred labellings of $\anAFsymbol$ in $C$, the labelling-based counterparts of the corresponding notions of Definition \[def:extinc\], and describes a preliminary algorithm — — exploiting the SCC-recursive schema. implements $\mathcal{GF}$ (Def. \[def:SCCscheme\]), where the chosen base function $\simbsetbasgenn{\PR}$ is computed by a refinement of the algorithm in [@tafa] which exploits a SAT solver as a NP-oracle to determine the preferred labellings. exploits the SCC-recursive schema by constructing a sequence of strongly connected components of $\anAFsymbol$ in a topological order. Preferred labellings are incrementally constructed along the SCCs, by computing the preferred labellings of each SCC and merging them with those identified in the previous SCCs. In the following, we take advantage of two algorithms mentioned in [@KR], namely  [@KR Alg. 3] and  [@KR Alg. 4]: their usage is described in the following section.

Exploiting Parallel Computation
===============================

In this section we present our approach exploiting parallel computation in the context of the SCC-recursive schema. First of all, we need to identify when it is possible to parallelise the process aimed at verifying that given $\anAFsymbol = \AF{}$, $\forall E \subseteq \setargs, \forall C \subseteq \setargs, E \in \setextgenn{\anAFsymbol}{C}$.

Theoretical Remarks
-------------------

Two elements guaranteeing independence and thus the possibility to parallelise the process can be identified. First of all, each preferred extension can be computed independently from the others.

\[remark:parall-extensions\] Given an $\anAFsymbol = \AF{}$, $\forall E \in \setgenext{\gensem}{\anAFsymbol}, \forall C \subseteq \setargs$, proving that $E \in \setextgenn{\anAFsymbol}{C}$ does not require any knowledge about $\overline{E} \in \setgenext{\gensem}{\anAFsymbol}\setminus\set{E}$.

A second, rather more articulated, condition of independence requires to identify two sets of SCCs, $\overline{S} = \set{S_1, \ldots, S_n} \subseteq \scc{\anAFsymbol}$ and $P_{\overline{S}} = \set{P_1, \ldots, P_m} \subseteq \scc{\anAFsymbol}$ such that (1) each SCC in $\overline{S}$ does not attack the others in $\overline{S}$; and (2) each SCC in $\overline{S}$ is attacked only by SCCs in $P_{\overline{S}}$.

\[remark:parall-tree\] Given an $\anAFsymbol = \AF{}$, $\forall E \subseteq \setargs, \forall C \subseteq \setargs$, if there exist $\overline{S} = \set{S_1, \ldots, S_n} \subseteq \scc{\anAFsymbol}$ such that $\forall S_i, S_j, S_i^+\cap S_j = \emptyset$, and there exists $P_{\overline{S}} \subseteq \scc{\anAFsymbol}$ such that $\forall S_i \in \overline{S}, ({S_i}^- \setminus S_i) \subseteq \bigcup_{P \in P_{\overline{S}}} P$, then $\forall S \in \overline{S}$ proving that $(E \cap S) \in
                   \setextgenn{\restargfram{\anAFsymbol}{S \setminus \attacked{(E \setminus S)}}}{\pundfromset{\anAFsymbol}{S}{E} \cap C}$ can be determined in function of $P_{\overline{S}}$ and does not require any knowledge about $S' \in \overline{S}\setminus\set{S}$.

The $\nameprefparall$ Algorithm
-------------------------------

In this section we introduce a meta-algorithm —  (Alg. \[alg:parallel\]) — which exploits the SCC-recursive schema using parallel computation and a pro-active *greedy* approach which *memoizes* some notable cases.

First of all, the function $\nameinpref$ (Algorithm \[alg:base-p\]) receives as input an argumentation framework $\anAFsymbol = \anAF$ and returns the set of preferred labellings of $\anAFsymbol$. This is simply achieved by invoking (at line $3$) $\nameprefparall(\anAFsymbol,\setargs)$, where the function $\nameprefparall$ ($\mathcal{GF}$ in Def. \[def:SCCscheme\]) receives as input an argumentation framework $\anAFsymbol = \anAF$ and a set $C \subseteq \setargs$, and computes the set $\setgenlab{\PR}{\anAFsymbol, C}$, the set of preferred labellings of $\anAFsymbol$ in $C$.

 first pre-processes (at line $3$) — via the function   [@KR Alg. 3] — $\anAFsymbol$ by computing the grounded labelling in $C$: $\Labfun$ contains the restriction of the grounded labelling to those arguments which are either  or ; $U$ is the set of arguments that are labelled  in the grounded labelling.

At line $4$  initialises to $\set{\Labfun}$ the variable $E_p$, which stores the set of labellings that are incrementally constructed. At line $5$   restricts $\anAFsymbol$ to $\restargfram{\anAFsymbol}{U}$. Then, at line $6$,  exploits Remark \[remark:parall-tree\] by building a list $L := (L^1, \ldots, L^n)$ of sets of SCCs — [@Cormen2009 p. 617] with some modifications — such that $\forall L^i \in L, L^i = \set{S_j^i \in \scc{\anAFsymbol} ~\mid~ (S_j^i)^- \setminus S_j^i \in \bigcup_{z \in \set{1, \ldots, i-1} }\bigcup_{S \in L^{z}} S ~\mbox{and}~(S_j^i)^+ \setminus S_j^i \in \bigcup_{z \in \set{i+1, \ldots, n} }\bigcup_{S \in L^{z}} S}$.

At line $7$, the  function (Alg. \[alg:greedy\]) is called; it receives as input the list of SCCs $L$ and the set of arguments $C$, and returns a set $M$ of pairs $(S_i, B_i)$ where $S_i \in \scc{\anAFsymbol}$, and $B_i = \setgenlab{\PR}{\restargfram{\anAFsymbol}{S_i}, S_i \cap C}$. $B_i$ — computed by the function  [@KR Alg. 4] — is the set of preferred labellings for $S_i$ when no argument in $S_i$ is attacked by $\textin$ or $\textundec$ arguments in previous, w.r.t. the $L$ list, SCCs.

**$\nameinpref(\anAFsymbol)$**

**$\nameprefparall(\anAFsymbol,C)$**

Then, at lines $8-36$,  performs a first loop among the elements of the list $L$. At line $9$ a rather articulated data structure, $E_l$, is initialised. For each $S \in L_l$, $E_l^S$ is a list of pairs $(\Labfun, E_l^{S}[\Labfun] \subseteq \setoflabellingsset{S})$: to ease of notation, hereafter we omit the pair-structure thus referring directly to $E_l^{S}[\Labfun]$ which contains the set of preferred labellings of $S$ constructed on the basis of a specific labelling $\Labfun$ identified in the previous (w.r.t. the list $L$) SCCs.

Two more loops are thus considered and their execution can be safely parallelised: the loop at lines $10-28$ exploits Remark \[remark:parall-tree\] by considering each SCC in a given element of the list $L$; while the loop at lines $11-27$ considers a single preferred labelling, each of which is independent from the others — cf. Remark \[remark:parall-extensions\].

$\nameboundcondII(\anAFsymbol, S, L^l, \Labfun)$ at line $12$ computes the effect of previous SCCs, and returns $(O, I)$, where:

-   $O = \set{\arga \in S \mid \exists \argb \in \aset \cap \attackers{\arga} : \Labfun(\argb)=\textin}$ and

-   $I = \set{\arga \in S \mid \forall \ \argb \in \aset \cap \attackers{\arga} , \Labfun(\argb)=\textout}$,

with ${\aset \equiv \bigcup_{i = 1}^{l-1} \bigcup_{S \in L_i} S}$. Variable $O$ is set to include arguments of $S$ that are attacked by “outside” $\textin$-labelled arguments according to $\Labfun$, and variable $I$ is set to include arguments of $S$ that are only attacked by “outside” $\textout$-labelled arguments. This gives rise to three cases:

1.  each argument of $S$ is attacked by $\textin$ or $\textundec$ arguments in previous SCCs — hence each argument of $S$ is labelled  or  (line $14$);

2.  no argument of $S$ is attacked by $\textin$ arguments in previous SCCs: this is the base case of the recursion and thus either we exploit the *memoization* technique implemented with the  algorithm (line $17$) or we exploit the function  (line $20$);

3.  in the remaining case, arguments attacked by -arguments are labelled as $\textout$ and  is recursively called on the restriction of $S$ to the unlabelled arguments (lines $22-23$).

Finally, at lines $29-35$ the computed preferred labellings $E_l^S[\Labfun]$ are merged together ($E_1 \comblab E_2 = \set{\Labfun_1 \cup \Labfun_2 | \Labfun_1 \in E_1, \Labfun_2 \in E_2}$) with the $\Labfun$ labelling of previous SCCs. Once again, due to Remark \[remark:parall-extensions\], this process can be parallelised (lines $31-33$).

Then the algorithm considers the next element in the list $L$. Once the outer loop is exited, all strongly connected components have been processed, thus $E_p$ is returned as the set of preferred labellings in $C$ (line $37$).

**$\namegreedy(L, C)$**

Given an $\anAFsymbol = \anAF$ and a set $C \subseteq \setargs$, Algorithm \[alg:parallel\] returns $E_p = \setgenlab{\PR}{\anAFsymbol, C}$.

This follows from [@KR Thm. 1] and Remarks \[remark:parall-extensions\] and \[remark:parall-tree\].

Empirical Analysis
==================

The solvers have been run on a cluster with computing nodes equipped with 2.4 Ghz Dual Core AMD Opteron, 8 GB of RAM and Linux operating system. As in the International Planning Competition (IPC) [@Jimenez2012], a cutoff of 900 seconds was imposed to compute the preferred extensions for each . No limit was imposed on the RAM usage, but a run fails at saturation of the available memory. Moreover, we adopted the IPC speed score, also borrowed from the planning community, which is defined as follows. For each , each system gets a score of $1/(1 + \log_{10}(T/T^*))$, where $T$ is its execution time and $T^*$ the best execution time among the compared systems, or a score of 0 if it fails in that case. Runtimes below 0.01 sec get by default the maximal score of 1. In our experimental analysis, IPC score is normalised to 100. For each solver we recorded the overall result: success (if it finds each preferred extension), crashed, timed-out or ran out of memory.

As shown in [@comma14a], most of the state-of-the-art approaches for enumerating preferred extensions hardly solve large (w.r.t. the number of arguments) frameworks. In this work, we focus on extremely large s; the largest – as far as we know – that have ever been used for testing solvers.

We randomly generated a set of 200 s, varying the number of SCCs between 90 and 210, the number of arguments between 2,700 and 8,400, and considering different uniformly distributed probabilities of attacks, either between arguments or between different SCCs, leading to s with a number of attacks between approximately 100 thousands and 2 millions. s were generated using [AFBenchGen]{} [@comma14b].

In the following we rely on the Wilcoxon Signed-Rank Test (WSRT) in order to identify significant subset of data [@Wilcoxon1945].

                  P1      P2      P2G         P4          P4G
  ------------- ------- ------- ------- --------------- -------
  IPC score      50.0    58.6    44.7    [**74.9**]{}    56.9
  % success      58.8    68.3    57.3    [**74.9**]{}    65.8
  % best          1.0     0.0     0.0    [**74.4**]{}     0.0
  Avg runtime    439.4   464.3   385.7   [**269.6**]{}   384.8
  Speedup          –      1.9     1.3         2.8         1.7

  : \[tab:cfr\] Performance achieved by using 1, 2 and 4 processors with/out exploiting the *greedy* approach (+G). Results are shown in terms of normalised IPC score, percentages of success, percentages of s in which the system has been the fastest, average runtime (considering s in which at least one approach succeeded) and max speedup against P1. Values in bold indicate the best results.

Table \[tab:cfr\] shows the results of the overall comparison between R-PREF (henceforth P1) and $\nameprefparall$ (henceforth P2 or P4, according to the number of processors). The latter exploits either two or four processors, and has been run with and without the *greedy* approach. From Table \[tab:cfr\], two main conclusions can be derived. First, the exploitation of *greedy* approach introduces a significant overhead, due to the required pre-calculation. In our testing instances, pre-calculated knowledge is not used by algorithms and therefore, exploiting a *greedy* approach has a detrimental effect on P2 and P4 performance. This behaviour is confirmed also by a comparison (not shown) between P1 with/out *greedy* approach. Given this result, the *greedy* approach will not be considered in the rest of this section.

The second conclusion we derive from Table \[tab:cfr\] is that parallelisation improves significantly the performance of both runtime and the number of successfully analysed s. Since the normalised IPC score of P4 is equal to its percentage of successes, P4 is always the fastest approach on the whole testing set. Both P4 and P2, according to WRST perform significantly better than P1 ($p < 0.05$). Using 2 (resp. 4) processors provides a maximum speed-up of 1.9 (resp. 2.8) times w.r.t. serial execution. Such results justify the use of parallel approaches in abstract argumentation.

![CPU-time of P2 (upper) or P4 (lower) w.r.t. P1 for all the considered s. The x-axis refers to CPU seconds of P1; the y-axis refers to CPU seconds of P2 (upper) or P4 (lower). CPU-time of 900 seconds indicates timeout.[]{data-label="fig:scatter"}](imgs/P1P2){width="\linewidth"}

![CPU-time of P2 (upper) or P4 (lower) w.r.t. P1 for all the considered s. The x-axis refers to CPU seconds of P1; the y-axis refers to CPU seconds of P2 (upper) or P4 (lower). CPU-time of 900 seconds indicates timeout.[]{data-label="fig:scatter"}](imgs/P1P4){width="\linewidth"}

![IPC scores of P2, P4 and P1 w.r.t. the probability of attacks between different SCCs (upper) and the number of SCCs (lower).[]{data-label="fig:sccs"}](imgs/attacks){width="\linewidth"}

![IPC scores of P2, P4 and P1 w.r.t. the probability of attacks between different SCCs (upper) and the number of SCCs (lower).[]{data-label="fig:sccs"}](imgs/SCCs){width="\linewidth"}

Figure \[fig:scatter\] provides results in the form of scatterplots, showing the performance of P1 and, respectively, P2 and P4. Using 2 processors have a remarkable impact on runtimes, in particular on complex s, which require approximately more than 300 seconds. A larger number of s can be successfully analysed by P2: this can be derived by observing the elements on the right axis of the graph. On *simple* s, the impact of using 2 processors is not so clear. On the other hand, parallelising on 4 processors guarantee to obtain lower runtimes on the whole testing set. This behaviour is probably due to the fact that the overhead introduced by parallelisation (generating threads, communication overhead, etc.) is not completely compensated by using 2 processors only, specially when a short amount of CPU time is needed for enumerating the extensions of a given .

The number of SCCs in the same set, cf. Remark \[remark:parall-tree\], critically affects the performance of the proposed parallel algorithm. The larger the size of each level, the higher the degree of parallelisation that can be reached, since parallelisation is primarily based on processing simultaneously SCCs that are located on the same level. Figure \[fig:sccs\] (upper) show the IPC score of parallelised and serial algorithms, with regards to the probability of attacks between SCCs. As expected, the performance gap between parallelised (P2, P4) and serial (P1) algorithms is maximum when the probability is 0 — i.e., all the SCCs are on the same level — and slowly decreases as the percentage increases. With a probability of 75%, most of the levels have a single SCC, therefore parallelisation does not provide a great speedup. It is worthy to notice that at higher attacks probability percentages, enumerating all the preferred extensions is very complex, and requires a significant amount of CPU-time. The differences of performance between P1 and P4 are always statistically significant ($p < 0.05$). It is not the case of P1 and P2, their performance are statistically indistinguishable on sets with probability of attacks of 50% ($p = 0.39$) and 75% ($p=0.66$).

Finally, Figure \[fig:sccs\] shows how IPC score of considered algorithms changes with regard to the number of SCCs of the s. As a general trend, increasing the number of SCCs increases the runtime (and decreases the number of successes) for all implementations. This is expected, as larger inputs are harder to solve. On the other hand, P1 is very quick on smallest considered s; on average it is faster than P2. P1 performance rapidly decreases as the number of SCCs increases. This is also confirmed by the WRST: while P4 is always statistically better than P1, P2 performs statistically worse than P1 on s with $|$SCCs$|=90$, but it performs statistically better when $|$SCCs$| >= 120$. Generally, parallelisation provides best speedup on very large s, with lower probability of attacks among SCCs.

Conclusions
===========

In this paper we proposed an approach for exploiting the SCC-recursive schema for computing semantics extensions in Dung’s s taking advantage of parallel executions and dynamic programming. It is worth mentioning that Alg. \[alg:base-p\], in conjunction with Algs. \[alg:parallel\] and \[alg:greedy\], are meta-algorithms that implement the SCC-recursive schema independently from the chosen semantics. Although we chose to consider the preferred semantics in order to provide a direct comparison with recent works [@KR] — in essence equivalent to P1 — , the same algorithms can work for each semantics that is SCC-recursive [@AIJ05].

Moreover, the empirical analysis shows that there is a substantial statistically significant increment of performance due to the partial parallel execution of the proposed algorithms. This results in:

1.  an increment (approx. 50%) of the number of s for which we can solve the preferred semantics enumeration problem before the chosen cutoff time;

2.  a significant speedup of the computation of preferred extension up to 280% just considering 4 processors.

Future work is already envisaged in the area of additional experimentation analyses by considering different benchmarks and by discussing a variation of Alg. \[alg:parallel\] where the two inner loops of Alg. \[alg:parallel\] (lines $10-24$ and $11-23$) are swapped. We also plan to apply more dynamic programming techniques (e.g. *memoization*) by improving the current proposal of the *greedy* computation of some preferred labelling — Alg. \[alg:greedy\]. In addition, we will compare our approach with [@Dvorak2011; @Ellmauthaler2014], which reduce the problem of enumerating preferred extensions to an ASP program which can be solved using the parallel ASP solver `clingo`. Finally, recent works on Input/Output behaviour characterisation of s [@Baroni2012; @Baroni2014] can be exploited for determining conditions of independent computation and thus exploiting parallel executions on graph structures different from SCCs.

[^1]: f.cerutti@abdn.ac.uk

[^2]: ilias.tachmazidis@hud.ac.uk

[^3]: m.vallati@hud.ac.uk

[^4]: S.Batsakis@hud.ac.uk

[^5]: massimiliano.giacomin@unibs.it

[^6]: g.antoniou@hud.ac.uk

[^7]: In this paper we consider only *finite* sets of arguments: see [@Baroni2013] for a discussion on infinite sets of arguments.
