A Four-Label-Based Algorithm for Solving Stable Extension Enumeration in Abstract Argumentation Frameworks

Abstract

In abstract argumentation frameworks, the computation of stable extensions is an important semantic task for evaluating the acceptability of arguments. The current approaches for the computation of stable extensions are typically conducted through methodologies that are either label-based or extension-based. Label-based algorithms operate by assigning labels to each argument, thus reducing the attack relations between arguments to constraint relations among the labels. This paper analyzes the existing two-label and three-label enumeration algorithms for stable extensions through case studies. It is found that both the two-label and three-label algorithms are not precise enough in defining types of arguments. To address these issues, this paper proposes a four-label enumeration algorithm for stable extensions. This method introduces a$must\_in$ label to pre-mark certain $in$-type arguments, thereby achieving a finer classification of $in$-type arguments. This enhances the labelings’ propagation ability and reduces the algorithm’s search space. Our proposed four-label algorithm was tested on authoritative benchmark sets of abstract argumentation framework problems: ICCMA 2019, ICCMA 2021, and ICCMA 2023. Experimental results show that the four-label algorithm significantly improves solving efficiency compared to existing two-label and three-label algorithms. Additionally, ablation experiments confirm that both the four-label transition strategy and preprocessing strategy enhance the algorithm’s performance.

1. Introduction

Computational argumentation is an essential component of artificial intelligence [1,2,3], aiming to analyze the acceptability of arguments and ultimately achieve consensus. The abstract argumentation framework (abbreviated AAF or AF), first proposed by Dung [4], consists of a set of arguments and a set of attack relations. By determining the acceptability of arguments, AF derives relevant semantic extensions. This framework abstracts complex problems into simple argumentation models, making it a fundamental model for argumentation across various domains. Moreover, AF serves as a reasoning model and a research cornerstone in fields such as decision support systems [5], non-monotonic reasoning [6], machine learning [7], medical decision-making [8,9], explainable artificial intelligence, and intelligent interactions in multi-agent systems [10].

Enumerating stable extensions is a fundamental problem in abstract argumentation frameworks. Previous algorithms for enumerating stable extensions include dynamic programming algorithms [11], reduction algorithms [12], and depth-first search (DFS) algorithms [13], among which DFS algorithms commonly use labeling models. Typical label-based methods for enumerating stable extensions include two-label and three-label algorithms. The two-label algorithm for stable extensions is an intuitive method based on the definition of stable extensions. This labeling method is relatively simple and direct in algorithm design but suffers from numerous ineffective searches. Additionally, Nofal et al. proposed a three-label algorithm for stable extensions [14], introducing a new labeling to the two-label algorithm to differentiate argument types and reduce the search space. Although the three-label algorithm partially optimizes the issues present in the two-label algorithm, it still has problems with redundant searches. To our knowledge, there is currently no comprehensive, efficient, and direct DFS within backtracking algorithms for enumerating stable extensions. Therefore, this paper introduces a four-label enumeration algorithm for stable extensions by adding the $must\_in$ label.

The main contributions of this paper can be summarized in two aspects. First, this paper conducts a comprehensive analysis of the existing two-label and three-label enumeration stable extension methods, illustrating their limitations through sample analyses. Second, by introducing the $must\_in$ label, a four-label algorithm is proposed. In the four-label algorithm, we first propose a preprocessing strategy that can preemptively label and address arguments concerning confirmed labeling types, thereby achieving the target state (i.e., stable extensions) earlier. Additionally, a four-label transition strategy is introduced to enhance collaboration between labels, thereby accelerating labeling propagation and reducing the search space of the algorithm.

The paper is organized as follows. Section 2 gives an introduction to the semantic extension model of the abstract argumentation framework and the related algorithms for solving stable extensions. Section 3 presents the definitions of the argumentation framework, labeling model, and stable extensions, as well as their interrelationships. Section 4 gives a comparative analysis of the existing two-label and three-label algorithms for solving stable extensions and highlights their limitations. Section 5 elaborates on the concepts and details of the four-label algorithm. Section 6 demonstrates the experimental results of the four-label algorithm and other label algorithms on the ICCMA benchmark sets and analyzes the impact of the preprocessing strategy and labeling transition strategy on the algorithm’s efficiency through ablation experiments. Section 7 contains the remarks and future work.

2. Related Work on Reduction-Based Methods and Direct Solving for AF

In early abstract argumentation frameworks, the concepts of admissible set, complete extension, grounded extension, preferred extension, and stable extensions were generally represented through extension models [15]. Furthermore, these concepts can also be expressed through labeling models [16,17]. In the current research on abstract argumentation frameworks, the design of algorithms for solving stable extensions primarily revolves around these two models. These algorithms can generally be divided into reduction-based algorithms (or methods) and direct solving algorithms [12].

