A computational model of argumentation schemes for multi-agent systems

1.Introduction

Argumentation schemes are patterns for arguments (or for inferences), representing the structure of common types of arguments used both in everyday discourse as well as in special contexts such as legal and scientific reasoning [89]. Argumentation schemes have become a well-known concept from Douglas Walton’s book “Argumentation schemes for presumptive reasoning” [87], a seminal contribution to the literature on argumentation, in which Walton argues about common forms of arguments, considered “valid” or correct, addressing the question of what are those forms of arguments or so-called argumentation schemes. Walton’s work on argumentation schemes became influential across a range of areas of study, e.g., legal and scientific argumentation [89], as well as being a central element in the development of argumentation in computer science, in particular artificial intelligence [41, 67].

Considering that argumentation is a complex and important ability that demonstrates cognitive capacity [5], the Artificial Intelligence (AI) community sees argumentation schemes as an important component to model and implement intelligent-agent technologies embedding such cognitive capacity, enabling argument mining [28, 35, 36], agent decision-making, reasoning, and communication [32, 33, 77, 82]. Applying such technologies on a variety of domains such as legal reasoning, medical argumentation, e-government, debating technologies, and many others [5, 69, 86].

Particularly in Multi-Agent Systems (MAS), argumentation plays an important role in both agent reasoning and communication [37], providing an expressive communication method [33], as well as a powerful reasoning mechanism under conditions of conflicting and uncertain information [5]. Consequently, interesting multi-agent system applications using argumentation-based techniques have been developed in the last few years, for example [32, 46, 52, 78]. Most of those applications define argumentation schemes (often only one) that are used by agents to instantiate arguments used for reasoning and/or communication, fulfilling the application needs regarding argumentation. However, the link between argumentation schemes and the (few) practical approaches and frameworks for argumentation, particularly in multi-agent systems, has not been fully investigated in the literature. We believe that it is necessary to address the particular structure of argumentation schemes, keeping the essence of the argumentation schemes as devised by Walton [89] and reflecting natural (human-like) argumentation, in such practical frameworks and in particular in agent-oriented programming languages, which will allow us to implement multi-agent systems empowered by argumentation techniques in a more principled way. This is so because, firstly, Walton’s approach provides an elegant model for knowledge engineering in multi-agent systems based on argumentation schemes, which seems an essential step towards developing multi-agent system applications that take advantage of argumentation schemes. Secondly, because Walton’s approach provides a refined and modular mechanism for agents to reason and communicate using argumentation schemes, reflecting the essence of how humans argue. Also, our approach allows implicit information in argumentation schemes to be kept implicit at the implementation level, whereas other practical approaches explicitly represent them as additional premises or need to break an argumentation scheme into separate arguments.

In this work, we propose a novel argumentation framework, formally defined and implemented, that takes into consideration the general structure of argumentation schemes and agent-oriented programming languages as its core. Thus, after modelling (or importing) argumentation schemes into our framework, agents are directly able to construct, communicate, and reason with arguments instantiated from those argumentation schemes, also addressing important properties when using argumentation schemes, e.g., scheme awareness [91]. This work extends our previous paper [50], in which we took the initial steps towards the development of this framework. In this paper, we not only present the framework, but we also describe in detail how it can be used to implement argumentation-based reasoning and argumentation-based dialogues using argumentation schemes, presenting various examples of their use.

The main contributions of this work are: (i) we propose an argumentation framework that has the general structure of argumentation schemes as its core. Using that general structure, we can represent argumentation schemes of different levels of specificity, including those in which there is implicit information pointed out by critical questions; our framework maintains the essence of argumentation schemes as defined by Walton [89], in which it is the matching between the argument and its reasoning pattern (argumentation scheme) that brings to light the relevant implicit information necessary to judge the validity of an argument; (ii) we show how our framework can be used to implement argumentation-based reasoning mechanisms based on argumentation schemes, in which agents first instantiate and evaluate each argument individually using its respective argumentation scheme and then, considering the acceptable instances of arguments, agents define the set of acceptable arguments given a particular argumentation semantics; (iii) we experimentally evaluate the performance of our implementation for argumentation-based reasoning considering different levels of specificity for argumentation schemes, i.e., using single or chained argumentation schemes, varying the number of premises and critical questions. Our results confirm our hypothesis that the more complex the reasoning needed (using chained argumentation schemes), the longer it takes for agents to reach a conclusion. Also, our results provide guidance to the process of knowledge engineering for argumentation schemes in multi-agent systems using our approach, depending on the application’s needs, i.e., detailed reasoning versus faster reasoning; (iv) we show how our framework can be used to implement argumentation-based dialogues based on argumentation schemes. We propose a dialogue protocol in which agents can question the argumentation scheme used to instantiate arguments when they are not aware of that argumentation scheme, considering the problem of scheme awareness in argumentation-based dialogues [91]. We implemented the proposed protocol in an agent-oriented programming language and we show the outputs generated from different argumentation-based dialogues, considering different lines of argumentation; and (v) we provide an open-source implementation of our framework in the Jason multi-agent programming platform [12].

This paper is organised as follows. In Section 2, we present the background of this work, giving an overview of how argumentation techniques have been used in artificial intelligence and multi-agent systems, also introducing the notion of argumentation schemes. In Section 3, we introduce our argumentation-scheme-centred framework and formally define it. In Section 4, we describe our approach to argumentation-based reasoning using argumentation schemes, presenting examples and an empirical evaluation of our implementation. In Section 5, we describe our approach to argumentation-based dialogues using argumentation schemes, introducing a dialogue protocol based on argumentation schemes, and showing various examples of dialogues generated according to the implementation of that protocols. In Section 6, we discuss the main properties of our framework. In Section 7, we describe some work related to our approach. In Section 8, we conclude the paper also pointing out future directions for our research.

2.Background

3.An argumentation-scheme-centred argumentation framework

Some approaches in the argumentation literature have suggested that argumentation schemes [87, 89] could be translated into defeasible inferences [48, 49, 63], and the acceptability of arguments, instantiated using these rules, could be used to extend frameworks such as ASPIC+ [43], DeLP [27], and others [47, 53]. However, those approaches do not take into consideration that most of the critical questions related to the argumentation schemes are not explicitly represented in the argument, as clearly argued by Walton [87]. Thus, those approaches would require to make the critical questions related to the scheme used to instantiate that argument explicit in the representation of that argument; that is, it would be necessary to include an explicit representation of all critical questions (usually representing presumptions and/or exceptions for the application of that scheme [66]), as premises of the argument, or even modelling those critical questions using other arguments undercutting the main argument (i.e., an argument saying that defeasible inference rule does not apply in that particular case) [64]. Otherwise, when such critical questions are not represented as part of the argument, and an agent is not able to infer from which argumentation scheme that argument comes from, all that information is lost.

