Dual-Neighborhood Tabu Search for Computing Stable Extensions in Abstract Argumentation Frameworks

Abstract

Abstract argumentation has become one of the important fields of artificial intelligence. This paper proposes a dual-neighborhood tabu search (DNTS) method specifically designed to find a single stable extension in abstract argumentation frameworks. The proposed algorithm implements an improved dual-neighborhood strategy incorporating a fast neighborhood evaluation method. In addition, by introducing techniques such as tabu and perturbation, this algorithm is able to jump out of the local optimum, which significantly improves the performance of the algorithm. In order to evaluate the effectiveness of the method, the performance of the algorithm on more than 300 randomly generated benchmark datasets was studied and compared with the algorithm in the literature. In the experiment, DNTS outperforms the other method regarding time consumption in more than 50 instances and surpasses the other meta-heuristic method in the number of solved cases. Further analysis shows that the initialization method, the tabu strategy, and the perturbation technique help guarantee the efficiency of the proposed DNTS.

1. Introduction

Formal argumentation has received widespread attention in research areas such as non-monotonic reasoning [1], communication in multi-agent systems [2], and semantic web reasoning [3]. Early research in these areas originated in the early 1990s. However, widespread academic attention was sparked by Dung’s theory of abstract argumentation frameworks [4], which marked an important developmental milestone in the field.

Dung’s theory of abstract argumentation frameworks provides a foundational model for the field of computational argumentation. This model has been widely applied in various domains such as multi-agent systems, decision support tools, and medical and legal reasoning. From this, computational argumentation has developed into an important branch of artificial intelligence research [5].

Dung [4] proposed a generic and highly abstract model of argumentation, which formalizes the argumentation framework as an abstract argumentation framework ($AF$), represented as $AF=(A,R)$, by defining arguments as vertices and attack relations between arguments as directed edges.

In this framework, a stable extension is defined as the set of arguments $E\subseteq A$ that satisfies the following conditions: (1) there is no attack relation between any arguments within E; and (2) all arguments in $AF$ that do not belong to E are attacked by at least one of the arguments in E. Figure 1 illustrates an example of a stable extension. In the illustration presented, set E consisting of red vertices is identified as a stable extension. Set E attacks all the arguments in the framework that are not contained in it, while the arguments within set E do not have any mutual attack relations between each other.

The purpose of this paper is to study the problem of finding a single stable extension in abstract argumentation frameworks, also called the SE-ST problem.

In the field of research on formal argumentation modeling, the problem of semantic parsing in the theory of abstract argumentation frameworks [6] is particularly prominent. The International Competition on Computational Models of Argumentation (ICCMA) has been launched specifically for this purpose, in order to promote this field of research. The competition consists of several competition tracks aimed at solving a series of related problems. The research in this paper is on one of its main tracks and focuses on exploring solution strategies for computing a single stable extension of an abstract argumentation framework.

Currently, algorithms for solving the stable extensions problem are mainly divided into two categories [7]: reduction-based approaches and direct approaches. Reduction-based approaches typically employ efficient existing solvers, such as SAT solvers [8], to transform abstract argumentation frameworks and stable extensions into a format that the solver can handle. In the main track of the International Competition on Computational Models of Argumentation (ICCMA), the majority of algorithms that perform outstandingly adopt reduction-based approaches, including the u-toksia [9] algorithm and the pyglaf [10] algorithm.

The other category is direct approaches, which provide solutions directly for arguments on the abstract argumentation framework. These methods are typically based on labeling theory [11]. This approach was pioneered by Pollock [12] and was later expanded by Caminada [11], Vreeswijk [13], and Verheij [14]. The most prominent variant is the 3-valued labelings proposed by Caminada and Gabbay [11]. The first labeling-based algorithm framework was proposed by Doutre and Mengin [15]. The core idea of labeling-based algorithms is that, once the label of an argument is determined, it immediately affects the potential labels of its adjacent arguments.

In recent years, most of the algorithms for computing stable extensions have been based on invoking SAT solvers or other types of solvers, with relatively fewer studies employing direct approaches. In research on solving abstract argumentation problems using local search approaches, Niu [16] and M. Thimm [17] have explored the use of stochastic local search methods. However, the work of Niu et al. focuses on solving the preferred extensions, and their approach conceptually differs from the present study. They operate on the CNF representation of the problem and apply the Swcca algorithm [18]. Therefore, their approach is essentially reduction-based rather than direct. The HAYWOOD algorithm proposed by M. Thimm in 2018 is a direct approach based on heuristic information for local search [19], mainly expanding the search space through a stochastic selection mechanism [20]. Similarly, the approach proposed in this paper also adopts a direct approach.

Due to the NP-hardness of the problem, the current algorithms that accurately determine whether a stable extension exists are all exponential in time complexity. Meta-heuristic approaches, such as tabu search, attempt to find solutions to NP-hard problems in polynomial time. Although they cannot guarantee a solution or prove its absence, meta-heuristics are more efficient in solving large-scale NP-hard problems than exact algorithms.

Tabu search enhances the performance of local search by relaxing the basic rules of local search. It forbids certain previously experienced operations by establishing a tabu list based on neighborhood search. Battiti [21] and Kelly [22] proposed two early variants of tabu search, which employ strategies to drive the search away from the current solution without using objective function thresholds. Glover [23] controls the objective function by setting tabu thresholds and employing a more comprehensive diversification strategy.

In this paper, we propose a dual-neighborhood tabu search algorithm (DNTS) to compute a single stable extension and introduce a perturbation technique. The main focus of this paper is on the efficiency of the algorithms in terms of time performance, while also conducting experiments on the number of correctly solved instances, comparing the performance of different algorithms on random instances.

The paper is organized as follows. In Section 2, we introduce preliminary definitions. Section 3 introduces the main framework of the proposed DNTS algorithm. Section 4 describes details of the DNTS algorithm. Section 5 presents the experiments, including parametric and comparative experiments. Section 6 presents analyses and discussion. Section 7 concludes the paper.

2. Preliminary Definitions

2.1. Argumentation Frameworks

Definition 1.

An abstract argumentation framework is denoted by a pair, $AF=(A,R)$, where A is a finite set of arguments and $R\subseteq A\times A$ is an attack relation built on set A.

For two arguments, a, $b\in A$, argument a is said to attack argument b if ($a,b$) $\in R$. Set $E\subseteq A$ attacks b if any argument in E attacks b. $\left\{a\right\}-$ refers to the set of arguments attacking the argument a.

In general, we depict $AF$ as a directed graph, where vertices denote arguments and edges denote attack relationships between arguments. Figure 2 illustrates a set of abstract argumentation frameworks.

Example 1.

Argumentation frameworks: $AF1=\left(\right\{a\},\{\left\}\right)$, there is only one argument node with no attack relationship; $AF2=\left(\right\{a,b\},\{(a,b)\left\}\right)$, two arguments, a and b, and a attacks b; $AF3=\left(\right\{a,b\},\{(a,b),(b,a)\left\}\right)$, denotes mutual attacks between arguments, a attacks b and b attacks a; $AF4=\left(\right\{a,b,c\},\{(a,b),(b,c)\left\}\right)$, comprising three arguments, a, b, and c, where a attacks b, b attacks c, and c is defended by a.

2.2. Stable Extension

Dung-style semantics define the sets of arguments that can jointly be accepted (extensions). A $\sigma$-extension refers to an extension under semantics $\sigma$ [24].

Definition 2

(A conflict-free set). Let an abstract argumentation framework be $AF=(A,R)$. Set $E\subseteq A$ is a conflict-free set if there do not exist $x,y\in E$, such that x attacks y or y attacks x. The set of all conflict-free sets of $AF$ is denoted by cf(AF).

Definition 3

(Acceptability of arguments). Let an abstract argumentation framework be $AF=(A,R)$. An argument $a\in A$ is acceptable with respect to the set of arguments $E\subseteq A$ if $\forall b\in A(b\notin E)$, and if b attacks a then E attacks b.

Definition 4

(An admissible set). Let an abstract argumentation framework be $AF=(A,R)$. Set $E\subseteq A$, E is an admissible set if $E\in$ cf(AF), and every argument within E is acceptable with respect to E. The admissible sets are denoted by adm(AF).

Definition 5

(A complete extension). Let an abstract argumentation framework be $AF=(A,R)$. Set $E\subseteq A$ is a complete extension if $E\in$ adm(AF) and every acceptable argument with respect to E belongs to E. The complete extensions are denoted by com(AF).

Definition 6

(A stable extension). Let an abstract argumentation framework be $AF=(A,R)$. Set $E\subseteq A$ is a stable extension if $E\in$ cf(AF) and $\forall a\in A$, and if $a\notin E$, then E attacks a. The stable extensions are denoted by stb(AF).

Definition 7

(A grounded extension). Let an abstract argumentation framework be $AF=(A,R)$. Set $E\subseteq A$ is a grounded extension if $E\in$ com(AF) and, for each $T\in$ com(AF), $T\not\subset E$. The grounded extension is denoted by grd(AF).

Figure 3 shows several instances of grounded extensions. In Figure 3a, the set $S=\left\{a\right\}$ is first obtained by performing a characteristic function call on the empty set, which contains the initial argument a. Subsequently, the characteristic function call is performed again on set S, resulting in the updated set $S=\{a,c\}$. When the characteristic function call continues on updated set S, the set remains unchanged as $S=\{a,c\}$. This indicates that a grounded extension $\{a,c\}$, has been obtained.

Following the same procedure, the grounded extension $\left\{a\right\}$ is obtained in Figure 3b. In Figure 3c, the grounded extension results in the empty set. For details of the theoretical basis and proof of this procedure, as well as details of the characteristic function, please refer to the literature [4].

There are various semantic extensions, such as the preferred extension and semi-stable extension. For further information, refer to the literature [4]. This paper specifically addresses the stable extension.

2.3. Stable Labelings