Reduction-based methods transform the problem of solving abstract argumentation frameworks (such as stable extensions) into another classical NP problem, by using existing mature algorithms to solve this NP problem. These reduction-based methods can be further subdivided into reduction methods based on extension models and those based on labeling models. The reduction methods based on extension models leverage the properties of extension models to transform the abstract argumentation framework problem into a classical NP problem. For example, ASPARTIX-V [18,19] encodes the problem of finding stable extensions in an argumentation framework into an answer set problem (ASP). Since there is a direct correspondence between answer sets and stable models, this method can use a standard ASP solver to directly model and solve the semantics of the abstract argumentation framework. The solutions to the ASP problem can then be decoded to obtain solutions to the original problem. Similarly, $\mu$-toksia [20] encodes the problem of solving semantic extensions into a SAT problem, then uses the SAT solver CryptoMinSat [21] as the underlying solver. The reduction methods based on labelings combine the definition of the semantics with their corresponding labelings to reduce the problem to a classic NP problem. For instance, ArgSemSAT uses the Glucose [22] SAT solver, while Fudge uses the CaDiCaL [23,24] SAT solver. Essentially, mature and general solvers like ASP solvers and SAT solvers employ complex and efficient algorithmic strategies, such as conflict-driven clause learning [25,26].

Direct methods for solving semantic problems in abstract argumentation frameworks can be divided into incomplete search algorithms [27] and complete search algorithms. A representative example of incomplete algorithms is the local search algorithm. This kind of algorithm first initializes a set of labels for the arguments, then continually selects and flips the labels of some conflicting arguments using heuristic strategies until a legal solution is found [28]. Complete algorithms, on the other hand, are based on a depth-first search framework and traverse the entire solution space to find the solution. To enhance the efficiency of complete algorithms, effective branching strategies, labeling propagation methods, and pruning strategies are commonly employed. Notable solvers of this type include ArgTools [29] and DREDD [30]. The four-label algorithm presented in this paper is also a direct solving algorithm. By introducing a new label, our proposed algorithm optimizes the labeling transition strategy, thereby accelerating labeling propagation and reducing the search space.

3. Background

3.1. Abstract Argumentation Framework and Stable Extensions

An abstract argumentation framework consists of a set of arguments and binary attack relations between them. In other words, each AF corresponds to a directed graph where each argument in the framework represents a vertex, and each attack relation represents an edge.

Definition 1.

(Abstract Argumentation Framework): Given an abstract argumentation framework AF, it is a tuple $\Gamma =〈A,R〉$, where A is a set of arguments, and $R\subseteq A\times A$ is a binary relation representing the attack relations on the set A.

In an abstract argumentation framework $AF$, if $(a,b)\in R$, it means that argument a attacks argument b (or b is attacked by a), and this can also be denoted as $a\to b$. Let ${\left\{a\right\}}^{+}$ denote the subset of arguments attacked by a and ${\left\{a\right\}}^{-}$ denote the subset of arguments that attack a. Given a set of arguments $X\subseteq A$:

$$X^{-}=\{b\in A:\exists a\in Xs.t.b\in {\left\{x\right\}}^{-}\},$$

$$X^{+}=\{b\in A:\exists a\in Xs.t.b\in {\left\{x\right\}}^{+}\}.$$

Definition 2.

(Conflict-Free Set): Given an abstract argumentation framework $\Gamma =〈A,R〉$, a subset $X\subseteq A$ is a conflict-free set iff $\forall a$, $b\in X$, $\nexists (a\to b\vee b\to a)$, meaning there is no direct attack relationship between a and b. The set of conflict-free sets is denoted by $X_{CF}(\Gamma )$.

Definition 3.

(Acceptability of Arguments): Given an abstract argumentation framework $\Gamma =〈A,R〉$, where $X\in X_{CF}(\Gamma )$, an argument $a\in A$ is acceptable with respect to X iff $\nexists (a\to X)\wedge (X\to a)$ and, ∀$b\in A$ ($b\notin X$), if $b\to a$, then $X\to b$ must hold.

Definition 4.

(Admissible Set): Given an abstract argumentation framework $\Gamma =〈A,R〉$, a subset $X\subseteq A$ is an admissible set iff $X\in X_{CF}(\Gamma )$, and each argument in X is acceptable with respect to X. The set of admissible sets is denoted by $X_{AS}(\Gamma )$.

Definition 5.

(Complete Extension): Given an abstract argumentation framework $\Gamma =〈A,R〉$, a set of arguments X is a complete extension iff $X\in X_{AS}(\Gamma )$, and every argument acceptable with respect to X belongs to X. The set of complete extensions is denoted by $X_{CO}(\Gamma )$.

A complete extension includes all arguments that are acceptable with respect to itself and does not allow for the addition of any new acceptable arguments through extension.

Definition 6.

(Stable Extension): Given an argumentation framework $\Gamma =〈A,R〉$, a set of arguments $X\subseteq A$ is a stable extension iff $X\in X_{CO}(\Gamma )$ and, for every argument $\forall a\in A$ such that $a\notin X$, it holds that $X\to a$. In other words, a stable extension attacks every argument that does not belong to that extension. The set of stable extensions is denoted by $X_{ST}(\Gamma )$.

Stable extensions can be obtained using a characteristic function derived from complete extensions. Each complete extension corresponds to a stable extension. However, different complete extensions may yield the same stable extension through further extension, hence $X_{ST}(\Gamma )\subseteq X_{CO}(\Gamma )$.