Although approaches that explicitly represent critical questions on arguments do not face the problem of losing information, we believe they do not embrace the essence of argumentation schemes22 discussed by Walton [89], in which arguments are instances of reasoning patterns (argumentation schemes) and it is this link (identifying the argumentation scheme used to instantiate an argument) that bring to light the critical questions applying to an argument. We also believe it is essential to keep this essence when applying argumentation in dialogues between agents and between agents and humans.

In this work, we present an argumentation framework in which argumentation schemes are the core of our framework. We propose a computational representation for argumentation schemes, and of arguments instantiated from those reasoning patterns, that overcomes the problem of making explicit information that should be implicit in an argument. Moreover, we describe how agents may reason and communicate using our proposed structure of arguments.

In order to make explicit the representation of arguments, we introduce the language L used in this work. We use a first-order language as the basis for our representation, given that most agent-oriented programming languages are based on logic programming, and we are interested not only in the formal specification of our framework but also in its implementation. In particular, we have a set of atomic formulæ {p0,…,pn}∈L, and a set of defeasible inference rules {(pi,…,pj⇒pk),…,(pl,…,pm⇒po)}∈L. In order to refer to the unification process, we use a most-general unifier θ (as usual in logic programming). We use uppercase letters to represent variables – e.g., Ag and R in role(Ag,R) – and lowercase letters to represent terms and predicate symbols – e.g., john, doctor and role(john,doctor). We use “¬” to represent strong negation in L, e.g., ¬reliable(pietro) means that pietro is not reliable. We also use negation as failure “not”, e.g., not(reliable(pietro)) means that an agent does not know if pietro is reliable. Atomic formulæ, sets of atomic formulæ, and defeasible inference rules can be annotated with relevant information used in the inference mechanism. In this paper, annotations are ground literals representing the names of argumentation schemes, e.g., pl[sn] and {pi∧⋯∧pj}[sn] are used to represent critical questions related to the argumentation scheme sn, and (pl,…,pm⇒po)[sn] is used to represent the defeasible inference rule corresponding to the inference modelled by the argumentation scheme sn.

Further, all knowledge available to an agent ag is represented as Δag. When an agent ag is aware of some information ψ (i.e., ψ is part of or can be inferred from its belief base), we write Δag⊧ψ, with ψ∈L. For example, when an agent ag is aware of a defeasible inference rule (pl,…,pm⇒po) we write Δag⊧(pl,…,pm⇒po). For example, Δag⊧(penguin(X)⇒¬flies(X)) means that agent ag is aware of the defeasible inference stating that presumably, all penguins do not fly.

We introduce the formal definition for argumentation schemes used in this paper as follow:

Considering the logic language L, an argumentation scheme ⟨sn,C,P,CQ⟩ is represented using a (not ground) defeasible inference rule of the type (pi,…,pj⇒pk)[sn], in which {pi,…,pj}=P and pk=C. Note that the inference rule is annotated33 with the name of the argumentation schemes sn, which is used to refer to the critical questions associated with that schemes. The critical questions related to the scheme are (not grounded) formulæ of the type {p0[sn],…,pn[sn]}∈L, with {p0[sn],…,pn[sn]}=CQ.

For example, the argumentation scheme role to know can be represented using the following defeasible inference rule:44 with the argumentation scheme name sn= role_to_know, the conclusion C = Conclusion, and premises P={role(Agent,Role), role_to_know(Role,Domain), asserts(Agent, Conclusion), about(Conclusion,Domain)}.

The associated critical questions CQ are:

For example, considering the argumentation scheme role to know, imagine that an agent ag knows that john (another agent in the system) is playing the role of doctor – role(john,doctor) – within the organisation of the multi-agent system. Further, ag knows that doctors know about cancer – knows(doctor,cancer). Therefore, if john asserts that “smoking causes cancer” – asserts(john,causes(smoking,cancer)), and given that causes of cancer are a subject matter related to cancer – about(causes(smoking,cancer),cancer), ag is able to instantiate the argumentation scheme role to know, which allows ag to conclude that smoking causes cancer – causes(smoking,cancer).

Note that an agent can instantiate different arguments, say ⟨S1,c1⟩snθ2 and ⟨S2,c2⟩snθ1, from the same argumentation scheme sn, when θ1≠θ2. Also, an agent is able to use the same argumentation scheme to instantiate conflicting arguments. Following our example, imagine that another agent also (presumably) playing the role of doctor, called pietro, asserts that “smoking does not cause cancer” – asserts(pietro,¬causes(smoking,cancer)). Any agent aware of both assertion, John’s and Pietro’s assertions, is able to construct conflicting arguments for ¬causes(smoking,cancer) and causes(smoking,cancer) (as we will see later, both attacking each other). However, the agents are able to question whether john and pietro are reliable (trustworthy) sources, if they really play the role of doctor, and the other questionable points indicated by the critical questions in the argumentation scheme used in order to check the validity of that particular conclusion. Here, an important issue on the representation of arguments appears, as not all critical questions (for example the reliability of an agent) refer to information explicitly represented in the structure of arguments instantiated from argumentation schemes. As described in [84], the critical questions of an argumentation scheme play an important role in: (i) criticising the scheme’s premises; (ii) pointing out exceptional situations in which the scheme should not be used; (iii) representing conditions for a scheme’s use (for example, a particular context). Thus, it is essential to consider the critical questions when evaluating an individual instance of argument from an argumentation scheme, and when the critical questions are not positively answered, that argument instance might not be acceptable.55 For example, imagine that an agent has the information that “Pietro is not a reliable source” – ¬reliable(pietro). In that case, that agent is not able to answer positively the critical question reliable(pietro), thus it is rational to think that instance of the argumentation scheme (i.e., that argument) might not be acceptable for that agent; the argument concluding ¬causes(smoking,cancer) might not be an acceptable instance of the argumentation scheme role to know for such a rational agent.

Note that instantiating an argumentation scheme requires an agent checking the acceptability of the premises used in that argument, this automatically refers to the agent checking attacks against the premises of that argument instance.66 Also, positively answering the critical questions related to the argumentation schemes used to instantiate that argument requires instantiating the critical questions. Considering the language introduced above, we are able to model critical questions that cover all roles mentioned by [84], for example, for some scenarios it would be interesting to model critical questions pointing out to the absence of a particular piece of information – not(¬reliable(pietro)) (the agent does not have the information that Pietro is not reliable). When the application requires more complex argumentation (inferences) regarding critical questions, predicates representing critical questions may be the conclusion of other arguments, which will be instantiated from argumentation schemes with their own critical questions, as we show later in this paper.

