In this paper we present a novel data-mining model called argumentative decision graphs (
). An is a special argumentation framework where arguments have a rule-based structure and an attack relation is defined among arguments.
are graph-like models learnt from data in a supervised way that can be used for classification tasks. As in a decision tree, given a set of input features, an returns the value of the target variable. Unlike decision trees, the output of an can be also an undecided status, occurring when the model does not have enough reasons to predict a value for the target variable. This is due to the use of argumentation semantics to identify what arguments of an make a prediction about the target variable. Unlike Bayesian Networks, are accepted and consequently are not required to be acyclic, but they can have any topology. Advantages of are the possibility of using diferent semantics to make predictions, the ability to deal with incomplete input data and to generate compact explanations. We evaluate a preliminary greedy algorithm to learn an from data using public datasets and we compare our results with Decision Tree in terms of balanced accuracy and size of the model. Our results provide evidence to further progress our research.
from data for binary classification.
In this paper we describe a novel data-mining model called Argumentative Decision Graphs ( ).
An
is a supervised data-mining model that learns the relationships between a target variable and a large enough set of examples. In this first paper we present a preliminary algorithm to learn
An argumentative decision graph is an extension of Dung’s abstract argumentation graphs [
AI32021, 5ℎ ℎ
The main reason to introduce is the willingness to bring the advantages of symbolic non-monotonic reasoning into data-mining models. An is an extension of an abstract argumentation framework, that is a symbolic reasoning system able to represent partial and conflicting knowledge and to formalize a large set of non-monotonic semantics. For this reason, an can deal with partial information and make predictions when some of the inputs are missing.
The predictions of an are made by applying an argumentation semantics. We first recall that
an argumentation semantics is a set of postulates used to identify the set of acceptable arguments,
called extensions. In the labelling approach [
Data-mining models that could be considered similar to are explainable models such as
Decision Trees [
The paper is organized as follows. In section 2 we recall the basics of abstract argumentation semantics, in section 3 we introduce our model, while in section 4 we critically compare them to decision trees. Section 5 describes an algorithm to learn from data that is evaluated in section 6, while related works are described in section 7.
Definition 2.1. An argumentation framework is a pair ⟨ , ℛ⟩ , where is a non-empty finite set whose elements are called arguments and ℛ ⊆ × is a binary relation, called the attack relation. If (, ) ∈ ℛ we say that attacks . An argument is initial if it is not attacked by any argument, including itself.
An argumentation framework = ⟨ , ℛ⟩
identifies a directed graph. We define the restriction of an argumentation framework to a set of nodes as the framework ↓ corresponding to the vertex-induced subgraph of identified by : Definition 2.2. Given = ⟨ , ℛ⟩ , the restriction of to a set of nodes ⊆ argumentation framework ↓ = ⟨, ℛ ⟩ where ℛ = ℛ ∩ ( × ) . is the
An abstract argumentation semantics identifies a set of arguments that can survive the conflicts encoded by the attack relation ℛ. Dung’s semantics require a group of acceptable arguments to be conflict-free (an argument and its attackers cannot be accepted at the same) and admissible (the set of arguments defends itself from external attacks).
Definition 2.3.
A set ⊆ is conflict-free if ∀, ∈ , (, ) ∉ ℛ
Definition 2.4. A set ⊆ defends an argument ⊆ if ∀ ∈ such that (, ) ∈ ℛ, ∃ ∈ such that (, ) ∈ ℛ . The set of arguments defended by is denoted ℱ ( ) . A conflict-free set is admissible if ⊆ ℱ ( ) and it is complete if = ℱ ( ) .
We follow the labelling approach of [
Definition 2.5. Let = ⟨ , ℛ⟩ We write (ℒ ) for { ∈ |ℒ () = } |ℒ () = } .
Definition 2.6. Let = ( , ℛ) holds that: . A labelling is a total function ℒ ∶ → {, , } , (ℒ ) for { ∈ |ℒ () = } , and (ℒ ) for { ∈
. A complete labelling is a labelling such that for every ∈ 1. if is labelled then all its attackers are labelled ; 2. if is labelled then it has at least one attacker that is labelled ; 3. if is labelled then it has at least one attacker labelled and no attackers labelled . Definition 2.7. Given = ( , ℛ) , ℒ is the grounded labelling if ℒ is a complete labelling where (ℒ ) is maximal (w.r.t. set inclusion) among all complete labellings of . ℒ is the preferred labelling if ℒ is a complete labelling where (ℒ ) is maximal (w.r.t. set inclusion) among all complete labellings of . A stable labelling is a complete labelling with (ℒ ) = ∅ .
The grounded semantics, first introduced by Pollock [
In this section we introduce the notion of argumentative decision graphs. We work with a dataset
composed by a set of features, each of them taking values in a finite set. A feature represent
the target variable of the classification task. Informally, an argumentative decision graph is an
extension of Dung’s abstract argumentation graph [
Formally, we consider a dataset represented by a × matrix-like data structure, where each row is called an instance of the dataset and each column is called a feature. An instance can be represented by a tuple = ⟨ 1, ., ⟩, where is the value associated with the ℎ feature . We consider the predicates of the form ( ) , with the meaning ”the feature has the value ”.
Given a tuple = ⟨ 1, ., , .., ⟩, the predicate ( ) is verified by if = (the value of the ℎ component of the tuple is equal to ), and not verified otherwise. One of the features is called the target variable and it is denoted with , and therefore the predicates involving the target variable have the form ( ) . The set of all the predicates is called ∪ , where is the set of predicates regarding the target variable and the set of predicates regarding the other features { 1.. }.
An is an argumentation framework where each argument has a structure = ⟨, ⟩ , where ∈ and is either the empty set or a target variable predicate ( ) . An argument with a non-empty conclusion is called a predictive argument. An attack relation is defined over the arguments. The definition is therefore the following: Definition 3.1. An argumentative decision graph ADG is an argumentation framework = ( , ℛ) where each ∈ has the form = ⟨, ⟩ , ∈ , ∈ ∪ ∅ and ℛ ⊆ × .
Example 1. Let us consider the dataset 1 in Table 1, describing Paul’s activities on Sunday. The dataset has the following four Boolean features: w (whether the weather is windy), s (whether the weather is sunny), k (whether Paul has a sore knee or not) and l (whether Paul has a fishing licence) and a target variable a (activity), that takes the two values {surf, fish} . Using the features of 1, the following two are given: • • 1 = ⟨{ 1, 2, 3}, {( 1, 2), ( 2, 3), ( 3, 2)} 2 = ⟨{ 1, 2, 3, 4}, {( 1, 2), ( 2, 3), ( 3, 2)} where 1 = ⟨( ), ∅)⟩ , 2 = ⟨ ( ), ( )⟩ , 3 = ⟨( ), ( ℎ)⟩ , 4 = ⟨ (), ( ℎ)⟩ .
1 is saying that Paul goes surfing if the weather is windy (argument 2) and fishing if the weather is sunny ( 3), but he cannot do both of the activities ( 2 and 3 mutually attack each other), and he does not go surfing if he has a sore knee ( 1 attacks 2). 2 is adding the information that Paul goes fishing if the weather is not windy ( 4). We can represent an with a directed graph where each node is labelled with the argument it represents. In figure 1 1 and 2 are shown. For readability, we also wrote the description of each argument.
In order to be well-formed, the attack relation of an has to satisfy some consistency constraints. The first constraint is that there is no attack between two arguments whose supports contain the same feature. This is because the two arguments are mutually exclusive, since only one of the two supports can be verified by an input tuple. The second constrain is that there is no attack between two arguments whose conclusions are the same and not empty. Third, if two arguments and have mutually exclusive conclusions and they use diferent features in their supports, there must be an attack between them: either attacks , attacks or they symmetrically attack each other. This constrain is introduced to guarantee that the predictions of an are conflict-free, i.e., two arguments with mutually exclusive conclusions cannot be accepted at the same time. Formally the three constrains are as follows. We remind how denotes the target variable and the ℎ feature. Definition 3.2. Given an = ⟨ , ℛ⟩ ⟨ 1, 1⟩, 2 = ⟨ 2, 2⟩ it holds that: , the is well-formed if ∀ 1, 2 ∈ with 1 = 1. if 1 = ( 1) and 2 = ( 2) then ( 1, 2) ∉ ℛ ∧ ( 2, 1) ∉ ℛ 2. if 1 = 2 ≠ ∅ then ( 1, 2) ∉ ℛ ∧ ( 2, 1) ∉ ℛ 3. if 1 = ⟨ 1( ), ( 1)⟩, 2 = ⟨ 2( ), ( 2)⟩ and 1 ≠ 2 ∧ 1 ≠ 2 then ( 1, 2) ∈ ℛ ∨ ( 2, 1) ∈ ℛ.
We consider a dataset and an built from . The target variable is and is the set of values that the target variable can take.
An identifies a function ∶ → ∪ { und, unk} that, given an input tuple ∈ , it returns either a value for the target variable or one of two additional outputs: undecided (und) or unknown (unk). The computation of is described in algorithm 1. Given an input instance , we ifrst consider the set of all the arguments whose support is verified by . Then, we apply grounded semantics on the abstract argumentation framework restricted to the verified arguments. We remind how, since the is well-formed, all the accepted arguments have the same conclusion. We then consider the following situations: 1. if there is at least a predictive accepted argument, the value predicted by the is the value of the conclusion of any of the predictive accepted arguments. 2. if the extension is empty but there is at least one predictive argument that is undecided, then the predicted value of the is the status undecided: there are arguments that could be used to predict the target variable, but they are part of conflicts that cannot be resolved. 3. in all the other cases, when there are neither accepted nor undecided predictive arguments, the value returned by the is the status unknown.
Algorithm 1: The function to make predictions given a tuple ∈ . The dataset is described by the features 1, .., and target variable taking values in the set . 1 Inputs: = ⟨, ℛ⟩ , a tuple ∈ ; 2 Output: a predicted value in the set ∪ { und,unk} 3 ← verified (, ) 4 ℒ ← Grounded( ↓ ) 5 if in(ℒ ) ≠ ∅ then 6 if ∃ ∈ in(ℒ ) ∣ = ⟨, ()⟩ then 7 return v 8 else 9 if und(ℒ ) ≠ ∅ ∧ ∃ ∈ und(ℒ ) ∣ = ⟨, ()⟩ 10 return unk
then return und;
Example 2. Let us consider again 1 and 2 and the dataset 1 in Table 1. Let us consider the first tuple 1 = ⟨ , , , ℎ⟩ and compute 1( 1). All the three arguments 1, 2, 3 are verified by 1, and therefore the argumentation graph to be considered is equivalent to the full one. The grounded semantics returns two accepted arguments { 1, 3} since 2 is defeated by 1. Since 3 = ⟨( ), ( ℎ)⟩ then 1( 1) = ℎ . If we consider the tuple 2 = ⟨ , , , ⟩ (the weather is sunny and windy and Paul has no sore knee), only 2 and 3 are verified by 2, and the resulting argumentation framework is a couple of mutually attacking arguments labelled undec by the grounded semantics and therefore 1( 2) =und. Regarding tuple 6 = ⟨, , , ⟩ (weather neither sunny nor windy, Paul has a sore knee), only argument 1 is verified and accepted by grounded semantics. However, this argument does not predict the target variable and, since there are no undecided arguments, nothing can be said about the target variable and 1( 6) =unk.
By comparing the predictions of an with the actual values of the target variable, the usual performance metrics derived from the confusion matrix such as accuracy, precision, recall and f1-score can be computed. The confusion matrix is a joint-frequency table of the predicted versus the actual values. In a binary classification the confusion matrix is a 2 × 2 table. However, since an can also return the two special values undecided and unknown, the confusion matrix will have two additional lines. In Figure 2 the confusion matrices for 1 and 2 computed using the dataset 1 are shown.
We note how both 1 and 2 have a perfect accuracy when a prediction is generated (this is measured by the decision accuracy equal to 1), however 1 is in the unknown status in 4 out of 10 cases and undecided in one case, and therefore its overall accuracy is 0.5. 2 is a better predictive model since it makes predictions in more cases than 1 without adding any prediction error. This is reflected by its higher f1-score.
In this section we outline some interesting diferences and similarities between and decision
trees. We consider again a dataset with a set of features { 1, .., , } where is the target variable.
A decision tree ( ) [
Entry point. A decision tree has a single entry point - the root of the tree - and a specific order in which nodes are tested to generate a prediction. On the contrary, an has no entry point and arguments can be evaluated in any order. The consequence is that, in case of partial information that is the value of one or more features is missing or unknown - an has a higher chance to return a prediction. For instance, if the information about the feature sore knee is not available 1 and 2 cannot return a prediction, while 1 and 2 could.
Adding new knowledge. Let us suppose that new knowledge needs to be added to the dataset in the form of a new feature/variable. An argumentation graph is easier to be expanded; in order to add a new argument, it is enough to define the new set of attacks involving the new node. The previous structure of the graph is unchanged. On the other side, adding a variable to a decision tree without changing its previous structure can be done only by adding new terminal nodes testing the new variable or use the variable as the new root. Retraining the tree would in general generates a very diferent tree where the new variable might appear in diferent part of the graph. It can be observed that also for an in order to find the optimal graph it might be necessary to modify the previous nodes and links. However, an has more options when it comes to accommodate a new variable without changing the existing graph due to a less constrained topology.
Representation of knowledge. The topology of a and the one of an are certainly diferent. However, despite the diferences, both of the two models represent knowledge as a set of logical rules in disjunctive normal form. A tree is an acyclic graph where every path is disjoint from the other. Every path represents a distinct rule to reach a conclusion, and once a path is taken it is not possible to move back to another path. Multiple paths are usually present to reach the same conclusion. Therefore a represents knowledge as a set of mutually exclusive rules and each split represents a specialization of the support of a rule. On the contrary an represents knowledge as a set of default rules, potentially defining an inconsistent (conflicting) set and subjects to exceptions. Every unidirectional attack provides an exception to a rule (=an argument) and therefore specializing further when the rule can be used. Depending on the context and the data, the conflict-based representation of the could generate more understandable and compact models than the mutually exclusive rules generated by the or vice versa.
Explanations. Decision Trees are regarded as one of the most explainable data mining models. The tree structure, if not too complex, can be easily understood by a human. Each branch of the tree represents a specific input case, and each branch identifies a logical rule consisting of the conjunction of all the tests used to reach the terminal node from the root. For instance, sore knee and not windy weather is an explanation for Paul going fishing in the tree 2. The length of an explanation is the length of the path from the root node to the terminal node. The average length of all the paths - often weighted by the number of tuples covered by each path - is a measure of the average length of the explanations generated by the decision tree.
Regarding an , the structure can be also understood by a human if the argumentation graph has a small size, but it could be argued that the free topology of an argumentation graph makes it harder to be understood. However, even when the graph is large, the application of the chosen semantics reduces the number of arguments that are necessary to explain a decision. In general, the arguments defeated by an accepted argument are irrelevant to define the decision and, if we are using grounded semantics and the set of accepted arguments is not empty, the undecided arguments are also irrelevant. Moreover, we do not need all the accepted arguments since the acceptability of some arguments might depend on the acceptability of other arguments. The explanations could therefore be compact also for a large graph. The analysis of explanations is an important issue that will be covered in future works.
Variable Importance. In a decision tree, the importance of a variable is measured by the information gain, that is the reduction in the conditional entropy of the target variable. In other words, a variable is important if, by knowing its value, the target variable can be predicted with more certainty. In an , various measures of the importance of a variable could be defined. For instance, the importance of an argument could be proportional to the number of input tuples for which the argument is necessary to obtain a prediction. Note how, since an argument refers to a specific feature-value pair, an has a more fine-grained notion of variable importance. An aggregated value for each feature can then be provided.
Semantics. Another diference between and is the way their outputs are produced. An is evaluated using argumentation semantics to solve the conflicts encoded in the graph. Given an input tuple, an is evaluated by mean of an argumentation semantics that labels the arguments as accepted, rejected or undecided. The undecided label provides an with a built-in way of quantifying the uncertainty deriving from conflicting information. Moreover, semantics provide a way of representing diferent strategies to accept arguments. While the grounded semantics is the most skeptical semantics maximizing the set of undecided arguments, semantics such as the preferred are credulous semantics maximizing the set of accepted arguments. Semantics other than the grounded are often multi-status, meaning that they generate multiple sets of accepted arguments, all consistent with the semantics used. Multi-status semantics could be used to present multiple consistent scenarios to the decision makers, each of them with valid reasons to be accepted.
Expressiveness. Regarding the expressiveness of the two models, they are equivalent. Given an , it is possible to define a computing exactly the same function. Indeed, if we compute the output of an for all the input tuples, we can build an exhaustive where each path represents an input tuple and the value predicted by the terminal nodes is the same as the output. Given a , an equivalent can be built by following these rules: 1. for each directed link from a node to a terminal node of the , create a predictive argument ⟨ ( ), ⟩, where is the variable tested at node and is the value of identifying the link connecting to the terminal node , and is the value of the target variable predicted at node . 2. for each link from a node to node where is non-terminal, create an argument ⟨ ( ), ∅⟩, where is the variable tested at and is the value of the feature identifying the link . 3. after having found the arguments of the using rules 1 and 2, for each argument associated to a link from node to , add to the attack relation ℛ the pair of nodes (, ) , where is any argument associated to a link that is on a directed path connecting to a terminal node so that ∉ , unless the two arguments use the same feature or predict the same value for the target variable.
The idea is that terminal nodes provide the arguments to predict the target variable, while the non-terminal nodes provide the non-predictive arguments. Regarding the attack relation, an argument generated by a link from node to attacks all the arguments generated by links that are mutually exclusive with and belonging to the sub-tree identified by the node .
As an example, let us consider the decision tree 1. We build the corresponding . According to rule 1, the has the following predictive arguments: 1 = ⟨ ( ), ⟩ , 2 = ⟨ (), ℎ⟩ , 3 = ⟨( ), ℎ⟩ , 4 = ⟨(), ⟩ . According to rule 2, it has the following two non-predictive arguments: 5 = ⟨(), ∅⟩ , 6 = ⟨( ), ∅⟩ . Regarding the attack relation, according to rule 3 the only attacks are: 5 attacks 3 and 4, while 6 attacks 1 2. Argument 5 does not attack 6 and vice versa since they use the same feature and they are therefore mutually exclusive. The resulting is shown in figure 4. We conclude by observing that, despite the two models are equivalent, this does not guarantee that the two algorithms will learn similar models from data. In fact, the way the relationship between input tuples and target variable is learnt and the way knowledge is represented imply that the two models will in general be quite diferent. 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
Function AddARG( = ⟨ ( ), ⟩, = ⟨, ℛ⟩
)): while Arg ≠ ∅ do
← ⟨∅, ∅⟩ ←
for ∈ Arg do perf if perf perf ← perf ← == ←
return .remove( )
← AddArg(, ←eval(ADG ) > + Δ then
) then if return return for = ⟨ ( ), ⟩ ∈ Arg do ← ← ⟨ ∪ {, }, ℛ ∪ {(, )}⟩ → ← ⟨ ∪ , ℛ ∪ {(, )}⟩ ↔ ← ⟨ ∪ , ℛ ∪ {(, ), (, )}⟩ if ≠
∧ ≠ ≠ ∅ then ← ∈ { ← ∈ {, else if ≠ then
←,
In this section we present a first simple algorithm to learn from data. The algorithm is a preliminary attempt, and it can be improved in multiple ways. However, it represents a starting point to study and test the potential of
.
Algorithm 2: The function BuildADG to learn an from a dataset . The dataset is described by the features 1, .., and target variable . The target variable is binary and takes the values +, −. represents the set of all possible values for the feature . The function eval returns the selected performance indicator for a given 1 Inputs: Dataset , a performance threshold Δ 2 Outputs: an 3 Function BuildADG( ,Δ): perf ← 0 ; Arg ← ∅ for each distinct pair ( , ) do
Arg ← Arg ∪ ⟨ ( ), +⟩ ∪ ⟨ ( ), −⟩ ∪ ⟨ ( ), ∅⟩
→, ←,
↔} where eval( ) is maximal →,
↔} where eval( ) is maximal The algorithm, called BuildADG, builds an incrementally by adding an argument at the time and by expanding the attack relation in order to maximize a performance indicator, such as the overall accuracy of the
. BuildADG is shown in algorithm 2. We consider a dataset with features { 1, .., , }
where is the target variable, each feature takes value from its corresponding set of values , while the target variable is binary and it takes the two values + or −. The algorithm has two inputs: the dataset and a tuning parameter Δ. The algorithm starts by identifying the arguments that will be used to build the . For each pair feature-value ⟨ , ⟩ three arguments are added, one predicting +, one − and the neutral argument with empty conclusion ⟨ ( ), ∅⟩ .
Then, for each argument in the algorithm adds to the the argument that increased the performance of the resulting by the highest interval, but only if the addition of increased the performance by at least Δ compared to the previous . Argument is removed from the list of arguments and the procedure is repeated until all the arguments have been tested or it is not possible to increase the performance of the by Δ. The function AddArg is responsible for adding a new argument to the . For each argument already in the , we need to decide how the new argument interacts with . The resulting must be well-formed to avoid logical inconsistencies. If argument and are mutually exclusive there is no need to add an attack link between them. The same is for the situation in which and are predicting the same value for the target variable . If both and are predictive but they predict diferent values for and they do not have mutually exclusive supports, an attack must be present to keep conflict-freeness. There are three possibilities: attacks , attacks or they mutually attack each other. One of these three attacks must be present to keep the well-formed, and the one generating the best is kept. If either or are non-predictive argument, there is also the fourth possibility that there is no attack relation between the arguments (line 30).
In this section, we provide a first evaluation of the BuildADG algorithm and we compare its results
to a C4.5 Decision Tree. The evaluation compares the total accuracy of the two models using three
benchmark datasets. An evaluation considering other performance indicators or the explainability
of the models is left for future works. The datasets used for the evaluation are well-known, publicly
available datasets [
In both the bank and car price datasets, the accuracy of the decision tree was statistically higher than the accuracy. The gap was smaller for the car price dataset, where registered a balanced accuracy of 0.88. For the US census dataset we obtained positive results: the accuracy of the was in the 95% confidence interval of the decision tree accuracy and only marginally lower (83.4% versus 84.2%), and the balanced accuracy of the was higher than the one of the decision tree. Regarding the size of the models learnt, we used the number of nodes and links to measure it (note how the number of links in a tree is − 1 , where is the number of nodes). The graph was smaller for the car price and bank dataset, but more complex for the US census dataset. Table 3 shows the most important variables (ranked by importance) for decision tree and for . There is a good degree of overlapping for all the three datasets, meaning that the two algorithms substantially agreed on the most important variables.
Discussion. The results obtained are promising but they also expose some of the weakness of the preliminary algorithm proposed. Indeed, the algorithm is naive in several aspects. For instance, the addition of a new argument is accepted if the absolute number of correctly classified instances is increased by an interval Δ even if the accuracy (i.e. the percentage of correct predictions) could decrease, showing how the algorithm has a bias in favour of increasing the coverage of the instances rather than maximizing the accuracy. The algorithm also needs a pruning procedure, similar to the ones used in a decision tree. The result of the US census dataset shows that an can became very complex, harming the understandability of the outputs but also increasing the chance of model overfitting. A pruning strategy should reduce the complexity of the model, keeping its accuracy high. One idea could be to introduce a regularization parameter similar to the one present in the cost-based pruning mechanism of a decision tree, parameter that will penalize complex , forcing the algorithm to find a trade-of between complexity and performance. Finally, our preliminary algorithm is not computationally eficient, and it can be optimized in multiple ways, including an approximation using Monte Carlo simulation.
Recently, there has been an increasing number of studies mixing argumentation theory and machine
learning methods. However, very little studies directly face the problem of learning an
argumentation graph from data. The large majority of applications are in the field of argumentation mining,
where arguments are extracted automatically from text using NLP techniques either in a data-driven
fashion or in a mixed approach where an explicit structure of arguments has to be matched on
the text [
In this paper, we presented a novel data-mining algorithm called argumentative decision graphs ( ). An is a special argumentation framework where arguments have a rule-based structure and an attack relation is defined among arguments. are learnt from data in a supervised way and they can be used for classification tasks. We have discussed the main diferences and similarities with similar models such as decision trees, showing a translation between the two formalisms. Unlike decision trees, the output of an can be also an undecided status, where the graph does not have enough reasons to predict a value for the target variable. This is due to the use of argumentation semantics to identify the arguments of an that are accepted and consequently make a prediction on the target variable. We evaluated a preliminary greedy algorithm to learn an from data using benchmark datasets and we compared our results with the C4.5 decision tree algorithm. Our results showed how had an accuracy lower or comparable to decision trees, a generally less complex model and a good agreement on the importance of the variables between the two models. The algorithm presented is naive in some of its assumptions, and it can be improved in many aspects, including how arguments interact, the way the impact of an argument is evaluated and how to reduce its computational time. Overall, we believe to have provided enough evidence to justify further research into .