3.2. The Relationship between Arguments and Labelings

There is a one-to-one correspondence [17] between labelings and arguments. In an abstract argumentation framework $\Gamma =〈A,R〉$, each extension E implicitly defines a three-valued labeling of arguments: if an argument a belongs to E, then a is labeled as $in$; if a is labeled as $out$, it indicates that there exists an argument in E attacking a; if neither condition applies, a is labeled as $undec$. Here, the $in$ label signifies explicit support for the argument, the $out$ label denotes explicit opposition to the argument, and the $undec$ label indicates that the status of the argument remains undecided.

Definition 7.

(Labeling Model): Given an argumentation framework $\Gamma =〈A,R〉$ and argument $a\in A$, let $Lab:A\to \{in,out,undec\}$ be a mapping from arguments of the argumentation framework Γ to labels.

Definition 8.

(Legal $in$ Label): Given an argumentation framework $\Gamma =〈A,R〉$ and arguments $a,b,c\in A$, let $Lab:A\to \{in,out,undec\}$ represent a mapping from arguments of the argumentation framework Γ to labels. It is known that $Lab\left(a\right)=in$, for any $b\in {\left\{a\right\}}^{+}$, so it holds that $Lab\left(b\right)=out$, and, for any $c\in {\left\{a\right\}}^{-}$, it holds that $Lab\left(c\right)\ne in$.

Definition 9.

(Legal $out$ Label): Given an argumentation framework $\Gamma =〈A,R〉$ and arguments $a,b\in A$, let $Lab:A\to \{in,out,undec\}$ represent a mapping from arguments of the argumentation framework Γ to labels. If $Lab\left(a\right)=out$, then there exists $b\in {\left\{a\right\}}^{-}$ such that $Lab\left(b\right)=in$.

Definition 10.

(Legal $undec$ Label): Given an argument framework $\Gamma =〈A,R〉$ and arguments $a,b\in A$, let $Lab:A\to \{in,out,undec\}$ denote the mapping from arguments of the argumentation framework Γ to labels. If $Lab\left(a\right)=undec$, then there exists $b\in {\left\{a\right\}}^{-}$ such that $Lab\left(b\right)=undec$.

In the mapping of arguments to labels within an abstract argumentation framework, a set of labels is considered a complete labeling when all three types of label are legal. This complete labeling serves as the foundation for defining other semantic labeling. Consequently, when the set of $undec$ labels in a set of complete labeling is empty, this complete labeling is also a stable labeling. In the subsequent discussion of stable extension algorithms, it is assumed that the $undec$ label set is empty; hence, the $undec$ label will not be included in the labeling propagation process of the stable extension algorithms.

4. Comparison of Two-Label and Three-Label Enumeration Algorithms for Stable Extensions

4.1. Labeling Model for Stable Extensions

In current research, algorithms that solve stable extensions based on depth-first search include two-label algorithms and three-label algorithms. The two-label algorithm is an intuitive labeling algorithm designed based on the properties of stable extensions. The three-label algorithm is a labeling algorithm designed on the basis of the two-label algorithm by introducing the $must\_out$ label.

In the two-label algorithm, since arguments within a stable extension attack all arguments not included in the extension, there are only two types of legal labels in the stable extension: the $in$ label and the $out$ label. The $in$ label is used to label arguments that can be included in the stable extension sets, while the $out$ label is used to label arguments that are attacked by $in$ arguments and thus cannot be included in the stable extension sets. Therefore, the two-label algorithm employs two types of label transitions: $in$ transition and $out$ transition.

Definition 11.

(Two-Label Stable Extension): Given an argumentation framework $\Gamma =〈A,R〉$ and arguments $a,b\in A$, let $Lab:A\to \{in,out\}$ be a mapping from arguments of the argumentation framework Γ to labels. A stable extension satisfies the following conditions:

$$Lab\left(a\right)=ins.t.\forall b\in {\left\{a\right\}}^{-}:Lab\left(b\right)=out,$$

$$Lab\left(a\right)=outs.t.\exists b\in {\left\{a\right\}}^{-}:Lab\left(b\right)=in.$$

In the three-label algorithm, the $must\_out$ label is introduced to label arguments that attack the arguments labeled as $in$, thereby distinguishing between different types of $out$ arguments. Consequently, three labeling types participate in labeling propagation within the algorithm. However, the algorithm defines only two types of labeling transition rules: $in$ transition and $must\_out$ transition. The reasons for using $in$ and $must\_out$ for the labeling transition in this algorithm are as follows. Firstly, a binary branching structure is more suitable for solving stable extension problems compared to other multi-branch structures. Secondly, conflicting arguments are generally labeled as $must\_out$. The legality check of the argument labels only needs to focus on the set of arguments labeled as $must\_out$. Using the $must\_out$ label as a type of labeling transition can eliminate conflicting arguments more quickly, enabling the algorithm to enumerate stable extensions faster.

Definition 12.