After instantiating arguments from the argumentation schemes available to it, an agent needs to check if those arguments result in conflicts. Considering a dialectical point of view, two types of attack (conflict) between arguments can be considered, according to [89]: (i) a strong kind of conflict, where one party has a thesis to be proved, and the other party has a thesis that is the opposite of the first thesis, and (ii) a weaker kind of conflict, where one party has a thesis to be proved, and the other party doubts that thesis, but has no opposing thesis of their own. In the strong kind of conflict, each party must try to refute the thesis of the other in order to win. In the weaker form, one side can refute the other, showing that their thesis is doubtful. When considering the computational model of arguments, this difference between conflicts is inherent from the structure of arguments and can be found in the work of others (e.g., [63]). Both types of conflicts are also considered in monological argumentation frameworks. On the one hand, the stronger kind of conflict refers to arguments supporting conflicting conclusions, in which each argument has its own set of evidence (i.e., its support). On the other hand, the weaker kind of conflict refers to an argument attacking (in conflict with) part of the support of another argument, that is, an argument does not imply that the conclusion of another argument is false, but it implies that some information used as support of that conclusion (e.g., some piece of information in the support of another argument) is not true.

Attacks between arguments are identified by looking at their structures and finding conflicting information, as formalised below.

For example, considering an agent ag and its knowledge base Δag, ag is able to construct two different arguments using the argumentation scheme role to know; both arguments are in conflict with each other at their conclusions:

Note that both arguments above are acceptable instances of the argumentation scheme role to know, according to Definition 3. However, when defining the acceptability of an argument (semantically), it is not enough to check if it is an acceptable instance of an argumentation scheme; it is necessary to check if that argument survives attacks from other acceptable instances of argumentation schemes. At this point, it would be reasonable to conclude that both arguments are not (semantically) acceptable to ag, and it would not be able to conclude either causes(smoking,cancer) or ¬causes(smoking,cancer). However, imagine that pietro is not a doctor, i.e., role(pietro,doctor) is not true (it was a misperception of ag), and ag becomes aware of that information through the hospital director named mathew.

Given the knowledge that ag has about the hospital, partially shown above, in Δag, it is able to construct an argument using the argumentation scheme role to know concluding that pietro is a cleaning staff and not a doctor:

Thus, the argument concluding ¬causes(smoking,cancer) is not an acceptable instance of the argumentation scheme role to know anymore, considering that role(pietro,cleaning_staff) is conflicting information with role(pietro,doctor) (semantically declared at ag knowledge base). At this point, it would be reasonable for ag to conclude causes(smoking,cancer).

Considering the three arguments above, the argument concluding that causes(smoking,cancer) is attacked by the argument concluding ¬causes(smoking,cancer), which is attacked by the argument concluding role(pietro,cleaning_staff). Considering that the argument concluding role(pietro,cleaning_staff) is not attacked by any other argument, role(pietro,cleaning_staff) and causes(smoking,cancer) are the two acceptable conclusions (and their respective arguments) in our example. We write Δag⊧⟨S1,c1⟩sniθ to represent when ⟨S1,c1⟩sniθ is an acceptable argument for ag. Also, we write Δag⊧c1 to represent that c1 is an acceptable conclusion for ag.

4.Argumentation-based reasoning using argumentation schemes

One characteristic we desire in our framework is generality. The generality of our framework to represent argumentation schemes has been evaluated in Panisson’s PhD thesis [44], in which 11 argumentation schemes (with and without implicit critical questions) from different areas in the literature have been specified using our framework, evaluated, and implemented in an agent-oriented programming language. Here, starting from Section 4.1, we focus on demonstrating examples of how our framework for argumentation schemes can be used to implement argumentation-based reasoning in multi-agent systems. Also, in Section 4.2, we evaluate our implementation in order to demonstrate how fast agents are able to reach a particular conclusion supported by arguments instantiated from argumentation schemes using our implementation, investigating how much the number of premises and critical questions influence the time necessary for agents to reach such a conclusion.

4.2.Experimental results

We have implemented our approach88 extending the argumentation-based framework reported in [47, 53], which is implemented in the Jason [12] multi-agent platform. We have evaluated our implementation to check how much time an agent needs to construct an acceptable instance of an argument from an argumentation scheme, depending on the number of premises and critical questions present in such scheme. In our experiments, we have considered both approaches for modelling argumentation schemes, i.e., with and without chained arguments.

Fig. 1.

Time (ms) for reaching a conclusion considering one level of inference.

Fig. 2.

Time (ms) for reaching a conclusion considering 2 levels of inference.

First, we evaluate our implementation when modelling argumentation schemes without chained arguments, in which premises and critical questions are asserted into agents’ belief base. Figure 1 shows our results, varying the number of premises and critical questions from 1 to 10. It can be noted that there is a similar influence of the number of premises and critical questions in the final time for an agent to construct an acceptable instance of an argumentation scheme.

We then evaluate our implementation considering chained arguments, in which the premises of the main argument are conclusions of other arguments constructed from different argumentation schemes. Thus, first an agent constructs acceptable instances of arguments from their respective argumentation schemes for each premise of the main argument, and using those premises it constructs the main argument as an acceptable instance of its respective argumentation scheme. Figure 2 shows our results, varying the number of premises (and respective argumentation schemes, given each premise is the conclusion of an acceptable instance from a different argumentation scheme) and the critical questions. It can be noted that the number of premises has a greater influence on the time to construct the main argument than the number of critical questions. This results from the fact that premises of the main argument are conclusions of other arguments, which are constructed and evaluated from their respective argumentation schemes,99 according to Definition 3, which means that they have their own critical questions to be positively answered.

Our results provide a guide for the process of knowledge engineering of argumentation schemes in multi-agent systems (specially useful when using our implementation), showing how those reasoning patterns could be modelled depending on the multi-agent application requirements. On the one hand, when defining chained argumentation schemes (generating chained arguments), which will allow agents to execute a more detailed and refined reasoning process based on argumentation, as in [46], more time is required for agents to analyse and evaluate a particular conclusion from those argumentation schemes. On the other hand, when defining a single argumentation scheme, such reasoning is simplified but faster results are reached.

Fig. 3.

Abstract inference tree generated for chained argumentation schemes with 4 premises and 4 critical questions.

Figure 3 shows an abstract example for an inference tree generated by an agent reaching a conclusion conc using chained argumentation schemes (i.e., all sni argumentation schemes are chained to the argumentation scheme sn) with four premises and four critical questions.

5.Argumentation-based dialogues with argumentation schemes

When participating in argumentation-based dialogues using argumentation schemes, agents must be aware of such reasoning patterns in order to have a full understanding of what is being communicated, which has been referred to as “scheme awareness” by Wells [91]. Being aware of the argumentation schemes used by others, when receiving an argument, allows agents to understand which argumentation scheme has been used to instantiate that argument, identifying the critical questions related to it, being able to understand what implicit information was used by the speaker when building that argument.