We incorporate a labeling-based algorithm in the proposed method. A labeling is a function L: $Arg\to \{in,out,undec\}$ that assigns a label to each argument to indicate the current state of the argument. For the classical 3-valued labelings approach, in signifies acceptance of the argument, out denotes rejection of the argument, and undec indicates the argument’s status as undecided.

Definition 8.

Given an $AF=(A,R)$ and L is considered as a complete labeling, if for any $a\in A$ satisfy:

1. $L\left(a\right)=ins.t.\forall b\in \left\{a\right\}-:L\left(b\right)=out$;

2. $L\left(a\right)=outs.t.\exists b\in \left\{a\right\}-:L\left(b\right)=in$;

3. $L\left(a\right)=undecs.t.\forall b\in \left\{a\right\}-:L\left(b\right)\ne in\wedge \exists c\in \left\{a\right\}-:L\left(c\right)=undec$.

With Definition 8, it follows that a is legally labeled in if and only if all its attackers are labeled out. If a is legally labeled as out if there is at least one attacker labeled as in. a is legally labeled as undec then it has at least one attacker that is labeled as undec and it does not have an attacker that is labeled as in.

It has been proved in the literature [11] that complete labeling and stable labeling are related as follows in Theorem 1.

Theorem 1.

Given an $AF=(A,R)$ and a labeling L. The following statements are equivalent:

1. L is a complete labeling such that $undec\left(L\right)=\varnothing$;

2. L is a stable labeling.

Therefore, the solution for stable labelings relies only on the use of the labels in and out. A stable labeling is a set of labels that all arguments are legally labeled. Then the corresponding in(L), the set of arguments labeled as in, is also called the corresponding stable extension.

Figure 4 illustrates an example of stable labelings. In the left abstract argumentation framework, the labels of the arguments $a,b,c,d$ are incorrect according to the first rule in Definition 8; the labels of the arguments $f,g$ are also incorrect according to the second rule in Definition 8. Thus, only the label of parameter e is identified as correct. On the right-hand side, the labels of all arguments satisfy Definition 8, i.e., it is a stable labeling. Arguments $b,d,f$ labeled in form a stable extension.

Based on Definition 8 and Theorem 1, we can summarize the overall idea of our algorithm. First, we use only in and out labels in our algorithm to label the argument states. Then, we keep modifying the mislabeled arguments by the first and second provisions of Definition 8 until there are no mislabeled arguments. At this point, all the labels of the arguments are legal and no undec label satisfies the criteria of Theorem 1, and we can obtain a stable labeling. Then we output the set labeled in.

3. Main Framework of DNTS

HAYWOOD [17] implements a local search algorithm with stochastic selection and restart operations to calculate the stable extension. Inspired by HAYWOOD, this paper proposes the DNTS algorithm. The algorithm uses a meta-heuristic strategy that makes local search-based and integrates two neighborhood moves operators to extend the search space. Further, by adding a tabu strategy and perturbation technique, the DNTS algorithm optimizes the search process by effectively stepping out of the local optimum.

We implement Definition 8 through the function $definition$ but excluding the label undec. If an argument is labeled as in, then all arguments attacking it must be labeled as out. If an argument is labeled as out, then at least one of the arguments attacking it must be labeled out.

The function $\delta$ is designed to determine if the argument v is incorrectly labeled under L. The correctness is judged on the basis of $definition$. The $\delta$ function returns 0 if the label is correctly labeled or 1 if it is not.