($must\_out$ Label): Given an argumentation framework $\Gamma =〈A,R〉$ and arguments $a,b\in A$, let $Lab:A\to \{in,out,must\_out\}$ be a mapping from arguments of the argumentation framework Γ to labels. If b satisfies $b\in {\left\{a\right\}}^{-}$ and $Lab\left(a\right)=in$, then $Lab\left(b\right)=must\_out$.

Definition 13.

(Three-Label Stable Extension): Given an argumentation framework $\Gamma =〈A,R〉$ and arguments $a,b\in A$, let $Lab:A\to \{in,out,must\_out\}$ be the mapping from arguments of the argumentation framework Γ to labels. The three-label stable extension satisfies the following conditions:

$$Lab\left(a\right)=ins.t.\forall b\in {\left\{a\right\}}^{-}:Lab\left(b\right)=out,$$

$$Lab\left(a\right)=outs.t.\exists b\in {\left\{a\right\}}^{-}:Lab\left(b\right)=in,$$

$$Lab\left(a\right)=ins.t.\forall b\in {\left\{a\right\}}^{-}\wedge Lab\left(b\right)\ne out:Lab\left(b\right)=must\_out.$$

4.2. Comparison of Two-Label and Three-Label Algorithms

Figure 1 illustrates specific instances of the two-label (left) and three-label (right) solving algorithms, using the $blank$ label to represent arguments that have not been labeled. In the instance of the two-label algorithm (left), the algorithm performs three argument selections in the order of $a_1$, $a_3$, and $a_6$. After each labeling propagation, the algorithm checks for label legality. The two-label algorithm primarily involves the following three steps:

• Step 1: Argument $a_1$ is labeled as $in$ and propagates the $out$ label to argument $a_2$, with all propagated labels being legal.
• Step 2: Argument $a_3$ is labeled as $in$ and propagates the $out$ label to arguments $a_4$ and $a_5$. The arguments $a_2$, $a_4$, and $a_5$, labeled as $out$, are all legal.
• Step 3: Argument $a_6$ is labeled as $in$ without propagating any other argument labels, so no labeling legality check is needed. At this point, all arguments have been legally labeled, so the set of arguments labeled as $in$ $\{a_1,a_3,a_6\}$ forms a stable extension.

In the instance of the three-label algorithm (right), there are also three argument selections, following the same order as above. However, the label legality check in this algorithm only applies to arguments labeled as $must\_out$. The three-label algorithm primarily involves the following three steps:

• Step 1: Argument $a_1$ is labeled as $in$ and propagates the label $out$ to argument $a_2$. No labeling legality check is needed in this round.
• Step 2: Argument $a_3$ is labeled as $in$ and propagates the labels $must\_out$ and $out$ to arguments $a_4$ and $a_5$, respectively. A legality check is performed for argument $a_4$, which is labeled as $must\_out$.
• Step 3: Argument $a_6$ does not propagate any other argument labels, so no legality check is needed.

From Figure 1, it is evident that the two-label algorithm is indeed quite simple and intuitive. However, it also shows that, during the label legality check, it often encounters unnecessary checks. For instance, after the labeling propagation in Step 2 of Figure 1, only argument $a_4$ actually requires a label legality check, but the two-label algorithm performs redundant checks on arguments $a_2$ and $a_5$. This greatly affects the algorithm’s efficiency. Therefore, to reduce the frequency of redundant searches, the label legality check process needs to be optimized. In the three-label algorithm, the introduction of the $must\_out$ label distinguishes between $out$ arguments that may result in illegal labeling propagation and those that definitely will not. Consequently, during each label legality check, only arguments labeled as $must\_out$ need to be checked. The three-label algorithm significantly reduces the number of redundant searches during the labeling propagation process.

Although the three-label algorithm appears to have optimized the issue of redundant searches present in the two-label algorithm, it still has some shortcomings. The three-label algorithm only distinguishes the nature of arguments labeled as $out$ and does not perform a comprehensive and systematic analysis of the nature of all arguments. In fact, the nature of arguments labeled as $in$ in the labeling propagation process of the three-label algorithm also exhibits diversity. In the next section, this paper introduces a four-label enumeration stable extension algorithm by incorporating the $must\_in$ label, along with an illustrative example and detailed description of the algorithm.

5. The Labeling Algorithm for Four-Label Enumeration Stable Extension

5.1. The Concept of the Four-Label Enumeration Stable Extension Algorithm

In this section, a four-label solving algorithm is proposed, aiming to more quickly address the enumeration problem of stable extensions in abstract argumentation frameworks. This new algorithm builds upon the existing two-label and three-label algorithms by introducing the $must\_in$ label to differentiate between $in$ type arguments with varying properties. This allows for the early labeling of some arguments, thereby accelerating labeling propagation and reducing the algorithm’s search space. The following provides the algorithm concept and an illustrative example.