A few approaches in the literature, for example [48, 49], propose that agents should openly share such argumentation schemes in order to deal with the inherent problem of scheme awareness. An overview of those approaches to argumentation schemes in MAS is shown in Fig. 4, where all agents are able to instantiate arguments from shared argumentation schemes at runtime. Whilst those approaches solve the problem of scheme awareness as defined by Wells [91], and it is adequate to many multi-agent architectures using shared domain-specific knowledge [23, 52, 74], we propose a more general approach, allowing agents to have knowledge of specific argumentation schemes and to be able to communicate them when necessary.

Fig. 4.

Argumentation schemes shared by all agents.

In communication, the acceptability of arguments received from other agents is directly associated with the agents’ rationality, i.e., when an agent ag receives an argument ⟨S,c⟩sniθ from another agent, it is able to check whether or not that information is acceptable to itself, adding S to its knowledge base Δag (i.e., Δag=Δag∪S) and checking the acceptability of c. Thus, it is essential that such an agent is aware of the argumentation scheme sni to adequately check whether that argument is an acceptable instance of that argumentation scheme according to Definition 3. Afterwards, an agent can proceed to further consider that argument looking for arguments that attack it, arguments that attack those arguments attacking the initial one, and so on, according to Definition 6.

We use Δag⊧c to say that agent ag is able to construct an acceptable argument ⟨S,c⟩sniθ according to Definition 6, with S⊂Δag. Argument ⟨S,c⟩sniθ refers to an acceptable instance of the argumentation scheme ⟨sni,P,C,CQ⟩∈Δag. An agent never has acceptable arguments for conflicting information, i.e., Δag⊧c and Δag⊧c‾ never both hold simultaneously. We use Δag⊭c to mean that an agent is not able to construct an acceptable argument for c. Δag⊭c does not imply Δag⊧c‾; however, Δag⊧c implies Δag⊭c‾.

5.3.A protocol using argumentation schemes

Our protocol combines persuasion and information-seeking dialogues. A persuasion dialogue is used when an initiator agent believes something that it wants another agent to be convinced to believe as well [76]. In this type of dialogue, an agent starts the dialogue with an assert move, asserting the information (the subject of the dialogue) it wants the other agent to believe [54]. After that, agents are able to present their arguments supporting or attacking the subject of the dialogue. In the end, either the other agent accepts the subject of the dialogue, when the arguments from the initiator agent convince it, or the initiator agent accepts that it cannot convince the other agent to accept the subject of the dialogue, then closing the dialogue. However, our protocol mixes information-seeking dialogues when we allow agents to ask for the argumentation scheme used to instantiate arguments used by other agents in the dialogue.

In the previous sections, we have used examples of arguments typically used in persuasion dialogues, instantiated from the argumentation scheme from role to know. For example, in a hospital nurses usually use arguments based on doctors’ assertions in order to convince patients to accept a treatment, a diagnostic, etc.

In order to evaluate our framework, we have implemented the following protocol, which is an extended version of [54], making reference to components of our framework for argumentation schemes in multi-agent systems, as well as allowing agents to question the argumentation scheme used by other agents during the dialogue:

• (1) an agent agi starts a dialogue with another agent agj, executing an assert move assert(agi,agj,p), trying to make agj believe in p; p becomes the subject of the dialogue (the protocol goes to (2)).

• (2) an agent agj receives an assert move assert(agi,agj,p), and it checks if it has an argument against p. When it has no argument against p, it accepts p executing an accept move accept(agj,agi,p) (the protocol goes to (5)). Otherwise, when agj is able to construct an argument against p, it executes a question move question(agj,agi,p), asking for an argument supporting that assertion (the protocol goes to (3)).

• (3) an agent agi receives a question move question(agj,agi,p), and it responds with a justify move justify(agi,agj,⟨S,p⟩snθ), introducing an argument which supports the questioned proposition (the protocol goes to (4)).

• (4) an agent agj receives a justify move justify(agi,agj,⟨S,p⟩snθ), checking whether it is aware of the argumentation scheme sn used to build that argument. When it is not aware of the argumentation scheme sn, it questions agi about the scheme executing a question_scheme move question_scheme(agj,agi,sn) (the protocol goes to (6)). Otherwise, when it is aware of the argumentation scheme used by agi, then it checks if the new information received from agi is enough to make it accept the subject of the dialogue, i.e., if it has no argument against the subject of the dialogue, considering the new information received from agi. In case agj has no argument against the subject of the dialogue, it accepts the subject of the dialogue executing an accept move accept(agj,agi,p) (the protocol goes to (5)). Otherwise, when agj is able to construct an argument against the subject of the dialogue, either (i) it executes an assert move1212 assert(agj,agi,¬p), committing itself to provide support for ¬p (the protocol goes to (2)); or (ii) it checks whether it is able to answer negatively any critical question related to the argumentation scheme sn that agi has used to instantiate its argument. In the case it is able to answer negatively a critical question from sn, it executes an assert move assert(agj,agi,¬cq), with cq the critical question (the protocol goes to (2)).

• (5) an agent agj receives an accept move accept(agi,agj,p), and in the case where the accepted proposition is the subject of the dialogue, the dialogue ends with both agents believing that the subject of the dialogue holds. In the case where the accepted proposition is a critical question, the agent that accepts the critical question returns to step (4) of the protocol, accepting the subject of the dialogue, questioning another critical question, or committing itself to give support for the subject of the dialogue not being the case.

• (6) an agent agj receives a question_scheme move question_scheme(agi,agj,sn) and answers that move by informing agi about the argumentation scheme sn executing a inform_scheme move inform_scheme(agj,agi,⟨sn,C,P,CQ⟩) (the protocol goes to (7)).

• (7) an agent agj receives an inform_scheme move inform_scheme(agi,agj,⟨sn,C,P,CQ⟩), recalling the subject of the dialogue and then checking if it has no argument against the subject of the dialogue. In case agj has no argument against the subject of the dialogue, it accepts the subject of the dialogue executing an accept move accept(agj,agi,p) (the protocol goes to (5)). Otherwise, when agj is able to construct an argument against the subject of the dialogue, either (i) it executes an assert move assert(agj,agi,¬p), committing itself to provide support for ¬p (the protocol goes to (2)); or (ii) it checks if it is able to answer negatively any critical question related to the argumentation scheme sn that agi has used to instantiate its argument. In case it is able to answer negatively a critical question from sn, it executes an assert move assert(agj,agi,¬cq), with cq the critical question that it was able to answer negatively (the protocol goes to (2)).