$$\delta (v,L)=\left\{\begin{array}{c}0,ifdefinition(v,L)istrue\hfill \\ 1,ifdefinition(v,L)isfalse\hfill \end{array}\right.$$

(1)

On this basis, the DNTS algorithm proposed in this paper minimizes the following objective function:

$$F\left(L\right)=\sum _{v\in V}\delta (v,L)$$

(2)

The current labeling L represents a stable labeling if $F\left(L\right)=0$. The objective function computes the number of incorrectly labeled arguments given a known labeling L.

In this paper, we introduce a tabu search approach to search for a stable labeling. The search space of the proposed DNTS algorithm consists of all possible labelings including infeasible ones.

Algorithm 1 illustrates the main framework of our proposed DNTS algorithm, implementing a local search strategy for the SE-ST problem. It receives an input of abstract argumentation framework $AF$ and outputs stable labeling $L^{*}$ if it finds one.

The algorithm begins with an initialization phase, followed by a tabu search phase.

Algorithm 1 Main framework of the DNTS algorithm

INPUT:  $AF(A,R)$ OUTPUT:  A stable labeling $L^{*}$   1: procedure LS_DNTS   2:     $perturbIter\leftarrow 0$, $iter\leftarrow 0$,   3:     $(L,mislabel)\leftarrow INITIALISATION\left(AF\right)$   4:     $L^{*}\leftarrow L$   5:     $F_{best}\leftarrow mislabel\text{\_}number\left(mislabel\right)$   6:     repeat   7:           if $F\left(L^{*}\right)=0$ then   8:              return $L^{*}$   9:           end if 10:           for $v\in mislabel$ do 11:              $NEIGHBOREVALUATE(v,L^{*})$ 12:          end for 13:          repeat 14:              $bestv\leftarrow SELECTMIN\left(EvaluateHeap\right)$ 15:          until $tabutable\left(bestv\right)<iter$ 16:          $L^{*}\leftarrow EXECUTINGMOVE(bestv,iter,L^{*})$ 17:          $(F_{best},mislabel)\leftarrow UPDATEMISLABEL\left(L^{*}\right)$ 18:          $(perturbIter,L^{*})\leftarrow DISTURB\text{\_}RAND(perturbIter,F_{best},L^{*})$ 19:          $iter\leftarrow iter+1$ 20:     until termination condition 21: end procedure

In Algorithm 1, the initialization takes place from lines 2 to 5. During the initialization phase, variables $iter$ and $perturbIter$, $F_{best}$, labeling L and $L^{*}$, and the set $mislabel$ are initialized. Notations $iter$ denotes the iteration count of the local search procedure, and $perturbIter$ is the maximum iteration count before triggering the perturbation technique. $mislabel$ stores all mislabeled arguments. $F_{best}$ denotes the best objective value found during the local search.

With the function $INITIALISATION$, we obtain the initial L and $mislabel$. Then we assign L to $L^{*}$ and obtain the initial $F_{best}$ via set $mislabel$.

Subsequently, the algorithm enters the tabu search phase where the target set is identified through a series of search and flip moves. If the modified set of labels $L^{*}$ meets the conditions for stable labeling, where all labels comply with Definition 8, all arguments labeled in form a stable extension and the result is output; otherwise, the process repeats until the termination condition is met. If there are mislabeled arguments, the algorithm iterates through them, conducts neighborhood evaluations, and generates the evaluation heap $EvaluateHeap$ (detailed in Section 4.3). The top non-tabu argument from the heap is chosen to be flipped. If the top one is tabu, we simply pop it and select the next one. After the move, the current labeling is modified to be $L^{*}$. The set of mislabeled arguments $mislabel$ and $F_{best}$ are updated accordingly. The $DISTUB\text{\_}RAND$ procedure determines the need for a perturbation operation, which, if necessary, updates the $L^{*}$ set and adjusts the $perturbIter$ value.

The termination condition can be a maximum number of iterations or a runtime limit.

4. Algorithm Details

This section presents the details of the algorithm design, i.e., the neighborhood structure, the evaluation of the neighborhood move, the tabu strategy, and the perturbation technique.

4.1. Initialisation

The design of the initialization phase is based on the relationship between the grounded extension and the stable extension. If the grounded extension is not empty, it is always included in the stable extension. Thus identifying the grounded labeling before solving for stable labeling constitutes an efficient strategy. The derivation of the grounded extension depends on initial arguments, which are not attacked by any other arguments. These initial arguments are obtained by calling the $characteristicfunction$ on the empty set. Dung [4] defines the grounded extension as the least fixpoint of the $characteristicfunction$. In the iterative flipping process, argument labels within the grounded extension remain unchanged. The arguments attacked by the arguments in the grounded extension must be labeled out. We store this information in set $Grounded$.

Algorithm 2 details the initialization sub-procedure in Algorithm 1. The initial labeling L is formed by randomly assigning in or out labels to all arguments not belonging to set $Grounded$. Set $mislabel$ contains all arguments that are incorrectly labeled according to Definition 8. $Grounded$ stores the labels of the grounded extension as well as the labels of arguments attacked by the grounded extension.

Algorithm 2 Initialisation

INPUT:  $AF(A,R)$ OUTPUT:  $L,mislabel$   1: procedure Initialisation   2:     $Grounded\leftarrow calculateGrounded\left(AF\right)$   3:     for i = $1...N$ do   4:         if $i\in Grounded$ then   5:            $continue$   6:         end if   7:         $l\left(i\right)\leftarrow$RandomLabel($in,out$)   8:     end for   9:     $mislabel\leftarrow GetMislabel\left(L\right)$ 10: end procedure

4.2. Definition of Neighborhood Moves

L can be represented as a set pair $(IN,OUT)$. Here, $IN$ = in(L) is the set of arguments labeled as in, and $OUT$ = out(L) is the set of arguments labeled as out. The neighborhood moves of the DNTS algorithm consist of two types: one is to move an argument from $IN$ to $OUT$, and the other is to move an argument from $OUT$ to $IN$.

According to Definition 8 for legal in and out labels, we only adjust for mislabeled arguments. Figure 5 provides a specific example of this process. In this example, the function $flip\left(v\right)$ is defined to flip the label of the current argument v. If $L\left(v\right)$ = in, it flips to out; conversely, if $L\left(v\right)$ = out, it flips to in.

In Figure 5, the initial state $IN=\{a,b\}$, $OUT=\{c,d,e\}$. According to Definition 8 for legal in and out labels, we identify and flip the labels of mislabeled arguments. First, by performing neighborhood move (1), we move argument a from $IN$ to $OUT$, flipping its label from in to out. Next, neighborhood move (2) moves argument e from $OUT$ to $IN$, achieving the flip of argument e’s label from out to in. In the following sub-section, we detail how to evaluate moves.

4.3. Neighborhood Evaluation

To quantify the impact of different neighborhood moves on the objective function, we introduce function $P\left(vL\right)$, measuring the correctness of argument v under the labeling L. This involves assessing the contribution of the move in optimizing the objective function. Based on this evaluation, the most optimal neighborhood move is determined and selected for implementation. The function P is defined as follows:

$$P(v,L)=CorrectSelf(v,L)+CorrectNeighbors(v,L)$$

(3)

$$CorrectSelf=\delta (v,L)$$

(4)

$$CorrectNeighbors=\sum _{u\in Neighbors\left(v\right)}\delta (u,L)$$

(5)

The evaluation function P consists of $CorrectSelf$ and $CorrectNeighbors$. $CorrectSelf$ calculates the correctness of labeling a selected argument v with label $L\left(v\right)$ under the labeling L. $CorrectNeighbors$ calculates the correctness of the neighbors of v, i.e., u when argument v is labeled with $L\left(v\right)$. The criterion for evaluating the quality of a neighborhood move is $\Delta P$.

$$\Delta P\left(v\right)=P(v,L^{*})-P(v,L)$$

(6)

The altered labeling $L^{*}$ arises from applying the function $flip\left(v\right)$ to the current labeling L. Lower values of $\Delta P$ indicate higher quality of neighborhood moves. If $\Delta P$ is negative, it improves the configuration, and, conversely, if $\Delta P$ is positive, it deteriorates it. By calculating the evaluation function values for the current argument under different labels, the impact of executing the neighborhood move on the objective function can be assessed. Without involving any other operations, the algorithm selects the neighborhood move that minimizes the $\Delta P$ value for execution.

Taking Figure 6 as an example, this paper elucidates the key steps in problem solving. We assume the labeling L is as follows.

$L\left(A\right)$ = in, $L\left(B\right)$ = in, $L\left(C\right)$ = in, $L\left(D\right)$ = out, $L\left(E\right)$ = in

During the analysis, based on Definition 8, we identified that the label assignments for arguments B and C are incorrect. According to the first clause of Definition 8, all arguments attacking an argument labeled as in should be labeled out. Hence, the label assignments for B and C are erroneous. Next, we calculate the $\Delta P$ of the incorrectly labeled arguments.

Calculate the $\Delta P$ of B:

$$\Delta P\left(B\right)=P(B,L^{*})-P(B,L)=-2$$

Calculate the $\Delta P$ of C:

$$\Delta P\left(C\right)=P(C,L^{*})-P(C,L)=0$$

Argument B is used as an example to illustrate the calculation process. First, $P(B,L)$ evaluates the correctness of argument B under the current label in according to Definition 8. By assessing the correctness of its own and its neighbors under the current label, it is determined that B is mislabeled and C is correctly labeled, hence $P(B,L)=2$. $P(B,L^{*})$ evaluates the correctness of argument B under the flipped label out. At this juncture, the label of B is correct and the label of C is correct, resulting in $P(B,L^{*})=0$, leading to a $\Delta P\left(B\right)=-2$.

Subsequently, based on the calculated results, a greedy selection strategy is employed to operate on the argument with the smallest $\Delta P$ value.

4.3.1. Pseudo-Code for Neighborhood Move Evaluation

Algorithm 3 illustrates the neighborhood evaluation process. This process receives an incorrectly labeled argument, v, and the current labeling L as inputs. By flipping the label of argument v, we obtain the updated labeling $L^{*}$. Subsequently, an effectiveness evaluation is conducted by comparing the differences in the evaluation function between the original and the updated labeling.

The evaluation process is divided into two steps: first, assessing the impact of the label flip on the argument v itself, and then evaluating its effect on neighboring arguments. The variable $\Delta P$ records these impacts for determining the effectiveness of the label flip. Obviously, the key to the process is not only to evaluate the quality of the label after the flip of the argument itself but also to consider its impact on neighboring arguments. The efficiency of the neighborhood evaluation has a direct impact on the overall performance of the algorithm, while the complexity of the neighborhood structure determines the speed of execution of the evaluation. One of the main advantages of using the labeling approach is that it simplifies the interactions between neighbors, which improves the execution efficiency of the algorithm. The time complexity of this module is $O\left(\right|u|+logN)$, where N is the total number of arguments.

Algorithm 3 Neighborhood evaluation

INPUT:  $v,L$   1: procedure NEIGHBOREVALUATE   2:     $\Delta P\leftarrow 0$   3:     $L^{*}\leftarrow filp\left(v\right)$   4:     $\Delta P\leftarrow \Delta P-\delta (v,L)$   5:     $\Delta P\leftarrow \Delta P+\delta (v,L^{*})$   6:     for $u\in Neighbors\left(v\right)$ do   7:         $\Delta P\leftarrow \Delta P-\delta (u,L)$   8:         $\Delta P\leftarrow \Delta P+\delta (u,L^{*})$   9:     end for 10:     $HeapInsert(v,\Delta P)$ 11: end procedure

4.3.2. Fast Neighborhood Evaluation

In the main framework of the local search described in Section 3, we begin each iteration by evaluating all incorrectly labeled arguments within the mislabeled set $mislabel$. However, after executing the chosen argument label flip, only the correctness of the labels of the neighboring arguments to the argument is affected. This means that, in the next round of evaluation, we only need to assess the neighboring arguments to the flipped argument and then insert the results into the heap according to the magnitude of the evaluation values. In subsequent iterations, this operation alone is required, without the need to traverse all incorrectly labeled arguments, significantly enhancing our search efficiency.

In the DNTS algorithm, we also use the fast neighborhood evaluation. Algorithm 4 replaces lines 10 to 12 of Algorithm 1.

Algorithm 4 Fast neighborhood evaluation

INPUT:  $v,L,mislabel$ OUTPUT:  $EvaluateHeap$   1: procedure FastNeigborEvaluate   2:     if $definition(v,L)isflase$ and $l\left(v\right)\ne Grounded\left(v\right)$ then   3:         $AddToMislabel\left(v\right)$   4:         $NEIGHBOREVALUATE(v,L)$   5:     else   6:         $MislabelRemove\left(v\right)$   7:     end if   8:     for $u\in Neighbors\left(v\right)$ do   9:         if $definition(u,L)isflase$ and $l\left(u\right)\ne Grounded\left(u\right)$ then 10:            $AddToMislabel\left(u\right)$ 11:            $NEIGHBOREVALUATE(u,L)$ 12:         else 13:            $MislabelRemove\left(u\right)$ 14:            $HeapRemove\left(u\right)$ 15:         end if 16:     end for 17: return $EvaluateHeap$ 18: end procedure

Algorithm 4 illustrates the process of fast neighborhood move evaluation. First, we individually check the correctness of the argument label $L\left(v\right)$ after performing the optimal neighborhood move according to $definition$. If the label is incorrect and the argument is not a part of the grounded extension, it is added to the set of incorrectly labeled arguments $mislabel$ via the function $AddToMislabel$ and evaluated. If the labeling is correct, it is removed from $mislabel$ via the function $MislabelRemove$. The algorithm checks the correctness of the label for each argument in the neighboring argument set u of argument v. If any label is incorrect, it is added to the set of incorrectly labeled arguments $mislabel$ and evaluated. If it is correct, it is removed from $mislabel$ and from the evaluation heap $EvaluateHeap$. Eventually, the evaluation heap $EvaluateHeap$ is returned. The time complexity of this module is $O\left(\right|u{|}^2+\left|u\right|logN)$, and its space complexity is $O\left(N\right)$.

4.4. Neighborhood Move Execution

During the evaluation process, the algorithm evaluates the arguments based on their labeled flips and inserts the evaluation results sequentially into a heap data structure. The top element of the heap thus represents the current optimal choice, i.e., the argument that needs to be flipped. After completing the neighborhood move selection, the argument is removed from the heap and the heap structure is readjusted to maintain the ordering by evaluation result. The neighborhood move is then executed to flip the label of that argument. Specifically, the selected argument label is flipped to out if it is in, or to in if it is out.

Algorithm 5 explains how a move is implemented. The top element of the heap represents the argument with the smallest evaluation value ($\Delta P$), and it is implemented by flipping the label of that argument. After selecting the argument for which a neighborhood move is to be executed, the label of that argument is first identified and then the corresponding flip operation is executed.

After flipping the label of the selected argument, we make the neighborhood move tabu through the function $TabuAction$. The tabu search algorithm utilizes the tabu strategy to implement a memory function in the search process, marking explored local optima and avoiding these solutions for a subsequent period. This memory and tabu functionality not only enhances the effect of local search but also helps to prevent the search process from becoming trapped in local optima, thereby facilitating the discovery of global optimal solutions. Specifically, after each flip operation, the involved arguments are temporarily tabued to prevent them from being flipped again in the short term. The details will be illustrated in Section 4.5.

Setting the tabu length too long may result in missing the opportunity to flip a key argument, which in turn wastes a lot of time, while setting it too short may cause the argument to be unblocked too quickly, leading the algorithm to fall into a local loop. Therefore, the tabu length has a significant impact on the performance of the algorithm, and the determination of the tabu length needs to rely on extensive experimental research.

Algorithm 5 Executing Move

INPUT:  $v,iter,L$ OUTPUT:  L   1: procedure EXECUTINGMOVE   2:     if $L\left(v\right)isin$ then   3:         $L\left(v\right)$$\leftarrow change\text{\_}label(v,out)$   4:         $TabuAction(v,out,iter)$   5:     else $L\left(v\right)isout$   6:         $L\left(v\right)$$\leftarrow change\text{\_}label(v,in)$   7:         $TabuAction(v,in,iter)$   8:         for $u\in Neighbors\left(v\right)$ do   9:            if $L\left(v\right)isinandl\left(v\right)\ne Grounded\left(u\right)$ then 10:                $L\left(u\right)$$\leftarrow change\text{\_}label(u,out)$ 11:            end if 12:         end for 13:     end if 14: return L 15: end procedure

Any argument attacking a in labeled argument should be labeled as out; in labeled arguments cannot attack other in labeled arguments. Therefore, after executing a neighborhood move, the algorithm further modifies the neighbors of the moved argument. When the label of an argument is flipped from out to in, we uniformly flip all the neighboring argument labels of that argument to out. The time complexity of this module is $O\left(\right|u\left|\right)$.

4.5. Adaptive Tabu Strategy

In order to enlarge the search space and effectively avoid falling into local optimums, this algorithm introduces a tabu search strategy.

We denote by $tl1$ the length of the tabu for an argument to flip from $IN$ to $OUT$ and by $tl2$ the length of the tabu for an argument to flip from $OUT$ to $IN$, respectively. In the presence of a large number of mislabeled arguments, the algorithm may need to go through a higher number of iterations to reach a local optimum; on the contrary, when there are fewer mislabeled arguments, fewer iterations may achieve a local optimum. Therefore, employing a regulation mechanism based on the number of mislabeled arguments to determine the tabu length is a more rational choice. Thus, the tabu length’s parameters $tl1$ and $tl2$ are adjusted based on the current number of mislabeled arguments, with specific details provided in the parameter introduction in Section 5.1.

Algorithm 6 illustrates its main steps as tabu action. First, we identify whether the neighborhood move executed is a flip from out to in, or from in to out, and then we identify in the tabu table $tabutable$ how long the argument needs to be tabued, i.e., the length of the tabu.

Algorithm 6 TabuAction

INPUT:  $v,move,iter$ OUTPUT:  $tabutable$ 1: procedure TabuAction 2:     if $moveisout$ then 3:         $tabutable\left(v\right)$=$iter+tl1$ 4:     else $moveisin$ 5:         $tabutable\left(v\right)$=$iter+tl2$ 6:     end if 7: return $tabutable$ 8: end procedure

4.6. Perturbation Technique

The DNTS algorithm proposed in this paper implements a perturbation technique in cases where the prolonged search fails to improve the quality of labeling significantly.

The technique periodically applies a random perturbation to the labeling, whose triggering conditions depend on the search history and the perturbation period ($perturbPeriodt$). Its purpose is to free the current solution from the local optimum and explore more of the solution space. The perturbation involves a series of move combinations that are randomly exchanged. Specifically, it flips some of the out labels of the argument into in labels, with the parameter details introduced in Section 5.1.

Algorithm 7 gives the pseudo-code for $DISTURB\text{\_}RAND$, where $F_{best}$ is the historical optimal value reached by the objective function during the iteration process. After executing a label flip, the value of $perturbIter$ will be increased if the current objective function value $F\left(L\right)$ fails to fall below $F_{best}$, otherwise $perturbIter$ is set to 0 to reflect the finding of new optimal labeling.

Algorithm 7 Adaptive perturbation

INPUT:  $F_{best},L,perturbPeriodt$ OUTPUT:  $L^{*}$   1: procedure DISTURB_RAND   2:     if $F\left(L\right)\ge F_{best}$ then   3:         $perturbIter$$\leftarrow perturbIter+1$   4:     else   5:         $perturbIter$$\leftarrow 0$   6:     end if   7:     if $perturbIter>perturbPeriodt$ then   8:         $L^{*}$$\leftarrow disturb\text{\_}rand\left(L\right)$   9:     end if 10: return $L^{*}$ 11: end procedure

5. Experiment

The experimental design of this paper is divided into two parts: parametric and comparative experiments. In the parametric experiment phase, the evaluation metric was solely the running time. However, in the comparative experiment phase, both the running time and the number of correctly solved instances were evaluated. However, both the parametric and comparison experiments used the AFGen benchmark generator to generate different test instances. The number of correctly solved instances is defined as the number of instances that can be successfully solved correctly within the time limit of 600 s. According to the ICCMA evaluation rules, solving an instance with an incorrect result and failing to solve the instance in less than 600 s will be considered a failure.

The DNTS algorithm is implemented in C and tested on a desktop computer equipped with an Intel(R) Xeon(R) W-2235 CPU at 3.80 GHz, with 16.0 GB of RAM. The operating system is Ubuntu 18.04.

In this paper, we use the AFGen benchmark generator provided by ICCMA to randomly generate experimental instances of different sizes. The maximum size of one of the instances can be up to 650,000 edges. To ensure the diversity of the instances, each directed graph (AF) is checked for isomorphism by Nauty to exclude repeated instances. The generated instances contain vertex sets and edge sets.

AFGen is not the only generator used to generate instances, ICCMA also provides other instance generators as well as instances used for competitions. However, the AFGen generator produces the most randomized instances. In this paper, we mainly test the performance of the algorithm on randomized instances, and therefore we chose AFGen to generate instances for testing.

5.1. Calibration

In this section, preliminary experiments are conducted to determine the key parameter values of the DNTS algorithm.

For the parametric experiments, 30 instances were randomly generated for testing. The number of arguments ranged from 500 to 4000, and the number of edges ranged from 1000 to 250,000. By evaluating a large number of parameter combinations, 64 sets of parameters were finally selected for precise efficacy testing. To ensure reliable results, five tests were conducted for each parameter set. The best, worst, and average running times in seconds were then computed from these test results to evaluate the performance.

We tested the following parameters:

$DisturbPeriod$: perturbation periods are divided into two types: dynamic and static periods. Dynamic perturbation periods include $\left|A\right|$ and $14\left|A\right|$, where $\left|A\right|$ signifies the total number of arguments in the instance, and $14\left|A\right|$ is the setting of the restart parameter in the Haywood algorithm. Although this parameter hardly ever triggers the mechanism it is set for, it was shown to have the most significant effect in the HAYWOOD algorithm; hence, this experiment opts for an equivalent parameter as the perturbation period for testing. The static perturbation periods are 2000 and 8000.

$DisturbLevel$: the perturbation levels are set to four levels: 0.01, 0.0025, 0.00125, and 0.001. For example, when the perturbation level is 0.01 and the number of global arguments is 4000, 40 out of the 4000 arguments are perturbed every time the perturbation condition is met.

$tl$: the tabu length is set to include four combinations $tl1=4,tl2=2$; $tl1=4,tl2=4$; $tl1=6,tl2=4$, and $tl=6,tl2=6$. For example, if the number of mislabeled arguments is 20 and $tl1=4,tl2=4$, the tabu length is set to one-quarter of the number of arguments, i.e., 5.

Note that this experiment does not guarantee the optimal values of the parameters, and the optimal scheme may vary from one benchmark to another.

The analysis of data from

Table 1. Experimental results for the calibration.

$\mathit{DisturbPeriod}$	$\mathit{DisturbLevel}$	$\mathit{tl}1$	$\mathit{tl}2$	Best	Worst	Average
$\left|A\right|$	0.01	4	2	498.37	713.4	609.092
$\left|A\right|$	0.01	4	4	783.82	1118.67	884.91
$\left|A\right|$	0.01	6	4	526.53	907.49	727.28
$\left|A\right|$	0.01	6	6	572.59	1119.43	763.35
$\left|A\right|$	0.0025	4	2	748.61	869.94	821.38
$\left|A\right|$	0.0025	4	4	537.06	1034.21	759.91
$\left|A\right|$	0.0025	6	4	625.05	974.94	750.57
$\left|A\right|$	0.0025	6	6	598.04	782.81	655.49
$\left|A\right|$	0.00125	4	2	887.08	1007.93	929.67
$\left|A\right|$	0.00125	4	4	491.88	546.52	527.54
$\left|A\right|$	0.00125	6	4	530.28	1107.77	822.3
$\left|A\right|$	0.00125	6	6	560.85	691.76	619.64
$\left|A\right|$	0.001	4	2	961.31	1328.85	1049.92
$\left|A\right|$	0.001	4	4	578.56	942.9	842.42
$\left|A\right|$	0.001	6	4	867.07	901.54	887.32
$\left|A\right|$	0.001	6	6	885.43	1310.33	1064.99
14$\left|A\right|$	0.01	4	2	493.36	1098.75	686.89
14$\left|A\right|$	0.01	4	4	598	2138.62	1070.86
14$\left|A\right|$	0.01	6	4	563.31	931.99	699.97
14$\left|A\right|$	0.01	6	6	571.73	1378.23	857.24
14$\left|A\right|$	0.0025	4	2	753.85	1094.87	870.79
14$\left|A\right|$	0.0025	4	4	667.62	1402.25	976.12
14$\left|A\right|$	0.0025	6	4	559.07	970.37	659.72
14$\left|A\right|$	0.0025	6	6	517.71	1248.42	834.15
14$\left|A\right|$	0.00125	4	2	875.8	1182.45	982.33
14$\left|A\right|$	0.00125	4	4	613.45	2164.91	1158.9
14$\left|A\right|$	0.00125	6	4	575.3	638.43	606.43
14$\left|A\right|$	0.00125	6	6	539.9	1744.79	893.24
14$\left|A\right|$	0.001	4	2	839.75	1304.88	1015.3
14$\left|A\right|$	0.001	4	4	897.97	1269.52	1033.56
14$\left|A\right|$	0.001	6	4	892.8	1132.67	1002.72
14$\left|A\right|$	0.001	6	6	936.85	1564.24	1130.73
2000	0.01	4	2	520.68	726.94	622.13
2000	0.01	4	4	672.81	1289.86	902.94
2000	0.01	6	4	589.02	887.46	665.27
2000	0.01	6	6	629.85	1274.51	822.14
2000	0.0025	4	2	804.39	1074.58	919.29
2000	0.0025	4	4	679.78	1011.3	835.49
2000	0.0025	6	4	895.34	1076.88	945.9
2000	0.0025	6	6	585.87	1102.71	784.46
2000	0.00125	4	2	838.07	1152.28	1018.12
2000	0.00125	4	4	576.31	1133.41	792.79
2000	0.00125	6	4	515.6	824.22	625.21
2000	0.00125	6	6	549.93	866.76	759.66
2000	0.001	4	2	893.92	1051.53	977.36
2000	0.001	4	4	921.28	1115.36	1053.87
2000	0.001	6	4	901.14	1106.72	983.8
2000	0.001	6	6	850.88	1047.12	1033.94
8000	0.01	4	2	530.02	787.72	687.41
8000	0.01	4	4	603.07	1116.43	838.08
8000	0.01	6	4	522.51	606.95	543.14
8000	0.01	6	6	553.83	1057.55	786.53
8000	0.0025	4	2	883.28	943.8	916.21
8000	0.0025	4	4	525.61	808.93	628.24
8000	0.0025	6	4	557.59	678.45	610.19
8000	0.0025	6	6	593.92	683.44	649.73
8000	0.00125	4	2	855.89	1017.46	934.42
8000	0.00125	4	4	583.19	881.29	722.35
8000	0.00125	6	4	509.32	810.09	622.09
8000	0.00125	6	6	839.9	1222.42	945.88
8000	0.001	4	2	844.47	1061.15	953.9
8000	0.001	4	4	931.3	1162.98	989.34
8000	0.001	6	4	854.5	1029.2	962.8
8000	0.001	6	6	814.32	1347.12	1033.09

reveals that the DNTS algorithm demonstrates relative stability in its best values. However, it exhibits significant fluctuations in its worst values. Notably, the average values tend to be closer to the best values in the majority of cases.

Among the four sets of perturbation period settings, the $14\left|A\right|$ setting performs the worst. In the four sets of perturbation level settings, we find that long perturbation periods need to be matched with large perturbation levels, and short perturbation periods need to be matched with small perturbation levels. The tabu length effect is more randomized and can show good or bad results with different parameters. Based on these observations, we screened a set of more stable and efficient parameters for subsequent comparison experiments.

DNTS: $DisturbPeriod=\left|A\right|,DisturbLevell=0.00125,tl1=4,tl2=4$

5.2. Algorithm Comparison

This section evaluates the performance of the DNTS algorithm against other algorithms in terms of running time and number of correctly solved instances through comparative experiments.

The compared algorithms include u-toksia [9] and HAYWOOD [17].

Other algorithms based on the SAT solver, such as pyglaf [10] and dpdb [25], which excel in structured instances, exhibit poor performance in random instances. Consequently, u-toksia was selected for comparison. As a notable representative in ICCMA competitions, u-toksia has participated in several consecutive events. It achieved overall first place in the main track of the 2019 and 2021 ICCMA competitions. u-toksia did not achieve the top rank in the 2021 SE-ST project, with dpdb taking the lead. However, u-toksia performance in handling random instances significantly outperforms other higher-ranked algorithms such as dpdb. Regarding Haywood, multiple versions exist, and this experiment selects the best-performing HAYWOOD-4 version for demonstration.

5.2.1. Comparison on Algorithm Efficiency

In this sub-section, five groups of instances are generated for the experiment, each containing 20 instances with the same number of vertices but different numbers of edges, totaling 100 instances. The number of arguments were set at 500, 1000, 2000, 3000, and 4000, and the range of edges for each group of instances were 4000 to 10,000, 8,000 to 50,000, 20,000 to 160,000, 60,000 to 350,000, and 240,000 to 640,000, respectively. In solving random instances, the speed of solving is not exactly proportional to the size of the instances, but the general trend shows that the larger the size of the instances is, the longer is the time required for solving.

The purpose of establishing benchmarks is to evaluate the time efficiency of algorithms in solving instances. This ensures that all reference algorithms can find the stable extension for each instance, allowing for fair comparison. For each algorithm, 10 runs are conducted to record the best, worst, and average run times. Additionally, the average total time (att) for solving all instances across three categories is computed. All timings are reported in seconds.

If the algorithm fails to find a stable extension within 600 s, despite the existence of a stable extension, the algorithm will report that it cannot find a stable extension in this instance. This is the nature of local search-based meta-heuristics. If it fails to find a feasible solution, it cannot guarantee that there is no feasible one.

Based on the results presented in

Table 2. Experimental results for instances of 500 vertices.

		DNTS			HAYWOOD			u-toksia
Instance	Best	Worst	Average	Best	Worst	Average	Best	Worst	Average
V500_1	0.07	0.12	0.1	0.07	0.12	0.08	0.02	0.02	0.02
V500_2	0.12	0.12	0.12	0.12	0.12	0.12	0.02	0.02	0.02
V500_3	0.07	0.12	0.1	0.07	0.07	0.07	0.02	0.02	0.02
V500_4	0.07	0.07	0.07	0.07	0.07	0.07	0.02	0.02	0.02
V500_5	0.12	0.12	0.12	0.12	0.12	0.12	0.02	0.02	0.02
V500_6	0.07	0.12	0.11	0.12	0.12	0.12	0.02	0.02	0.02
V500_7	0.12	0.12	0.12	0.12	0.12	0.12	0.02	0.02	0.02
V500_8	0.07	0.07	0.07	0.07	0.07	0.07	0.02	0.02	0.02
V500_9	0.07	0.07	0.07	0.07	0.07	0.07	0.02	0.02	0.02
V500_10	0.07	0.12	0.1	0.07	0.07	0.07	0.02	0.02	0.02
V500_11	0.07	0.07	0.07	0.07	0.07	0.07	0.01	0.02	0.02
V500_12	0.07	0.07	0.07	0.07	0.07	0.07	0.02	0.02	0.02
V500_13	0.07	0.07	0.07	0.07	0.07	0.07	0.02	0.02	0.02
V500_14	0.12	0.12	0.12	0.12	0.12	0.12	0.02	0.03	0.02
V500_15	0.07	0.12	0.11	0.12	0.12	0.12	0.02	0.04	0.02
V500_16	0.07	0.12	0.11	0.12	0.12	0.12	0.02	0.04	0.02
V500_17	0.07	0.12	0.1	0.07	0.07	0.07	0.02	0.03	0.02
V500_18	0.12	0.12	0.12	0.12	0.12	0.12	0.02	0.02	0.02
V500_19	0.07	0.07	0.07	0.07	0.07	0.07	0.01	0.02	0.02
V500_20	0.07	0.07	0.07	0.07	0.07	0.07	0.01	0.02	0.01
Att	0.08	0.1	0.09	0.09	0.09	0.09	0.02	0.02	0.02

, the u-toksia algorithm performs particularly well in the performance evaluation of the smallest-scale random instances generated for 500 arguments. The time to solve the instances is mostly measured in microseconds, showing its significant advantage in handling small-sized instances. Although the DNTS algorithm is not optimal in terms of speed, it still manages to solve small-scale instances in a very short time, proving its utility in dealing with such problems.

Based on the results presented in

Table 3. Experimental results for instances of 1000 vertices.

		DNTS			HAYWOOD			u-toksia
Instance	Best	Worst	Average	Best	Worst	Average	Best	Worst	Average
V1000_1	0.37	0.43	0.41	0.37	0.43	0.38	0.93	1.04	0.94
V1000_2	0.37	0.48	0.42	0.37	0.38	0.37	5.92	6.07	6.02
V1000_3	0.42	0.48	0.44	0.42	0.48	0.45	0.07	0.07	0.07
V1000_4	0.32	0.63	0.39	0.32	0.32	0.32	2.36	2.41	2.4
V1000_5	0.53	3.37	1.26	2.21	3.38	3.21	16.5	17.06	16.72
V1000_6	0.37	0.48	0.41	0.37	0.43	0.42	0.04	0.07	0.05
V1000_7	0.42	0.53	0.46	0.42	0.43	0.43	2.82	2.92	2.89
V1000_8	0.53	2.76	1.23	1.14	1.19	1.17	15.99	16.35	16.23
V1000_9	0.32	5.76	1.37	0.32	0.32	0.32	0.02	0.02	0.02
V1000_10	0.32	1.95	0.54	0.32	0.32	0.32	0.27	0.27	0.27
V1000_11	0.42	0.48	0.44	0.42	0.47	0.43	2.46	2.56	2.51
V1000_12	0.37	0.73	0.55	0.42	0.43	0.43	3.73	3.78	3.75
V1000_13	0.32	0.48	0.35	0.32	0.37	0.33	0.04	0.04	0.04
V1000_14	0.43	3.58	0.84	0.42	0.43	0.42	14.11	14.46	14.31
V1000_15	0.42	0.88	0.59	0.58	0.58	0.58	3.07	3.22	3.15
V1000_16	0.32	0.52	0.35	0.32	0.32	0.32	6.53	6.73	6.66
V1000_17	2.71	28.1	12.66	13.24	41.22	30.26	17.72	18.13	17.91
V1000_18	0.32	0.99	0.43	0.27	0.27	0.27	0.04	0.04	0.04
V1000_19	1.75	18.62	6.39	14.36	20.57	15.19	18.69	19.24	18.97
V1000_20	0.68	2.66	1.11	0.83	0.93	0.87	18.74	19.14	18.92
Att	0.59	3.7	1.53	1.87	3.66	2.82	6.5	6.68	6.59

, in the performance evaluation of the random instances generated from 1000 arguments, the DNTS algorithm and the HAYWOOD algorithm are close to each other in the majority of the instances and are generally lower than the u-toksia algorithm. In particular, the DNTS algorithm uses less time in some of the more time-consuming instances (e.g., V1000_17, V1000_19). Overall, for this group of instances, the DNTS algorithm performs better in handling complex instances and is more time efficient than the u-toksia and HAYWOOD algorithms.

Based on the results presented in

Table 4. Experimental results for instances of 2000 vertices.

		DNTS			HAYWOOD			u-toksia
Instance	Best	Worst	Average	Best	Worst	Average	Best	Worst	Average
V2000_1	5.46	142.6	44.52	14	14.41	14.21	26.01	27.13	26.62
V2000_2	20.62	251.33	76.89	60.09	216.14	120.46	20.57	21.18	20.83
V2000_3	2.87	26.31	5.52	3.27	3.98	3.37	26.31	26.98	26.66
V2000_4	2.36	20.52	6.67	8.3	9.48	8.55	20.16	20.77	20.52
V2000_5	2.92	25.86	5.79	2.87	3.38	2.98	25.75	26.47	26.07
V2000_6	0.07	2.1	1.86	2	2.1	2.05	0.07	0.07	0.07
V2000_7	0.12	2.51	2.06	2.15	2.21	2.18	0.12	0.12	0.12
V2000_8	8.71	36.18	21.97	57.5	270.97	167.28	26.57	27.38	26.94
V2000_9	2.71	9.93	3.66	3.17	3.27	3.22	9.68	9.94	9.81
V2000_10	2	15.78	4.63	2.05	2.1	2.07	7.85	8	7.9
V2000_11	0.07	1.95	1.64	1.75	1.8	1.8	0.07	0.07	0.07
V2000_12	1.75	17.26	3.61	1.65	1.7	1.66	17.16	17.51	17.34
V2000_13	2.36	20.87	4.98	2.21	2.26	2.22	20.87	21.33	21.09
V2000_14	3.07	10.65	4.35	3.78	3.99	3.85	10.65	10.85	10.74
V2000_15	3.07	10.39	4.07	4.24	4.45	4.33	10.39	10.6	10.46
V2000_16	1.9	6.73	2.44	1.9	1.95	1.91	6.63	6.78	6.7
V2000_17	3.22	10.9	4.61	3.48	3.63	3.57	10.75	11.01	10.86
V2000_18	1.85	17.16	3.68	2.21	2.26	2.25	16.9	17.26	17.11
V2000_19	2.97	33.96	15.67	7.44	7.75	7.57	20.26	20.72	20.49
V2000_20	5.56	28.76	12.26	21.07	27.89	22.11	28.75	29.17	28.9
Att	3.68	34.59	11.54	10.26	29.29	18.88	15.28	15.67	15.47

, the performance evaluation for random instances generated with 2000 arguments shows that the DNTS algorithm has significantly lower best values than the HAYWOOD and u-toksia algorithms for most instances. It shows that the DNTS algorithm is the fastest for these instances. However, the DNTS algorithm performs poorly in terms of worst values. The DNTS algorithm is better than HAYWOOD and u-toksia in terms of att values of average, indicating that worst values do not occur as frequently.

The overall performance of DNTS is similar to that of HAYWOOD in most of the cases, and significantly better than HAYWOOD in V2000_2, V2000_8, V2000_20, and V2000_20. Both of them outperform the u-toksia algorithms in most of the cases in terms of the best and average values, but the performance of worst is not as stable as the u-toksia algorithms.

Based on the results presented in

Table 5. Experimental results for instances of 3000 vertices.

		DNTS			HAYWOOD			u-toksia
Instance	Best	Worst	Average	Best	Worst	Average	Best	Worst	Average
V3000_1	5	7.19	5.8	4.85	5.05	4.96	22.7	23.16	22.87
V3000_2	6.17	7.85	6.66	6.27	6.43	6.36	10.95	11.21	11.13
V3000_3	8.51	13.35	11.33	7.7	8.11	7.92	34.3	35.32	35.05
V3000_4	8.05	11.16	10.46	10.04	10.65	10.44	14.21	14.57	14.41
V3000_5	12.89	31.71	21.28	23.16	24.18	23.77	33.94	34.76	34.35
V3000_6	6.38	8.61	7.37	9.63	10.14	9.92	28.45	29.89	28.93
V3000_7	7.29	11.51	9.45	6.93	7.29	7.17	27.28	27.89	27.58
V3000_8	7.09	11.21	8.73	18.53	19.04	18.73	28.25	28.91	28.6
V3000_9	11.01	16.09	13.27	22.45	23.21	22.92	15.33	15.63	15.5
V3000_10	12.58	44.47	22.96	63.5	68.07	66.21	33.84	34.55	34.09
V3000_11	5.61	5.97	5.73	5.56	5.72	5.61	8.87	9.17	9.06
V3000_12	5.46	5.77	5.6	5.26	5.36	5.33	22.55	23.01	22.81
V3000_13	9.83	13.34	11.44	10.8	11.21	10.98	35.42	36.34	36.01
V3000_14	12.28	31.25	18.69	11.87	12.22	12.1	38.06	38.88	38.41
V3000_15	9.43	13.8	11.74	11.11	11.51	11.28	35.47	35.98	35.75
V3000_16	6.33	6.58	6.49	6.22	6.48	6.39	0.17	0.17	0.17
V3000_17	13.35	24.59	18.2	57.09	60.5	59.23	36.69	37.61	37.23
V3000_18	12.38	157.44	70.56	128.45	134.15	131.52	32.82	33.38	33.05
V3000_19	6.43	7.95	6.91	6.53	6.78	6.66	11.06	11.41	11.24
V3000_20	7.39	8.67	7.78	7.24	7.6	7.45	13.09	13.4	13.25
Att	8.67	21.93	14.02	21.16	22.19	21.75	24.17	24.76	24.47

and 

Table 6. Experimental results for instances of 4000 vertices.

		DNTS			HAYWOOD			u-toksia
Instance	Best	Worst	Average	Best	Worst	Average	Best	Worst	Average
V4000_1	20.92	25.49	22.13	19.65	20.52	20.1	23.67	48.39	44.93
V4000_2	23.01	93	47.8	20.16	21.28	20.59	41.63	57.65	43.79
V4000_3	32.57	138.98	61.95	245.5	261.06	251.06	47.47	121.48	55.29
V4000_4	17.16	24.08	20.5	17.01	17.87	17.3	18.69	38.22	36.07
V4000_5	19.75	24.89	22.63	19.04	19.96	19.51	22.14	42.39	40.01
V4000_6	34.15	120.62	57.42	200.78	208.1	203.81	48.09	55.3	49.26
V4000_7	28.2	83.08	46.17	76.01	80.28	77.45	30.38	48.89	46.55
V4000_8	24.79	31.56	28.24	27.33	31.1	28.29	24.02	54.65	50.96
V4000_9	23.57	33.23	28.45	23.87	25.2	24.45	25.96	48.64	45.85
V4000_10	30.99	65.49	37.87	33.08	34.55	33.71	46.91	52.36	50.73
V4000_11	20.77	23.67	21.65	20.06	20.87	20.47	17.72	21.33	18.21
V4000_12	19.04	25.04	22.14	21.69	22.7	22	23.36	44.98	42.38
V4000_13	24.13	31.25	27.19	51.95	55.05	52.85	28.15	50.43	47.57
V4000_14	19.8	28.44	22.75	20.57	21.48	20.96	16.8	26.87	17.94
V4000_15	19.25	25.28	22.08	22.75	23.72	23.15	17.41	21.18	17.88
V4000_16	28.65	79.62	51.66	155.61	162.32	158.73	50.27	82.52	53.94
V4000_17	21.99	26.92	24.41	26.92	28.35	27.42	25.5	47.27	44.49
V4000_18	36.59	86.28	52.3	71.53	75.25	73.03	48.54	82.01	52.37
V4000_19	28.55	46.51	33.91	34.61	36.33	35.14	32.06	55.41	52.46
V4000_20	36.84	67.62	49.89	287.14	299.6	291.57	48.49	68.33	50.89
Att	25.54	54.05	35.06	69.76	73.28	71.08	31.86	53.42	43.08

, in the performance evaluation for randomly generated instances with 3000 and 4000 arguments, the DNTS algorithm shows a clear advantage in the best values over HAYWOOD and u-toksia in most instances. DNTS exhibits significant fluctuations in its worst values. In terms of average values, DNTS performs similarly to HAYWOOD in most instances but significantly outperforms HAYWOOD in some complex instances with longer solution times (such as V3000_10, V3000_17, V3000_18, V4000_3, V4000_6, V4000_7). The superior performance of DNTS in complex instances results in a better average total time (att), compared with HAYWOOD and u-toksia.

Based on the above experimental results, it can be observed that the DNTS algorithm significantly outperforms the HAYWOOD and u-toksia algorithms in terms of the best of the solved instances. However, there is a large difference between its best and worst values, which reveals the lack of stability of the DNTS algorithm. The DNTS algorithm shows more outstanding performance compared with HAYWOOD when dealing with some complex instances that take a long time, which leads to a consistent outperformance of the DNTS algorithm over HAYWOOD and u-toksia in terms of the overall average time (att). Therefore, the DNTS algorithm can be considered as an effective optimization of the HAYWOOD algorithm in terms of improving the upper bound of the performance of the solved instances.

5.2.2. Comparison on Number of Solved Instances

u-toksia, as an exact algorithm, does not participate in the experiments of this section. This section compares the performance differences between the DNTS algorithm and the HAYWOOD algorithm in processing random instances, both of which are heuristic algorithms. For this purpose, we generated test instances different from those used in the previous experiments and ensured that each instance had a stable extension. The instances were divided into four groups based on the number of arguments, with 50 instances per group, totaling 200 instances for the experiment, aiming to assess the solving efficiency of each algorithm for instances of various sizes. To ensure the reliability of the experimental results, each group of instances was tested three times. In

Table 7. Experimental results on the number of instances correctly solved.

		DNTS			HAYWOOD
Group	Best	Worst	Average	Best	Worst	Average
1000	50	50	50	50	50	50
2000	50	50	50	50	50	50
3000	49	48	48.33	46	46	46
4000	45	45	45	36	35	35.33

, best represents the maximum number of instances solved, worst represents the minimum number of instances solved, and average represents the average number of instances solved in three runs.

Based on the experimental results in Table 7, it can be observed that the HAYWOOD and DNTS algorithms are able to successfully solve basically all the instances in the instances generated with 1000 and 2000 arguments. However, the number of solutions of both algorithms decrease as the instance size increases. Nevertheless, the DNTS algorithm still outperforms HAYWOOD in terms of the number of solutions, and this advantage becomes more and more significant as the instance size increases.

6. Discussion and Analysis

To further explore the impact of different initialization schemes, tabu strategies, and perturbation techniques on algorithm performance, this section introduces three variants of the original DNTS.

For the time comparison experiments, we selected the same 50 instances as in the time comparison experiments in Section 5.2.1 for testing, and each instance was executed five times to ensure the reliability of the results. In the experiment for evaluating the number of correctly solved instances by the algorithm, the same 200 instances from Section 5.2.2 were used for testing. Each instance was run three times to ensure reliability.

6.1. The Importance of Initializing Solutions

The DNTS algorithm generates initial solutions for all arguments randomly labeled in or out labels. We name the algorithm version that labels all arguments as out in the initialization phase as DNTS-OUT. Running times of best, worst, and average in seconds are compared for two initialization solutions. The goal of this experiment is to evaluate the effect of different initialization strategies on the running time.

We use the same 50 instances as Section 5.2.1. From the experimental results in

Table 8. Comparison of different initialization solutions.

			DNTS			DNTS-OUT
Group	Instance	Best	Worst	Average	Best	Worst	Average
vertex_500	v500_1	0.12	0.12	0.12	0.12	0.12	0.12
	v500_2	0.12	0.12	0.12	0.17	0.17	0.17
	v500_3	0.07	0.12	0.09	0.12	0.12	0.12
	v500_4	0.07	0.07	0.07	0.12	0.12	0.12
	v500_5	0.12	0.12	0.12	0.17	0.17	0.17
	v500_6	0.12	0.12	0.12	0.12	0.17	0.16
	v500_7	0.07	0.12	0.11	0.12	0.17	0.14
	v500_8	0.07	0.12	0.08	0.12	0.12	0.12
	v500_9	0.07	0.12	0.08	0.12	0.12	0.12
	v500_10	0.07	0.12	0.09	0.12	0.12	0.12
vertex_1000	v1000_1	0.42	1.04	0.55	0.68	0.73	0.7
	v1000_2	0.42	2.66	0.88	0.68	0.83	0.75
	v1000_3	0.42	0.53	0.46	0.98	1.19	1.04
	v1000_4	0.32	0.53	0.40	0.48	0.58	0.53
	v1000_5	0.53	6.12	1.98	0.98	2.1	1.47
	v1000_6	0.37	0.43	0.40	0.63	1.75	0.88
	v1000_7	0.42	0.58	0.49	0.68	0.73	0.71
	v1000_8	0.83	6.06	2.24	1.09	1.85	1.48
	v1000_9	0.32	1.14	0.53	0.37	3.88	2.46
	v1000_10	0.37	1.65	0.66	0.48	0.53	0.51
vertex_2000	v2000_1	9.17	37.30	19.15	55.00	151.85	103.30
	v2000_2	20.83	39.49	28.35	34.10	188.72	88.81
	v2000_3	3.83	5.61	5.04	17.26	22.55	19.65
	v2000_4	2.97	4.14	3.80	4.85	9.73	7.39
	v2000_5	3.12	5.16	3.91	19.55	23.82	20.76
	v2000_6	2.21	2.41	2.30	2.51	3.07	2.79
	v2000_7	2.51	2.71	2.61	5.21	7.65	6.23
	v2000_8	21.33	66.75	45.77	176.36	374.11	291.23
	v2000_9	4.90	6.53	5.82	17.72	24.18	20.88
	v2000_10	2.31	2.46	2.41	4.95	6.73	5.79
vertex_3000	v3000_1	4.95	6.78	5.98	7.49	9.02	8.56
	v3000_2	6.43	8.82	7.12	26.67	30.13	28.32
	v3000_3	8.21	24.28	13.56	54.70	69.09	59.55
	v3000_4	9.43	14.52	11.09	83.03	87.70	84.60
	v3000_5	13.75	78.64	42.33	139.24	150.02	143.93
	v3000_6	6.28	11.36	8.36	26.83	29.82	28.31
	v3000_7	8.36	9.84	8.88	24.23	31.05	28.40
	v3000_8	6.53	10.65	8.85	27.69	37.25	29.77
	v3000_9	12.12	16.55	14.16	108.18	120.71	117.22
	v3000_10	11.11	114.46	44.33	100.17	119.29	106.65
vertex_4000	v4000_1	19.70	27.79	23.40	155.34	173.01	162.97
	v4000_2	23.87	76.72	42.90	184.01	262.12	206.70
	v4000_3	35.22	169.90	77.79	309.48	600.00	405.81
	v4000_4	16.95	24.94	19.55	85.26	95.58	88.29
	v4000_5	19.96	30.18	24.49	150.98	182.36	162.84
	v4000_6	35.67	73.36	49.53	321.31	380.52	347.62
	v4000_7	27.84	58.36	39.37	246.75	269.32	257.73
	v4000_8	24.13	35.47	30.25	223.92	232.01	226.24
	v4000_9	25.40	35.93	29.72	237.76	246.97	241.41
	v4000_10	27.08	62.94	43.40	310.87	386.32	346.17

, we see that both the DNTS and DNTS-OUT algorithms are able to give results quickly.

For the small instances of 500 and 1000 arguments, the difference in running time between the DNTS and DNTS-OUT algorithms is insignificant, and both of them are able to give quick solution results. However, as the instance size increases, i.e., for 2000, 3000, and 4000 arguments, the DNTS algorithm shows a more significant advantage over DNTS-OUT in terms of running time, and this advantage increases with the number of arguments.

We use the same 200 instances as Section 5.2.2. The experimental results in

Table 9. Experimental results on the number of instances correctly solved.

	DNTS			DNTS-OUT
Group	Best	Worst	Average	Best	Worst	Average
1000	50	50	50	50	50	50
2000	50	50	50	50	50	50
3000	49	49	49	49	48	48.33
4000	45	45	45	21	20	20.67

show that, for smaller-sized instances, both algorithms can successfully solve 50 instances. However, when facing the larger size instances of 3000 and 4000 arguments, both algorithms fail or time out, but the DNTS algorithm is still able to successfully solve more instances than DNTS-OUT.

Combining the above experimental results, the use of the random label initialization strategy shows significant advantages over the initialization approach of marking all labels as out. These advantages are evident both in terms of running time and the number of successfully solved instances.

6.2. The Importance of Tabu Strategy

In this section, we test the impact of the tabu strategy on the algorithm.

The algorithm version that does not execute tabu actions is named DNTS-NT.

We use the same 50 instances as Section 5.2.1. The results in

Table 10. Comparison of tabu strategy.

			DNTS			DNTS-NT
Group	Instance	Best	Worst	Average	Best	Worst	Average
vertex_500	v500_1	0.12	0.12	0.12	0.07	0.07	0.07
	v500_2	0.12	0.12	0.12	0.12	0.12	0.12
	v500_3	0.07	0.12	0.09	0.07	0.12	0.08
	v500_4	0.07	0.07	0.07	0.07	0.07	0.07
	v500_5	0.12	0.12	0.12	0.07	0.12	0.11
	v500_6	0.12	0.12	0.12	0.07	0.07	0.07
	v500_7	0.07	0.12	0.11	0.07	0.12	0.09
	v500_8	0.07	0.07	0.08	0.07	0.07	0.07
	v500_9	0.07	0.12	0.08	0.07	0.07	0.07
	v500_10	0.07	0.12	0.09	0.07	0.12	0.08
vertex_1000	v1000_1	0.42	1.04	0.55	0.38	4.49	1.23
	v1000_2	0.42	2.66	0.88	0.42	0.48	0.46
	v1000_3	0.42	0.53	0.46	0.48	0.53	0.52
	v1000_4	0.32	0.53	0.4	0.32	1.19	0.52
	v1000_5	0.53	6.12	1.98	0.63	1.85	1.26
	v1000_6	0.37	0.43	0.40	0.43	0.53	0.47
	v1000_7	0.42	0.58	0.49	0.43	0.48	0.45
	v1000_8	0.83	6.06	2.24	0.83	1.44	1.06
	v1000_9	0.32	1.14	0.53	0.32	0.68	0.39
	v1000_10	0.37	1.65	0.66	0.37	0.43	0.39
vertex_2000	v2000_1	9.17	37.30	19.15	14.01	81.66	43.66
	v2000_2	20.83	39.49	28.35	5.46	141.26	43.09
	v2000_3	3.83	5.61	5.04	3.93	5.92	4.58
	v2000_4	2.97	4.14	3.80	3.53	9.02	6.32
	v2000_5	3.12	5.16	3.91	2.97	5.15	3.74
	v2000_6	2.21	2.41	2.30	2.16	2.26	2.21
	v2000_7	2.51	2.71	2.61	2.26	2.46	2.35
	v2000_8	21.33	66.75	45.77	23.77	62.89	49.68
	v2000_9	4.90	6.53	5.82	3.83	5.31	4.63
	v2000_10	2.31	2.46	2.41	2.21	3.83	2.58
vertex_3000	v3000_1	4.95	6.78	5.98	5.77	6.07	5.96
	v3000_2	6.43	8.82	7.12	11.67	12.02	11.85
	v3000_3	8.21	24.28	13.56	11.31	15.63	13.28
	v3000_4	9.43	14.52	11.09	17.52	31.96	21.69
	v3000_5	13.75	78.64	42.33	22.45	92.95	54.65
	v3000_6	6.28	11.36	8.36	12.28	18.79	15.49
	v3000_7	8.36	9.84	8.88	6.78	11.71	9.98
	v3000_8	6.53	10.65	8.85	7.50	8.77	8.03
	v3000_9	12.12	16.55	14.16	9.43	14.57	11.11
	v3000_10	11.11	114.46	44.33	36.44	50.42	43.44
vertex_4000	v4000_1	19.70	27.79	23.40	23.11	31.25	26.61
	v4000_2	23.87	76.72	42.90	59.28	130.74	104.79
	v4000_3	35.22	169.90	77.79	45.44	119.97	80.71
	v4000_4	16.95	24.94	19.55	39.03	57.65	45.96
	v4000_5	19.96	30.18	24.49	43.46	49.81	46.43
	v4000_6	35.67	73.36	49.53	73.97	122.80	90.77
	v4000_7	27.84	58.36	39.37	58.71	109.27	91.50
	v4000_8	24.13	34.50	30.25	45.08	55.97	50.62
	v4000_9	25.40	35.93	29.72	21.48	27.08	23.96
	v4000_10	27.08	62.94	43.40	65.53	80.03	72.62

show that both the DNTS and DNTS-NT algorithms produce fast results for small-size instances. For larger instances with 2000, 3000, and 4000 arguments, both algorithms present similar solution times in most instances. However, for complex instances that take longer to solve, particularly those with 4000 arguments, the DNTS algorithm significantly outperforms the DNTS-NT algorithm. This advantage is mainly attributed to its use of the tabu search mechanism.

We use the same 200 instances as Section 5.2.2. The results in

Table 11. Experimental results on the number of instances correctly solved.

	DNTS			DNTS-NT
Group	Best	Worst	Average	Best	Worst	Average
1000	50	50	50	50	50	50
2000	50	50	50	50	50	50
3000	49	49	49	49	48	48.67
4000	45	45	45	43	42	43.67

show that, when processing instances with 3000 and 4000 arguments, both the DNTS and DNTS-NT algorithms encounter instances they cannot solve. However, the DNTS algorithm still successfully solves a higher number of instances compared with DNTS-NT.

In summary, while the DNTS and DNTS-NT algorithms perform similarly in small or simple instances, the DNTS algorithm exhibits significant advantages in more complex and time-consuming instances. This is due to its effective use of the forbidden search mechanism, notably reducing the time required to find a solution.

6.3. The Importance of Perturbation Techniques

This sub-section tests the effect of perturbation techniques on algorithm performance. The algorithm variant that does not implement perturbation techniques is defined as DNTS-NP.

We use the same 50 instances as Section 5.2.1. The results in

Table 12. Comparison of perturbation technique.

			DNTS			DNTS-NP
Group	Instance	Best	Worst	Average	Best	Worst	Average
vertex_500	v500_1	0.12	0.12	0.12	0.12	0.12	0.12
	v500_2	0.12	0.12	0.12	0.12	0.12	0.12
	v500_3	0.07	0.12	0.09	0.07	0.12	0.1
	v500_4	0.07	0.07	0.07	0.07	0.07	0.07
	v500_5	0.12	0.12	0.12	0.12	0.12	0.12
	v500_6	0.12	0.12	0.12	0.12	0.12	0.12
	v500_7	0.07	0.12	0.11	0.12	0.12	0.12
	v500_8	0.07	0.07	0.08	0.07	0.07	0.07
	v500_9	0.07	0.12	0.08	0.07	0.12	0.08
	v500_10	0.07	0.12	0.09	0.07	0.12	0.09
vertex_1000	v1000_1	0.42	1.04	0.55	0.37	0.43	0.4
	v1000_2	0.42	2.66	0.88	0.37	0.53	0.45
	v1000_3	0.42	0.53	0.46	0.42	600	120.36
	v1000_4	0.32	0.53	0.4	0.37	0.38	0.37
	v1000_5	0.53	6.12	1.98	0.47	0.99	0.68
	v1000_6	0.37	0.43	0.4	0.37	0.43	0.41
	v1000_7	0.42	0.58	0.49	0.42	600	120.37
	v1000_8	0.83	6.06	2.24	0.58	2.26	1.22
	v1000_9	0.32	1.14	0.53	0.32	98.03	19.88
	v1000_10	0.37	1.65	0.66	0.32	527.63	105.81
vertex_2000	v2000_1	9.17	37.30	19.15	21.43	600.00	153.29
	v2000_2	20.83	39.49	28.35	36.29	600.00	366.56
	v2000_3	3.83	5.61	5.04	3.32	5.01	4.18
	v2000_4	2.97	4.14	3.80	3.43	6.38	5.10
	v2000_5	3.12	5.16	3.91	3.02	5.61	4.60
	v2000_6	2.21	2.41	2.30	2.10	2.61	2.39
	v2000_7	2.51	2.71	2.61	2.26	3.22	2.70
	v2000_8	21.33	66.75	45.77	20.47	600.00	152.72
	v2000_9	4.90	6.53	5.82	3.37	4.49	3.87
	v2000_10	2.31	2.46	2.41	2.10	2.82	2.46
vertex_3000	v3000_1	4.95	6.78	5.98	5.51	6.37	5.97
	v3000_2	6.43	8.82	7.12	6.53	9.22	7.97
	v3000_3	8.21	24.28	13.56	11.06	14.16	12.09
	v3000_4	9.43	14.52	11.09	9.63	16.75	13.03
	v3000_5	13.75	78.64	42.33	19.76	600.00	156.63
	v3000_6	6.28	11.36	8.36	7.49	12.83	10.34
	v3000_7	8.36	9.84	8.88	9.53	15.53	12.31
	v3000_8	6.53	10.65	8.85	7.34	11.51	9.78
	v3000_9	12.12	16.55	14.16	13.70	20.78	16.61
	v3000_10	11.11	114.46	44.33	25.19	42.69	33.60
vertex_4000	v4000_1	19.70	27.79	23.40	24.89	30.99	27.36
	v4000_2	23.87	76.72	42.90	35.78	153.08	65.36
	v4000_3	35.22	169.90	77.79	68.02	215.63	135.98
	v4000_4	16.95	24.94	19.55	20.11	32.12	24.14
	v4000_5	19.96	30.18	24.49	24.28	32.42	29.03
	v4000_6	35.67	73.36	49.53	42.18	600.00	277.31
	v4000_7	27.84	58.36	39.37	44.08	62.87	48.87
	v4000_8	24.13	34.50	30.25	31.80	38.52	34.20
	v4000_9	25.40	35.93	29.72	28.91	37.10	32.72
	v4000_10	27.08	62.94	43.40	34.86	52.15	42.51

show that there is little difference between the performance of the DNTS and DNTS-NP algorithms in most of the instances. However, in some of the higher complexity instances, the DNTS algorithm has a significantly shorter solution time than DNTS-NP. In particular, DNTS-NP is more prone to extremely poor results when dealing with certain instances (e.g., v1000_3, v1000_7, v1000_10, v2000_1, v2000_2), which can have problems with extremely high running times or unsolvability.

We use the same 200 instances as Section 5.2.2. The results in

Table 13. Experimental results on the number of instances correctly solved.

	DNTS			DNTS-NP
Group	Best	Worst	Average	Best	Worst	Average
1000	50	50	50	50	50	50
2000	50	50	50	48	47	47.67
3000	49	49	49	49	49	49
4000	45	45	45	45	44	44.33

indicate that both algorithms are successful in producing solutions when dealing with small instances. When dealing with large instances, the DNTS algorithm is able to solve more instances and shows better performance compared with DNTS-NP.

Comprehensive analyses show that DNTS and DNTS-NP perform close to each other in most cases. However, the DNTS-NP algorithm is prone to produce extremely poor results in some instances. This result emphasizes the importance of perturbation techniques in improving the stability of the DNTS algorithm and its ability to escape from locally optimal solutions.

6.4. Analysis of Algorithm Performance with Different Graph Type

We evaluated the DNTS algorithm’s iterations per second under different graph types. We chose 32 instances in Section 5.2.1, excluding 500 groups. Based on the size of these instances, we categorized them into sparse and dense graphs.

In randomized instances, the main factor affecting the iterative performance of the algorithm is the size of the instance since the graph is not very structured. From Figure 7, we find that both plots have distinct peaks and troughs and that the numbers of peaks and troughs are more numerous and of greater magnitude in Figure 7a and relatively fewer in Figure 7b. The higher the density of the graph is, the lower is the iterative performance of the algorithm. In addition, we analyzed the instances at indexes 1 and 2 in Figure 7a and indexes 1 and 3 in Figure 7b to test the number of stable extensions.

Analyzing these four instances, we find that the number of arguments in the stable extension from instance 1 is higher than in instance 2 in Figure 7a and instance 3 in Figure 7b, potentially affecting the algorithm’s iteration speed. Additionally, the graph’s ring structure may impact performance, with the algorithm’s search process becoming extremely difficult when there are too many rings or nested rings in the graph.

By analyzing the iterative performance of sparse and dense graphs, it can be seen that the DNTS algorithm has the most stable and superior performance in dense graphs, especially in medium and large instances. The DNTS-NT algorithm, on the other hand, has outstanding performance in sparse graphs in some instances, but its overall stability is not as good as that of the DNTS algorithm.

7. Conclusions

This paper introduces a dual-neighborhood tabu search (DNTS) algorithm to solve the single stable extension (SE-ST) problem within abstract argumentation frameworks. It implements a dual-neighborhood strategy incorporating a fast neighborhood evaluation method. In addition, by introducing techniques such as tabu and perturbation, this algorithm is able to jump out of the local optimum, which significantly improves the performance of the algorithm. The DNTS algorithm was experimentally validated on a series of random instances generated by the AFGen generator provided by ICCMA, demonstrating significant effectiveness. Comparative results with the u-toksia and HAYWOOD algorithms reveal that DNTS achieves superior best run times in most of the randomly generated instances, though it slightly lags in worst-case scenarios. Nevertheless, the efficient performance of DNTS in processing complex instances enables it to surpass both u-toksia and HAYWOOD in overall performance, evidencing that DNTS has raised the upper limit of solving efficiency, yet there is still room for improvement in terms of stability.

As the size of instances increases, the number of instances correctly solved by the DNTS algorithm shows a declining trend, but it still outperforms the HAYWOOD algorithm, which is of the same class of local search algorithms. This experimental result not only confirms the feasibility and advantages of the DNTS algorithm in computing stable extensions within abstract argumentation frameworks but also highlights the need for further optimization in terms of the number of solutions the algorithm can find.

Future work will explore methods to enhance the stability of the DNTS algorithm and attempt to apply it to solving other extension problems such as complete extension, preferred extension, etc., to fully assess its application potential and scalability.