In the four-label algorithm, the abstract argumentation framework is first preprocessed, categorizing the arguments into three types: initial argument set (labeled as $must\_in$), self-attacking argument set (labeled as $must\_out$), and ordinary argument set (others). Arguments in the $must\_in$ set are prioritized for labeling transition in this round. Next, the algorithm selects an argument from the ordinary argument set for the $in$ transition. After this labeling transition, a label legality check is performed (only for $must\_out$ arguments). If all propagated labels are legal, the algorithm continues to select ordinary arguments for the labeling transition; if it is illegal, the chosen ordinary argument is set to $must\_out$, and a label legality check is conducted again. The algorithm then checks the legality of the results. When all argument labels are legally $in$ and $out$, the set of arguments labeled as $in$ is considered a stable extension. Finally, this process is repeated until all stable extensions are enumerated.

Definition 14.

($must\_in$ Label): Given an argumentation framework $\Gamma =〈A,R〉$ and arguments $a,b\in A$, let $Lab:A\to \{in,out,must\_out,must\_in\}$ represent the mapping from arguments of the argumentation framework Γ to labels. If an argument a satisfies ${\left\{a\right\}}^{-}=⌀$ or $\forall b\in {\left\{a\right\}}^{-}$, $Lab\left(b\right)=out$, then $Lab\left(a\right)=must\_in$.

Definition 15.

(Four-Label Stable Extension): Given an argumentation framework $\Gamma =〈A,R〉$ and arguments $a,b\in A$, let $Lab:A\to \{in,out,must\_out,must\_in\}$ represent the mapping from arguments of the argumentation framework Γ to labels. The four-label stable extension satisfies the following conditions:

$$Lab\left(a\right)=ins.t.\forall b\in {\left\{a\right\}}^{-}:Lab\left(b\right)=out,$$

$$Lab\left(a\right)=outs.t.\exists b\in {\left\{a\right\}}^{-}:Lab\left(b\right)=in,$$

$$Lab\left(a\right)=ins.t.\forall b\in {\left\{a\right\}}^{-}\wedge Lab\left(b\right)\ne out:Lab\left(b\right)=must\_out,$$

$$Lab\left(a\right)=must\_ins.t.{\left\{a\right\}}^{-}=⌀\vee \forall b\in {\left\{a\right\}}^{-}:Lab\left(b\right)=out.$$

Figure 2 illustrates a specific instance of the four-label stable extension solving algorithm, with the $blank$ label representing arguments that have not been labeled. This instance can be divided into the following two steps:

• Step 1: During preprocessing, the initial argument $a_1$ is labeled as $must\_in$, and other ordinary arguments are labeled as $blank$. The arguments in the $must\_in$ label set are then prioritized for the $in$ transition. Consequently, argument $a_1$ is labeled as $in$ and propagates the label $out$ to argument $a_2$.
• Step 2: The argument $a_3$ is selected from the ordinary argument set. Then argument $a_3$ is labeled as $in$ and propagates labels $must\_out$ and $out$ to arguments $a_4$ and $a_5$, respectively. The labeling legality of argument $a_4$, which is labeled as $must\_out$, is then checked and found to be legal. Next, the algorithm attempts to further propagate labels based on the propagated arguments $a_4$ and $a_5$. Argument $a_4$ propagates the label $must\_in$ to argument $a_6$, which is then labeled as $in$. At this point, a stable extension $\{a_1,a_3,a_6\}$ is obtained.

Algorithm 1: Four-Label Enumerate All Stable Extensions of $\Gamma =〈A,R〉$.

5.2. Four-Label Algorithm Description

In the four-label enumeration stable extension algorithm, the algorithm first classifies the arguments in the input abstract argumentation framework based on their different properties, aiming to differentiate the arguments by priority. Then, it performs a labeling transition on the arguments according to their priority order. Finally, the algorithm collects the legal labeling sets, where the set of $in$ arguments constitutes the stable extension. The algorithm framework is outlined below.

The framework of the four-label algorithm is illustrated in Algorithm 1. Here, $\Gamma =\langle A,R\rangle$ represents the input abstract argumentation framework, $Lab$ denotes the mapping from arguments of the argumentation framework $\Gamma$ to labels, E is the stable extension set, and the $blank$ label represents arguments that have not been labeled. In Algorithm 1, the algorithm first preprocesses the input abstract argumentation framework (line 7); then, it selects unlabeled arguments (i.e., ordinary arguments) for labeling transition, prioritizing the $in$ transition. If this fails, it attempts the $must\_out$ transition. The process is repeated until all arguments are fully labeled, provided that the labeled arguments are legal (lines 8–14); finally, the legality of the labeling results is checked (lines 2–6).

The framework of the four-label algorithm can be divided into two functional modules: the preprocessing strategy and the four-label transition strategy. The preprocessing strategy primarily performs two operations: identifying high-priority arguments and labeling them as $must\_in$ and further processing the $must\_in$ arguments. In the four-label transition strategy, the focus is on performing the $in$ transition and the $must\_out$ transition and then checking the legality of the labels. The following sections will detail each of these modules.

Preprocessing Strategy. The preprocessing strategy is used to differentiate the order of argument labeling, with the main objectives of accelerating labeling propagation and reducing the number of algorithmic backtracks. In the abstract argumentation framework, since initial arguments are included in all extensions and since self-attacking arguments are not included in any extension, the algorithm can distinguish these special arguments during preprocessing based on their properties. Once these special arguments are labeled, initial arguments can be directly subjected to the labeling transition. Additionally, during the labeling transition process, the labels of some arguments can be inferred based on existing labels, and the handling of these arguments can be analogized to the initial arguments.