5.3.1.Dialogue rules

Initial Rule: The first move (commencement rule) introduces the subject of the dialogue (where subject(p) means that the atomic formula p is the subject of the dialogue). Each dialogue has only one subject. The agent that introduces the subject of the dialogue is called proponent, and the other agent participating in the dialogue is called opponent [18] (we use Pr and Op, respectively, to refer to them).

Cin1⇒assert(agi,agj,p)

where:

Cin1=∃⟨S,p⟩snθ:Δagi⊧⟨S,p⟩snθ

The dialogue starts when an agent wants to argue about a given subject. The initial rule states that an agent must have an argument that supports its claim in order to start an argumentation-based dialogue (as the agent will be committed to defend the initial assertion). Considering our framework for argumentation scheme in multi-agent systems, it requires the agent being able to instantiate an acceptable instance of an argument from an argumentation scheme in ΔAS, according to Definition 6.

Assert Rules: We have two dialogue rules that restrict the possible next move for agents to respond to an assert move:

assert(agi,agj,p)∧Cas1⇒accept(agj,agi,p)assert(agi,agj,p)∧Cas2⇒question(agj,agi,p)

where:

Cas1=∄⟨S,p‾⟩snθ:(Δagj∪CSagi)⊧⟨S,p‾⟩snθCas2=∃⟨S,p‾⟩snθ:(Δagj∪CSagi)⊧⟨S,p‾⟩snθ

The options of the agent are: (i) to accept the previous claim, where condition Cas1 means that the agent will accept a claim if it has no argument against it; and (ii) when the agent has an argument against the previous assertion, Cas2, the agent will question the other agent to provide the support for its previous claim.

Question Rule: The dialogue rule that restricts the moves after an agent receives a question message is:

question(agi,agj,p)∧Cqs1⇒justify(agj,agi,⟨S,p⟩snθ)

where:

Cqs1=∃⟨S,p⟩snθ:(Δagj∪CSagi)⊧⟨S,p⟩snθ

Considering that the agent has asserted p previously (which allowed the question move), the agent is committed to defending its claim in the dialogue, so it will provide the support for this claim.

Justify Rules: We have six dialogue rules that restrict the possible next move for agents to respond to a justify move:

justify(agi,agj,⟨S,c⟩sniθ)∧Cjs1⇒question_scheme(agj,agi,sni)justify(agi,agj,⟨S,c⟩sniθ)∧Cjs2⇒accept(agj,agi,p)justify(agi,agj,⟨S,c⟩sniθ)∧Cjs3⇒assert(agj,agi,p‾)justify(agi,agj,⟨S,c⟩sniθ)∧Cjs4⇒assert(agj,agi,cq‾)justify(agi,agj,⟨S,c⟩sniθ)∧Cjs5⇒closedialogue(agj,agi)justify(agi,agj,⟨S,c⟩sniθ)∧Cjs6⇒justify(agj,agi,⟨S′,c⟩snjθ)

where:

Cjs1=⟨sni,C,P,CQ⟩∉ΔagjCjs2=∄⟨S′,p‾⟩snjθ:(Δagj∪CSagi)⊧⟨S′,p‾⟩snjθ∧Op(agj)∧subject(p)Cjs3=∃⟨S′,p‾⟩snjθ:(Δagj∪CSagi)⊧⟨S′,p‾⟩snjθ∧p‾∉CSagj∧Op(agj)∧subject(p)Cjs4=∃cq‾θ:(Δagj∪CSagi)⊧cq‾θ∧cq‾θ∉CSagj∧cqθ∈CQ∧⟨sni,C,P,CQ⟩∈ΔagjCjs5=∄⟨S′,p⟩snjθ:(Δagj∪CSagi)⊧⟨S′,p⟩snjθ∧⟨S′,p⟩snjθ∉CSagj∧Pr(agj)∧subject(p)Cjs6=∃⟨S′,p⟩snjθ:(Δagj∪CSagi)⊧⟨S′,p⟩snjθ∧⟨S′,p⟩snjθ∉CSagj∧Pr(agj)∧subject(p)

When the agent is not aware of the argumentation schemes used by the other agent, it questions the other agent about such scheme, so that it will be able to properly evaluate that argument when receiving the information about the argumentation scheme used to instantiate it. Otherwise, the agent will accept the subject of the dialogue, Cjs2, if the justification received from the proponent has made the subject of the dialogue acceptable to it, otherwise either the agent will assert that it is committed to supporting a claim against the subject of the dialogue when it has an argument against it, Cjs3, or it will assert that some critical question related to that argument are not positively answered, Cjs4. In the case in which the agent that receives the justify move from the opponent cannot itself reach the same conclusion, given the new information received (i.e., the agent does not have an acceptable argument for the subject of the dialogue anymore), the agent closes the dialogue, Cjs5. In the final case, the agent sends a new argument1313 to support the subject of the dialogue, Cjs6.

Accept Rule: The dialogue rule that restricts the moves when an agent receives an accept message is:

accept(agi,agj,p)∧Cac1⇒closedialogue(agj,agi)

where:

Cac1=subject(p)∧Pr(agj)

When the agent receives an accept move it will close the dialogue. Only the proponent will receive an accept move when the opponent accepts the subject of the dialogue.

Question Scheme Rule: The dialogue rule that restricts the moves when an agent receives a question_scheme message is:

question_scheme(agi,agj,sni)∧Cqsc1⇒inform_scheme(agj,agi,⟨sni,C,P,CQ⟩)

where:

Cqsc1=⟨sni,C,P,CQ⟩∈Δagj

An agent is supposed to be aware of the argumentation scheme previously used to instantiate an argument used in that particular dialogue move, thus it will provide such an argumentation scheme when questioned.

Inform Scheme Rules: The dialogue rules that restricts the moves when an agent receives a question_scheme message are:

inform_scheme(agi,agj,⟨sni,C,P,CQ⟩)∧Ciss1⇒accept(agj,agi,p)inform_scheme(agi,agj,⟨sni,C,P,CQ⟩)∧Ciss2⇒assert(agj,agi,p‾)inform_scheme(agi,agj,⟨sni,C,P,CQ⟩)∧Ciss3⇒assert(agj,agi,cq‾)inform_scheme(agi,agj,⟨sni,C,P,CQ⟩)∧Ciss4⇒closedialogue(agj,agi)inform_scheme(agi,agj,⟨sni,C,P,CQ⟩)∧Ciss5⇒justify(agj,agi,S′)

where:

Ciss1=∄⟨S′,p‾⟩snjθ:(Δagj∪CSagi)⊧⟨S′,p‾⟩snjθ∧Op(agj)∧subject(p)Ciss2=∃⟨S′,p‾⟩snjθ:(Δagj∪CSagi)⊧⟨S′,p‾⟩snjθ∧p‾∉CSagj∧Op(agj)∧subject(p)Ciss3=∃cq‾θ:(Δagj∪CSagi)⊧cq‾θ∧cq‾θ∉CSagj∧cqθ∈CQCiss4=∄⟨S′,p⟩snjθ:(Δagj∪CSagi)⊧⟨S′,p⟩snjθ∧⟨S′,p⟩snjθ∉CSagj∧Pr(agj)∧subject(p)Ciss5=∃⟨S′,p⟩snjθ:(Δagj∪CSagi)⊧⟨S′,p⟩snjθ∧⟨S′,p⟩snjθ∉CSagj∧Pr(agj)∧subject(p)

The dialogue then follows as when the agent receives a justify move being aware of the argumentation scheme used by agi, recovering the subject of the dialogue, accepting the subject of the dialogue, Ciss1, if the justification received from the proponent has made the subject of the dialogue acceptable to it, otherwise either the agent will assert that it is committed to supporting a claim against the subject of the dialogue when it has an argument against it, Ciss2, or it will assert that some critical question related to that argument are not positively answered, Ciss3. In the case in which the agent that receives the justify move from the opponent cannot itself reach the same conclusion, given the new information received (i.e., the agent does not have an acceptable argument for the subject of the dialogue anymore), the agent closes the dialogue, Ciss4. In the final case, the agent sends a new argument1414 to support the subject of the dialogue, Ciss5.

5.3.2.Implementation in Jason agents

The dialogue rules presented in the previous section can be easily implemented in multi-agent platforms in which agent practical reasoning is inspired by reactive planning systems, such as the Jason platform [12]. In Jason, when an agent receives a message, an event of the form +!msg_received(Sender,Performative,Content) is generated to the receiver agent, and the agent can handle that event thereby generating new goals. To achieve their goals, agents look for plans. Thus, the dialogue rules presented in this section can be implemented as agents plans that aim to respond to received messages.

The number of plans to handle the event of receiving a particular message will be equivalent to the number of dialogue rules that restrict the next possible move with which the agent can respond. For example, the assert rules presented in the previous section can be implemented using the following agent plans:

Similarly, other conditions used in dialogue rules can be easily implemented using our framework through a code library that we implemented and made publicly available [47, 55].

5.3.3.Experiments

We ran some experiments to show different dialogues resulting from the protocol presented in Section 5.3 and implemented in our framework. In our experiments, two agents, named proponent and opponent, use the argumentation scheme role to know in order to argue about whether smoking causes cancer or not, based on assertions by hospital staff. So agent proponent starts a dialogue asserting that causes(smoking,cancer), which becomes the subject of the dialogue. The proponent’s knowledge is denoted by Δproponent, as defined below.

Δproponent=reliable(john)¬reliable(pietro)asserts(john,causes(smoking,cancer))role(john,doctor)role_to_know(doctor,cancer)about(causes(smoking,cancer),cancer).

In the case where agent opponent has no argument against the subject of the dialogue, i.e., causes(smoking,cancer), it accepts the opening assertion, as shown in the output from our implementation in Fig. 5.

Fig. 5.

First example.

In the case where agent proponent has an argument against the subject of the dialogue, we have a different output.

Δopponent=asserts(pietro,¬causes(smoking,cancer))role(pietro,doctor)role_to_know(doctor,cancer)about(causes(smoking,cancer),cancer).

Considering the opponent’s knowledge represented as Δopponent, in which the opponent agent assumes that Pietro is reliable and he is a doctor, initially the opponent has an argument against the subject of the dialogue. But, after receiving the information that Pietro is not reliable from proponent, it accepts the subject of the dialogue. The output of this dialogue is shown in Fig. 6.

Fig. 6.

Second example.

These two first examples demonstrate dialogues that occur when we do not have chained arguments. Using chained arguments, agents may have more interesting dialogues. For example, continuing our example from Section 4.1, imagine that the proponent agent has asked reliability advisers about whether Pietro and John are reliable sources of information or not. Then, the proponent is able to provide an argument supporting that Pietro is not reliable, i.e., ¬reliable(pietro), based on those advisers’ assertions (in our example, Ana’s assertion). The output of this dialogue is showed in Fig. 7.

Fig. 7.

Third example.

Fig. 8.

Fourth example.

The dialogue shown in Fig. 7 demonstrates an example in which agents are able to argue about the critical questions pointed by the argumentation scheme used to instantiate the arguments used during the dialogues. Besides, agents are also able to argue about the premises of arguments. For example, imagine that the opponent agent believes that Pietro is a doctor because he is dressing white and he is in the hospital, i.e., role(pietro,doctor) is a belief the opponent creates based on its own perception; however, Pietro is actually a member of the cleaning staff. Also, imagine that the proponent knows that Pietro is a cleaner because the hospital director Mathew has told so. Thus, continuing our example, also based on the example from Section 3, the output of this dialogue is shown in Fig. 8.

6.Discussion

There are some interesting properties of our approach that are important for the development of multi-agent systems when applying our argumentation framework. One important property is that our approach is general regarding the computational representation of argumentation schemes of different forms, with or without implicit critical questions, with any number of premises and critical questions, etc. The generality of the knowledge representation is further discussed in Panisson’s PhD thesis [44], in which a set of argumentation schemes from the literature are represented using the same formalisation used in this paper. It is shown that our approach allows us to represent argumentation schemes of different levels of specificity, including those that use chained arguments (supporting premises and critical questions), as well as argumentation schemes with and without critical questions. To the best of our knowledge, there is no other computational representation for argumentation schemes with critical questions, whether formalised or implemented, in the specific context of agent-oriented programming languages.

Our approach keeps the essence of argumentation schemes discussed by Walton [89] into the knowledge representation, reasoning, and dialogues, while also keeping the knowledge engineering of argumentation schemes as straightforward as possible. To model an argumentation scheme into our approach, engineers only need to think about the premises, conclusion, and critical question that will implement that reasoning pattern, representing such information using first-order formulas and linking them by a defeasible inference rule (premises and conclusion) and labels (inference rule and associated critical questions). After that, in case there are critical questions or premises resulting from other argumentation schemes (if the application requires nested argumentation schemes), they only need to model those argumentation schemes in the same way, matching the conclusion of that argumentation scheme with the corresponding premise or critical question. When reasoning, agents are going to evaluate arguments that are instances of those argumentation schemes, and being aware of the reasoning pattern being used to instantiate a particular argument, agents are able to link the critical questions associated with it, bringing to light that implicit information used to construct the argument, so properly evaluating its validity. Most importantly, during dialogues, agents will communicate arguments similar to how humans do. Also, by identifying the reasoning pattern used by others when instantiating an argument, agents will have a complete understanding of all information used by the speaker to evaluate the validity of the argument, including the implicit information pointed by the critical questions. It is very different from including those critical questions as additional premises into the arguments: in our approach they need not be communicated by agents, which reflects rationality and intelligence as observed in human dialogues, also reflecting some of Grice’s maxims [29]. Also, it is fundamentally different from modelling critical questions as undercutting arguments, in which the receiver of an argument only will be able to evaluate those critical questions when aware of such arguments (which would not be provided by a speaker, typically). Providing the argumentation scheme used to instantiate an argument would be natural for many types of dialogues and in various scenarios such as legal argumentation, for example.