Q1:

Why not directly label initial arguments with the $in$ label but rather with the $must\_in$ label?

Q2:

Why not directly label the self-attacking arguments with the $out$ label but rather with the $must\_out$ label?

We address these questions directly in the following paragraphs:

A1:

The advantage of using the $must\_in$ label is as follows. Since initial arguments are included in all semantic extensions, labeling these arguments with $must\_in$ allows the algorithm to focus on arguments that can be further processed, thus avoiding unnecessary argument search issues. Similarly, in the subsequent labeling transition strategy, $must\_in$ labels can also be used to label arguments whose label types are determined through inference. Thus, during argument label branching decisions, the algorithm only needs to consider those arguments whose label types are not yet determined and whose label is being attempted to be set as $in$, thereby reducing the number of algorithmic backtracks.

A2:

Since self-attacking arguments do not belong to any semantic extension, their final label type is generally $out$. However, in practice, self-attacking arguments may also contain contradictory arguments (e.g., self-attacking arguments that are not attacked by any other arguments) that cannot be legally labeled as $out$. Therefore, self-attacking arguments should be labeled as $must\_out$ first to facilitate legality checks. Similarly, contradictory arguments will also arise in the labeling transition strategy, requiring special marking with $must\_out$ labels for legality checks, thereby improving the algorithm’s efficiency.

Algorithm 2 illustrates the preprocessing procedure; here, x refers to an argument selected from the set A, with the $blank$ label representing arguments that have not been labeled. It defines three useful mappings, and the subsequent operations of the algorithm are based on them. The labels in the mapping functions are $blank$, $must\_out$, and $must\_in$. Specifically, self-attacking arguments are labeled with $must\_out$, initial arguments that are not attacked by any other arguments are labeled with $must\_in$, and all other arguments are labeled as $blank$ (lines 2–10). Next, the algorithm stores the resulting $must\_in$ arguments in set S, and then it prioritizes checking whether set S is empty. If S is not empty, the arguments in S are subjected to the $in$ transition (lines 11–12). Otherwise, the algorithm moves to the stage of selecting $blank$ arguments. This preprocessing strategy is similar to methods used for solving grounded extensions.

Algorithm 2: Preprocessing Labels

Labeling Transition Strategy. After the preprocessing is finished, the algorithm proceeds with a labeling transition and a legality check. First, the algorithm selects arguments that have not been labeled for the labeling transition, following the transition rules for $in$ and $must\_out$ labels. The labeling transition process is a binary tree searching framework, which tends to perform better than other multi-branch structures in algorithms. When all arguments have been labeled, the algorithm performs a legality check on the labeled argumentation framework for stable extensions. The criterion for this check is that the set contains only two types of labels: legal $in$ labels and legal $out$ labels.

During the labeling transition, the algorithm first performs the $in$ transition operation. As shown in Algorithm 3, it selects an argument x from the $blank$ arguments that have not been labeled and labels the chosen argument x as $in$. The arguments attacking x are labeled as $must\_out$ (lines 10–11), and the arguments attacked by x are labeled as $out$ (lines 3–5). After marking the arguments that have a direct attack relationship with x, the algorithm checks the legality of the generated $must\_out$ labels. If they are legal, the algorithm uses the arguments labeled as $must\_out$ and $out$ as two label inference directions. First, it judges whether more labels can be propagated in the $must\_out$ direction (lines 12–16). For instance, in Figure 2, argument $a_4$ propagates to argument $a_6$. Then, it judges whether more labels can be propagated in the $out$ direction (lines 6–9). If the labels are not legal, the label of the $in$ argument causing the conflicting argument is set to $must\_out$, and the algorithm continues to repeat the labeling transition operation until all arguments are legally labeled. The specific transition details are shown in Algorithm 4.

Definition 16.

(Contradictory Argument): Given an argumentation framework $\Gamma =〈A,R〉$ and argument $a\in A$, let $Lab:A\to \{in,out,must\_out,must\_in\}$ represent a mapping from arguments of the argumentation framework Γ to labels. If $Lab\left(a\right)=must\_out$ and ${\left\{a\right\}}^{-}=⌀$ or $\forall b\in {\left\{a\right\}}^{-}$, $Lab\left(b\right)\ne blank$, then argument a is called a contradictory argument.

Definition 17.

($4lab$-$in\_transitions$): Given an argumentation framework $\Gamma =〈A,R〉$ and arguments $a,x,y\in A$, let $Lab:A\to \{in,out,must\_out,must\_in\}$ represent a mapping from arguments of the argumentation framework Γ to labels. The $blank$ label represents an unmarked argument. The specific transition rules are shown in Algorithm 3.

Definition 18.

($4lab$-$must\_out$-$transitions$): Given an argumentation framework $\Gamma =〈A,R〉$ and arguments $x,y\in A$, let $Lab:A\to \{in,out,must\_out,must\_in\}$ represent a mapping from arguments of the argumentation framework Γ to labels. The $blank$ label represents an unlabeled argument. The specific propagation rules are shown in Algorithm 4.