Our approach takes into consideration the role of critical questions in argumentation schemes, covering all the possible roles of critical questions pointed out in [84], i.e., critical questions that: (i) criticise premises, as shown in our examples when criticising the role of an agent; (ii) point out exceptional situations in which the scheme could not be used, as shown in our examples when criticising the reliability of an agent; and (iii) representing conditions for the schemes’ use, given that we are able to model context-dependent argumentation schemes including critical questions of the type: “Is C (the current context) the right context?”, representing it as context(C)[sn], that is, requiring a particular context C that should hold when attempting to instantiate arguments from that scheme, according to Definition 3. Note that such context information is not part of the argument itself, but it is required to reach an acceptable (and rational) conclusion from that argumentation scheme.

Using this computational representation for argumentation schemes combined with the consideration of all roles of the critical questions, we provide a refined and modular argumentation-based reasoning mechanism, in which agents first instantiate and evaluate arguments individually, according to Definition 3, using those acceptable instances of argumentation schemes to check which ones are collectively acceptable given a particular argumentation semantics, according to Definition 6. To the best of our knowledge, there is no other work that proposed argumentation-based reasoning using a general structure for argumentation schemes with implicit critical questions. Also, we provided an empirical evaluation, showing how our (open source) implementation performs according to different levels of specificity for argumentation schemes (single and chained argumentation schemes, with varying numbers of critical questions and premises). Those results might guide the knowledge engineering process of modelling argumentation schemes according to the application needs.

Further, our framework has important properties regarding argumentation-based dialogues: (i) first, we allow agents to be able to communicate argumentation schemes when necessary, solving the problem of scheme awareness as discussed by Wells [91]. Thus, when an agent receives an argument and it is not able to identify which argumentation scheme has been used to instantiate that argument (and consequently not being able to evaluate individually that argument), the agent can ask other agents to inform which argumentation schemes have been used; (ii) second, when engineering multi-agent systems, our approach may guide the modelling of argumentation-based protocols, in regards to the purpose of such dialogues and supporting agents with different levels of bounded rationality; (iii) third, when considering (deep) disagreements among the participants, our approach allows agents to engage in subdialogues concerning the critical questions related to the argumentation schemes used to instantiate arguments, in the fashion of a dialogue-subdialogue structure. Althgouh this is part of our ongoing research efforts, note that it means agents possibly entering into a subdialogue about some implicit information used in that argument, as shown in the dialogue in Fig. 7, which has feature that may be regarded as intelligent behaviour for autonomous agents.

Finally, our work provides interesting directions for the development of Explainable AI [30, 31] and the interaction between humans and agents in the context of Hybrid Intelligence [1]. When modelling argumentation schemes to this end (explainability), agents are directly able to create, evaluate, and communicate arguments providing explanations for one another or for humans [41]. Templates of the argumentation schemes can be used to provide a translation between the natural language and the computational representation of arguments, allowing for more sophisticated human-agent interactions [51], or even using chatbot technologies [20–22]. These research directions are part of our ongoing work.

7.Related work

Related work exists using argumentation schemes in multi-agent systems [28, 34, 46, 57, 79, 81], all of which concern the modelling and using one (two in [46]) argumentation scheme that covers the application needs. However, none of those approaches proposes a general representation of argumentation schemes in agent-oriented programming languages.

In [71], the authors have described a formal account for argumentation schemes; however, such formal representation does not directly give to agents a mechanism either for reasoning with schemes or for constructing arguments using schemes. That work focused on the integration of the ARAUCARIA [70] tool (used to specify argumentation schemes) and agent platforms. Although we took inspiration from [71], we proposed a general structure for argumentation schemes in agent-oriented programming languages, which directly enables agents to use such representation for reasoning and communication.

In [84], the authors described a method to investigate argumentation schemes, which consists of: (i) determining the relevant types of sentences; (ii) determining the argumentation schemes; (iii) determining the exceptions blocking the use of the argumentation schemes; (iv) determining the conditions for the use of the argumentation scheme. We took inspiration from [84], using the desiderata for computational models of argumentation schemes, and [89], as a guide to propose a general structure for argumentation schemes, also considering all roles that critical questions could play.

In [15], the authors introduce a proposal to represent and share arguments, called the Argument Interchange Format (AIF), which represents a standard “abstract model” established by researchers across the fields of argumentation, artificial intelligence, and multi-agent systems. As described in [15], one of the major barriers to the development and practical deployment of an argumentation system is the lack of shared, agreed notation for argumentation and arguments. AIF aims to establish the following principles: (i) a machine-readable syntax for argumentation schemes; (ii) an explicit and machine-processable semantics for argumentation schemes; (iii) a unified abstract model with multiple reifications; (iv) core concepts within multiple extensions. AIF has at its core arguments and argument networks, communication (locutions and protocols), and context (the environment in which argumentation takes place). The AIF has been extended to capture dialogic argumentation in [72]. Furthermore, in [66], the authors also extend AIF to incorporate the representation of argumentation schemes by Walton [89]. Thus, critical questions are considered through a particular ontological relation named hasException, which points out the exceptions that can lead an argument to being considered unacceptable by a reasoning agent. Also, an ontological relation named hasPresumption is used to represent the information that is not explicit in the argument, as in the case of the credibility of a source in the argumentation scheme from role to know described in Section 2.2. AIF also has been used in interesting proposals that aim to create a Web infrastructure (Argument Web) that allows for storage and automatic retrieval and analysis of linked argument data [15]. Although the AIF provides a means for sharing arguments, to the best of our knowledge, there is no work on the integration of AIF and agent-oriented programming languages, and such an integration would be an interesting approach to pursue. In our approach, the AIF could be used to represent arguments at a higher level, allowing agents to share that knowledge in a multi-agent system. Those arguments and argumentation schemes could be translated into an agent-oriented programming language based on our approach, using our knowledge representation, which can be directly manipulated by agents, considering that agents can manipulate arguments and argumentation schemes represented using our approach in the same manner as they manipulate their beliefs.

In [93], the authors classify different levels of representation for argumentation schemes found in the literature, namely: (i) atomic level; (ii) functional roles and typed propositional functions; (iii) functional roles and instantiated predicates; (iv) labelled roles and strings; and (v) canonical sentences. Thus, the authors in [93] propose a functional language for computational analysis of argumentation schemes, so that different argumentation schemes can be compared. Although our aim is not to investigate the relationship between different argumentation schemes but to represent argumentation schemes in agent-oriented programming languages in order for the agents to be directly able to manipulate them, we took some inspiration from [93], inheriting the most refined and detailed representation for argumentation schemes given by (ii).

In [91], the authors describe how argumentation schemes could be exploited in dialogue games, introducing the idea of “scheme awareness”, providing not only a guideline for the development of new dialogue games using argumentation schemes but also a mechanism to extend dialogue-game frameworks to account for scheme awareness. They claim that current approaches to dialogue games can be categorised into three levels: (i) games unable to utilise argumentation schemes; (ii) games able to utilise a single scheme; and (iii) games able to utilise multiple/arbitrary schemes. Also, they claim that currently there are no approaches to games at level (iii). Whilst our work focuses on how agents represent, manipulate, and instantiate arguments from an internal representation of argumentation schemes to carry out argumentation-based reasoning, our approach forms the basis for argumentation-based dialogues using multiple argumentation schemes, i.e., as in (iii), given that agents can reason over any number of argumentation schemes, communicate those arguments, and communicate the argumentation schemes used to instantiate those arguments when necessary.

In [33], the authors present an approach for structured argumentation in multi-agent system dialogues. The authors claim that the use of argumentation in inter-agent dialogues may be beneficial to the agents. Also, they state that existing work on the experimental evaluation of the benefits of argumentation in agent dialogues make use of very simple models of argumentation, in which arguments have no or very little structure. We follow some directions pointed out in [33], defining a complete structure for arguments based on argumentation schemes, and experimentally evaluating our approach for argumentation-based dialogues.

The idea of labelling arguments with meta-information used in this paper comes from Gabbay’s work [24], further developed by other authors in [13, 14, 16, 45, 56]. While all that work focuses on modelling an argumentation framework in which the labels play an important role in the inference mechanism (mostly propagating strength of premises to the conclusions of arguments), here we propose a more modest use in which labels are used to make reference to argumentation schemes used to instantiate those arguments, pointing out the critical questions related to those instances of arguments.

In [41], the authors explore two important contributions of Walton’s work to AI (particularly in the design of autonomous software agents able to reason and argue with one another), namely argumentation schemes and dialogue protocols, describing how they may apply to current research on Explainable AI by automated decision-making systems. The authors also mention an example of how argumentation schemes could be chained, not only regarding their premises and conclusion but also regarding the critical questions, in which the answer of a critical question could be the conclusion of an argumentation scheme. The work presented by [41] inspired us to develop our argumentation-scheme-centred framework, keeping the essence of argumentation schemes presented by Walton’s work. Our approach moves towards the directions pointed out in [41] for using argumentation schemes in multi-agent systems, which also can be used to support explainability. Some initial steps towards this direction are found in [51].

In [6, 64], the authors present a formal account of legal reasoning, which can be seen as moving from evidence to facts, from facts to factors, and from factors to legal consequences. Their previous work, the CATO system presented in [2] and [8], implemented a single step of argumentation, concerning the last phase for legal reasoning, i.e., moving from factors to legal cases. Thus, they extend CATO system to bring the assignment of factors within the scope of the system, i.e., moving from facts to factors, and so open this aspect to explicit argumentation [6]. The authors propose CATO style argumentation schemes, in which schemes and undercutting attacks associated with them are formalised as defeasible inference rules within the ASPIC+ framework [42]. Differently from our approach, they use CATO style argumentation schemes. Argumentation schemes correspond to defeasible inference rules in ASPIC+, in which premises can be axioms (indisputable facts) or the conclusion from another argumentation scheme. Attacks are captured by defining undercutting CATO style argumentation schemes, which allow instantiating arguments against the application of another CATO style argumentation scheme. Undercutting arguments also may have undercutting arguments against their application. The work in [6, 64] moves towards a similar direction, which considers first using argumentation schemes to instantiate arguments (for and against deciding for a plaintiff, in their case), rebutting each other, and later solving those conflicts using argument graphs (with preference, in their case). Their formalism allows using nested argumentation schemes, similar to our approach. However, while undercutting schemes enable capturing the critical questions related to an argumentation scheme, their approach requires using nested argumentation schemes to model critical questions. That is, undercutting schemes allow agents to look for arguments concluding that the previous scheme does not apply in that particular case, implementing one particular role for critical questions [84]. Also, the approach in [64] may require more effort from the knowledge engineering point of view, in which modelling critical questions requires additional argumentation schemes.

8.Conclusion

In this paper, we have presented an argumentation framework developed on top of an agent-oriented programming language, in which argumentation schemes are at the core of the framework.

We first proposed a general structure for argumentation schemes represented in agent-oriented programming languages, in which argumentation schemes of different levels of specificity can be modelled, allowing the development of applications that use argumentation schemes with and without implicit critical questions, as well as using single or chained argumentation schemes.

We then presented an argumentation-based reasoning mechanism, in which agents consider those modelled argumentation schemes in order to construct and define the acceptability of arguments. In order to evaluate our framework in regards to argumentation-based reasoning, we implemented our framework and ran some experiments to show the performance of agents that follow our approach, considering different levels of specificity of argumentation schemes, i.e., using single and chained argumentation schemes. Our results confirm our initial hypothesis that using argumentation schemes without chained arguments is computationally more efficient than using chained arguments. These results reflect on the development of intelligent agents with different levels of bounded rationality, and also might guide knowledge engineers in the process of modelling argumentation schemes. While using a single argumentation scheme has been sufficient for the development of many multi-agent applications using argumentation [28, 34, 57, 79, 81], there are application domains in which a more complex reasoning process is required, for example, [46, 64], and our implementation supports both approaches.

We also presented an approach for argumentation-based dialogues using argumentation schemes, defining a protocol for argumentation-based dialogues that combines deliberation and information-seeking dialogues. We implemented that protocol for Jason agents [12], and showed different lines of argumentation using that protocol. Not only did we validate our framework through those examples, but we also provided a solution for the problem of scheme awareness described in [91].

Finally, we discussed how our work contributes to the development of the area of argumentation in multi-agent systems. We also discuss how our work moves towards the practical use of argumentation as a technique for explainable AI [30, 31]. In future work, we intend to implement applications with human-agent interaction using argumentation schemes. We intend to use argumentation schemes represented in both natural language and the formal representation presented in this work, as in [51], so that agents can use the appropriate representation depending on whether they are communicating with software agents or with human beings.