Algorithm 3: 4lab-in-transitions

Algorithm 4: 4lab-must_out-transitions

In the evaluation of the result, first, it is checked whether all arguments have been labeled, and then it is checked whether any contradictory arguments exist. If neither condition is present, then the set of arguments labeled as $in$ forms a stable extension. The final stable extension set E may be empty, may contain a single subset, or may contain multiple subsets.

In summary, the algorithm introduces the $must\_in$ label, providing more variety in argument labeling. This increases the length of the labeling propagation chain and reduces the search space. Therefore, the four-label algorithm proposed in this paper is more suitable for solving the stable extension problem compared to the two-label and three-label algorithms.

6. Experiment Analysis

6.1. Experiment Setup

To accurately evaluate the performance of the proposed method, both the four-label method that we propose in this paper and the two-label method used for comparison were implemented on the ArgTools solver (which uses the three-label method). All experiments run on Ubuntu 22.04 LTS (64 bit) with Intel Core i7-11700 @ 2.50 GHz CPU and 32 GB of RAM. The three methods above were tested on the ICCMA 2019, ICCMA 2021, and ICCMA 2023 datasets from the International Competition on Computational Models of Argument (ICCMA) (https://argumentationcompetition.org/2023/tracks.html, accessed on 3 August 2024). To be consistent with the testing standards of ICCMA 2023, we set the time limit as 1200 s for stable extensions of every AF instance. The result of each instance was presented as success (if the problem was solved) or failure (including crashes or timeouts). The source code has been made available (https://github.com/bear-eng/label-algorithm.git, accessed on 3 August 2024).

In the analysis of the experiment results, this paper primarily considers two metrics: the number of solved instances and PAR-2. PAR-2 represents an absolute performance measure, where the run time for problems that could not be solved within the allotted time is set to twice the cutoff time, while the run time for other instances is the actual run time.

6.2. Experiment Results and Analysis

Table 1. Experiment results on instances of the main track of ICCMA 2023 and ICCMA 2019.

Instances	Solver	# Solved	PAR-2 (s)
ICCMA 2019 (326)	ArgTools_2lab	292	260.3
	ArgTools_3lab	298	217.13
	ArgTools_4lab	326	7.36
ICCMA 2021 (587)	ArgTools_2lab	132	1994.39
	ArgTools_3lab	136	1963.9
	ArgTools_4lab	171	1729.37
ICCMA 2023 (329)	ArgTools_2lab	190	1073.15
	ArgTools_3lab	201	956.82
	ArgTools_4lab	224	752.19

presents a comparative analysis of the performance of the two-label algorithm (ArgTools_2lab), the three-label algorithm (ArgTools_3lab), and the four-label algorithm (ArgTools_4lab) on the benchmarks of the main track of ICCMA 2019, ICCMA 2021, and ICCMA 2023. From Table 1, it can be concluded that the four-label algorithm outperforms the other two algorithms across all three benchmarks. In other words, this method improves algorithm efficiency by introducing new labels to differentiate between the types of arguments and by refining the labeling rules based on the relationships among arguments. Next, we conducts three sets of ablation experiments to analyze the reasons for the efficiency improvements and demonstrates that the method is also effective in other solvers. Overall, the four-label algorithm has improved efficiency by 17.4% compared to the two-label algorithm and by 13.5% compared to the three-label algorithm.

In the ablation experiments of the preprocessing strategy and the four-label transition strategy, we configured these two strategies separately in the ArgTools solver and then ran the configured solvers on the main track of the ICCMA 2023 benchmark. Additionally, to better illustrate the algorithm’s performance on each instance and on each instance family, we have created cactus plots for individual instances and scatter plots for instance families. Note that instance family refers to a set of instances with similar names. Based on the solution results in

Table 2. Experiment results on the ICCMA 2023 benchmark of different instance families.

Instance Families	ArgTools_4lab		ArgTools_3lab		ArgSemSAT
	PAR-2 (s)	# Solved	PAR-2 (s)	# Solved	PAR-2 (s)	# Solved
GroundedGenerator (25)	0.43	25	0.5	25	0.38	25
SccGenerator (25)	759.64	19	1632.01	11	4.7	25
StableGenerator (25)	2280.09	2	2304.98	1	2123.62	22
AdmBuster (15)	568.49	12	967.23	9	9.45	15
ABA2AFs (25)	1.62	25	2.7	25	1.62	25
AFBenchGen2 (75)	718.99	52	843.2	49	306.57	57
Planning2AFs (25)	705.5	18	1091.34	15	0.01	25
SemBuster (15)	655.01	13	854.73	10	11.64	15
Traffic (25)	73.62	25	96.79	25	0.1	25
Logic-Based (25)	586.97	19	791.07	17	306.32	22
AFGen (17)	326.97	14	442.47	14	5.75	17
Crusti_g2io (32)	2400	0	2400	0	598.27	28

, there are three main families with difficult-to-solve problems: SccGenerator (25) (https://argumentationcompetition.org/2017/benchmark_selection_iccma2017.pdf, accessed on 3 August 2024), StableGenerator (25) (https://argumentationcompetition.org/2017/benchmark_selection_iccma2017.pdf, accessed on 3 August 2024), and Crusti_g2io (32) (https://helda.helsinki.fi/items/7c4a0bad-0604-44c5-b5cb-1a6a487fa8af, accessed on 3 August 2024). These three types of instances share two common characteristics that may have led to suboptimal solving performance, namely, the issues of randomness and community structure. Our algorithm leverages label characteristics to directly perform tree search on the problem, while SAT-based reduction methods encode the original problem into a SAT problem and then call a SAT solver. SAT-based methods may obscure some of the original problem’s information, so directly incorporating SAT techniques into the tree search for the original problem could be a key direction for future improvements.

• ArgTools_3lab: The basic Argtools solver which uses three labels.
• ArgTools_3lab+: Argtools solver with the preprocessing strategy applied.
• ArgTools_3lab++(ArgTools_4lab): Argtools solver with the proposed four-label method applied.
• ArgSemSAT: Stable extension solving algorithm based on the reduction model.

Figure 3 shows the results of the ArgTools_3lab+ and ArgTools_3lab solvers on the instances of the main track of ICCMA 2023, which include a total of 330 instances. Figure 3a displays the cactus plot for these two solvers on the above instances. Each point $(x,y)$ in the figure corresponds to the solving time for a specific instance, where the x-axis represents the runtime, and the y-axis represents the number of instances solved. From this, it can be concluded that preprocessing operations for solving instances, such as prioritizing initial and self-attacking arguments, can speed up labeling propagation efficiency.

Figure 3b shows the scatter plot for the instance families in the main track of ICCMA 2023. These instances are grouped into 17 families, with each family consisting of instances with similar names. A point $(x,y)$ in the figure represents an instance family, where x (y) denotes the average solving time of ArgTools_3lab+ (ArgTools_3lab) for each instance in the respective family. From Figure 3b, we can see that the preprocessing strategy of the four-label algorithm is effective across all instance families.

Similar to Figure 3, Figure 4 presents a comparison of the solving performance between the ArgTools_4lab and ArgTools_3lab+ solvers on the instances of the main track of ICCMA 2023. From the figure, it is evident that the four-label method is more effective in propagating argument labelings compared to the two-label and three-label methods. Additionally, the four-label labeling rules are generally effective across all instance families.

To further demonstrate that the four-label method proposed in this paper is not only applicable to the ArgTools solver mentioned in the article but also performs well in other labeling algorithms, we selected the DREDD solver by Matthias Thimm et al. (http://taas.tweetyproject.org, accessed on 3 August 2024), which participated in ICCMA 2019 and is also based on depth-first search for stable extensions. We then integrated the four-label method into the DREDD solver and tested the configured algorithm (DREDD_4lab) and the original DREDD algorithm on instances of the main track of ICCMA 2019 and ICCMA 2023. The comparison results are shown in

Table 3. Experiment results on the instances of the main track of ICCMA 2023 and the instances of ICCMA 2019.

Instances	Solver	# Solved	PAR-2 (s)
ICCMA 2019 (326)	DREDD	276	375.48
	DREDD_4lab	287	304.31
ICCMA 2021 (587)	DREDD	108	2118.3
	DREDD_4lab	113	2079.29
ICCMA 2023 329)	DREDD	146	1407.54
	DREDD_4lab	152	1376.84

.

• DREDD: The basic DREDD solver using three labels.
• DREDD_4lab: DREDD solver with the proposed four-label method applied.

In Table 3, we observe that DREDD_4lab shows a significant improvement in efficiency compared to the original DREDD algorithm. This indicates that, by introducing labels to differentiate between the nature of arguments in the DREDD_4lab algorithm, the cooperation among labels is enhanced, leading to faster labeling propagation and reduced search space. Therefore, we can conclude that the proposed four-label method is also applicable in other labeling-based solvers.

7. Conclusions and Future Work

This paper compares and analyzes two-label and three-label algorithms for solving stable extensions and proposes a four-label algorithm to address their limitations, aiming to enumerate all stable extensions of a given abstract argumentation framework more quickly. Meanwhile, the four-label algorithm has been experimentally validated and analyzed using benchmarks from ICCMA 2019, ICCMA 2021, and ICCMA 2023. The results demonstrate that this additional labeling approach significantly improves algorithm efficiency. Additionally, the four-label method was configured in some state-of-the-art solvers, proving its effectiveness in those contexts as well.

In future work, the new labeling strategy and preprocessing strategy proposed in this algorithm could still be applied to solving other semantic extension problems. Although the four-label algorithm significantly outperforms the previous two-label and three-label algorithms, there is still a gap compared to popular reduction-based methods. Therefore, in future work, these strategies can be encoded as SAT problems and combined with popular solvers to solve semantic extension problems more quickly. Additionally, when solving extensions, we can consider integrating conflict-driven clause learning mechanisms directly into the tree search framework, thereby designing a new solver specifically for abstract argumentation framework problems.