A computational model of argumentation schemes for multi-agent systems

Abstract

There are many benefits of using argumentation-based techniques in multi-agent systems, as clearly shown in the literature. Such benefits come not only from the expressiveness that argumentation-based techniques bring to agent communication but also from the reasoning and decision-making capabilities under conditions of conflicting and uncertain information that argumentation enables for autonomous agents. When developing multi-agent applications in which argumentation will be used to improve agent communication and reasoning, argumentation schemes (reasoning patterns for argumentation) are useful in addressing the requirements of the application domain in regards to argumentation (e.g., defining the scope in which argumentation will be used by agents in that particular application). In this work, we propose an argumentation framework that takes into account the particular structure of argumentation schemes at its core. This paper formally defines such a framework and experimentally evaluates its implementation for both argumentation-based reasoning and dialogues.

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

2.1. Argumentation in artificial intelligence and multi-agent systems

Computational argumentation has been largely studied as an abstract formalism [19], which provides important insights into the nature of argumentation. In abstract argumentation, arguments are represented as atomic entities and they have no internal structure. Thus, arguments and attacks between arguments are left unspecified. This abstract perspective provides some advantages in studying argumentation [10], in which it is possible to consider only the semantic level, i.e., given a set of arguments and an unspecified attack relation it is possible to analyse which arguments are acceptable in that set/context/perspective.

When we need a more detailed formalisation than abstract argumentation, regarding the structure of arguments and the nature of attack relations, we need to adopt a formalism based on structured argumentation, which specifies a computational model of argument [10]. In structured argumentation, a formal language is used to represent knowledge, and arguments and counterarguments can be constructed from that knowledge. Arguments are structured in the sense that premises and conclusion of arguments are made explicit, and the relationship between premises and conclusion is formalised, normally using logical entailment. Attacks between arguments than can be formalised identifying conflicting information in their structure. The best known structured argumentation frameworks are ASPIC+ [42], Assumption-Based Argumentation (ABA) [80], Defeasible Logic Programming (DeLP) [26], and Deductive Argumentation [11].

Studies in computational models of argument can be classified into two classes: monological argumentation and dialogical argumentation [10]. Monological argumentation has an emphasis on analysing a set of arguments and counterarguments (generated from some knowledge or a neutral third party), evaluating them in order to define which ones are acceptable and, consequently, making decisions based on the conclusions of those acceptable arguments. Dialogical argumentation has an emphasis on the exchange of arguments and counterarguments between agents, including not only how arguments are generated and evaluated (i.e., monological argumentation) but also how agents interact, how agents change their beliefs, protocols, and strategies that agents can adopt in argumentation-based dialogues.

In artificial intelligence, particularly in multi-agent systems, monological argumentation is used to implement reasoning mechanism for agents, in which agents are able to execute reasoning over uncertain and conflicting information, reaching well supported conclusions, and consequently, well supported decisions [17, 47, 65]. On the other hand, dialogical argumentation is used to design and implement argumentation-based communication between agents. Using a variety of types of dialogues, for example those described in [88], agents are able to explain their positions in a deliberation dialogue, to persuade their opponents in a negotiation, and so forth [4, 33, 38, 58, 59]. Normally, approaches to dialogical argumentation have a direct dependence on some monological argumentation framework, given that agents first need to construct and evaluate arguments from the knowledge available to them (their knowledge bases and arguments from others agents), then they can communicate arguments in argumentation-based dialogues. Also, some approaches use a third party in argumentation-based dialogues in order to describe the current “winning” arguments in that dialogue; this agent executes monological argumentation over the other agents’ arguments, for example, as in [62].

The history of development, from abstract argumentation to structured argumentation, have made the field of computational argumentation mature in theory, and a few approaches to applying argumentation-based techniques in multi-agent systems started to appear in practice. Most of this practical work focuses on using an argumentation scheme (reasoning pattern) as the core component of the argumentation mechanism. Normally, the argumentation scheme used is specified for particular applications, modelling the needs of that application domain. For example, in [81] argumentation schemes have been specified for analysing the provenance of information, in [57] argumentation schemes have been specified for reasoning about trust, in [77] argumentation schemes have been specified for arguing about transplantation of human organs, in [46] argumentation schemes have been specified for implementing data access control between smart applications, and so forth. Thus, we believe that argumentation schemes can play an important role in the development of applications that take advantage of argumentation-based techniques, as the literature also suggests.

However, even though some authors (e.g., [48, 63, 70]) have suggested that argumentation schemes could be represented into such structured argumentation frameworks, for example using defeasible inferences rules, there is no formal and general framework that takes into account the particular structure of argumentation schemes in multi-agent systems, e.g., capturing the role of the implicit critical questions associated with each argumentation scheme. Similar claims that reinforce the missing computational representation for argumentation schemes can be found in papers by others, for example in [7]: “Douglas Walton’s influential argumentation schemes remain an important insight, one which needs to be embraced by computational modelling of argument. His work comes from informal logic and was designed for manual analysis of argumentation. For computational purposes much detailed work remains to be done before the use of argumentation schemes can be as standard and well understood as logical deduction” [7].

In this work, we propose a formal argumentation framework in multi-agent systems in which argumentation schemes are the core of the framework. Our approach considers a general structure for representing argumentation schemes (with or without implicit critical questions).

2.2. Argumentation schemes

Argumentation schemes are patterns for arguments (or 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 argumentation [87, 89]. Besides the familiar deductive and inductive forms of arguments, argumentation schemes represent forms of arguments that are defeasible.1

¹

Sometimes called presumptive, or abductive as well.

This means that an argument may not be strong by itself (i.e., it is based on disputable inferences), but it may be strong enough to provide evidence that warrants rational acceptance of its conclusion [83]. Conclusions from argumentation schemes can be inferred in conditions of uncertainty, lack of knowledge, lack of resources, or insufficient time. This means that the reasoner must remain open-minded to new pieces of evidence that can invalidate previous conclusions [89]. These circumstances of uncertainty and lack of knowledge, resources, or time are, inevitably, characteristics of multi-agent systems, which deal with dynamic environments and organisations [92]. Thus, argumentation schemes have a natural application in multi-agent systems.

Many arguments include non-explicit (implicit) conditional premises or warrants, linking the explicit premises to the conclusion. Critical questions pointed by the argumentation scheme used to instantiate an argument are used to reveal such implicit information, playing an important role shifting the dialogue (or reasoning) to the revealed information [87]. Thus, the acceptance of a conclusion from an instantiation of an argumentation scheme is directly associated with so-called critical questions, which may be asked before the default conclusion from an argument (labelled by an argumentation scheme) is accepted. Together, the argumentation scheme and the matching set of critical questions are used to evaluate a given argument in a particular case, considering the context in which the argument occurred [89].

Arguments instantiated from argumentation schemes and properly evaluated utilising their critical questions can be used by agents in their reasoning and communication processes. In both situations, other arguments, probably instantiated from other argumentation schemes, are compared in order to arrive at an acceptable conclusion. After an argument is instantiated from an argumentation scheme and evaluated by its set of critical questions, the process follows the same principle of any argumentation-based approach, where arguments for and against a point of view (or just for an agent’s internal decision making) are compared until eventually arriving at a set of acceptable arguments.

To exemplify our approach, we adapted the argumentation schemes Argument from Position to Know from [87] to the context of a multi-agent (organisational) platform, so that we are able to refer to concepts present in multi-agent systems, for example roles that agents play in the system can be referred to within the scheme (it enables a clear reference to concepts of multi-agent systems). Consider the Argument from role to know in multi-agent systems [48] (role to know for short):

“Agent $\mathit{Ag}$ is currently playing a role R (its position) that implies knowing things in a certain subject domain S containing proposition A(Major Premise). $\mathit{Ag}$ asserts that A (in domain S) is true (or false) (Minor Premise). A is true (or false) (Conclusion)”.

The associated critical questions are: CQ1: Does playing role R imply knowing whether A holds? CQ2: Is $\mathit{Ag}$ an honest (trustworthy, reliable) source? CQ3: Did $\mathit{Ag}$ assert that A is true (or false)? CQ4: Is $\mathit{Ag}$ playing role R?

The argumentation scheme from role to know (and the argumentation scheme from position to know as well) exemplify some aspects of argumentation schemes pointed out by Walton in [87]:

“argumentation schemes have more of a rhetoric or persuasive function than a logical function”

in which the position/role and trustworthiness of the individual from where the information comes has an important weight in evaluating an argument instantiated from those schemes. Instantiating this argumentation scheme means replacing the variables $\mathit{Ag}$ , R, A and S with some atomic formulas from the application domain, as we will see in the next section.

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 schemes2

²

Extensively used in other areas, for example teaching critical thinking skills.

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æ $\{{\mathit{p}}_0\mathrm{,}\dots \mathrm{,}{\mathit{p}}_{\mathit{n}}\}\in \mathit{L}$ , and a set of defeasible inference rules $\{\mathrm{(}{\mathit{p}}_{\mathit{i}}\mathrm{,}\dots \mathrm{,}{\mathit{p}}_{\mathit{j}}\Rightarrow {\mathit{p}}_{\mathit{k}}\mathrm{)}\mathrm{,}\dots \mathrm{,}\mathrm{(}{\mathit{p}}_{\mathit{l}}\mathrm{,}\dots \mathrm{,}{\mathit{p}}_{\mathit{m}}\Rightarrow {\mathit{p}}_{\mathit{o}}\mathrm{)}\}\in \mathit{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., $\neg \mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}$ means that $\mathtt{pietro}$ is not reliable. We also use negation as failure “ $\mathtt{not}$ ”, e.g., $\mathtt{not}\mathrm{(}\mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}\mathrm{)}$ means that an agent does not know if $\mathtt{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., ${\mathit{p}}_{{\mathit{l}}_{[\mathit{sn}]}}$ and ${\{{\mathit{p}}_{\mathit{i}}\wedge \cdots \wedge {\mathit{p}}_{\mathit{j}}\}}_{[\mathit{sn}]}$ are used to represent critical questions related to the argumentation scheme $\mathit{sn}$ , and ${\mathrm{(}{\mathit{p}}_{\mathit{l}}\mathrm{,}\dots \mathrm{,}{\mathit{p}}_{\mathit{m}}\Rightarrow {\mathit{p}}_{\mathit{o}}\mathrm{)}}_{[\mathit{sn}]}$ is used to represent the defeasible inference rule corresponding to the inference modelled by the argumentation scheme $\mathit{sn}$ .

Further, all knowledge available to an agent $\mathtt{ag}$ is represented as ${\mathrm{\Delta }}_{\mathtt{ag}}$ . When an agent $\mathtt{ag}$ is aware of some information ψ (i.e., ψ is part of or can be inferred from its belief base), we write ${\mathrm{\Delta }}_{\mathtt{ag}}\vDash \mathit{\psi }$ , with $\mathit{\psi }\in \mathit{L}$ . For example, when an agent $\mathtt{ag}$ is aware of a defeasible inference rule $\mathrm{(}{\mathit{p}}_{\mathit{l}}\mathrm{,}\dots \mathrm{,}{\mathit{p}}_{\mathit{m}}\Rightarrow {\mathit{p}}_{\mathit{o}}\mathrm{)}$ we write ${\mathrm{\Delta }}_{\mathtt{ag}}\vDash \mathrm{(}{\mathit{p}}_{\mathit{l}}\mathrm{,}\dots \mathrm{,}{\mathit{p}}_{\mathit{m}}\Rightarrow {\mathit{p}}_{\mathit{o}}\mathrm{)}$ . For example, ${\mathrm{\Delta }}_{\mathtt{ag}}\vDash \mathrm{(}\mathtt{penguin}\mathrm{(}\mathtt{X}\mathrm{)}\Rightarrow \neg \mathtt{flies}\mathrm{(}\mathtt{X}\mathrm{)}\mathrm{)}$ means that agent $\mathtt{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:

Definition 1 (Argumentation scheme).

Formally, an argumentation scheme is a tuple $⟨\mathit{sn}\mathrm{,}\mathit{C}\mathrm{,}\mathit{P}\mathrm{,}\mathit{CQ}⟩$ with $\mathit{sn}$ the argumentation scheme identifier (i.e., its name), C the conclusion of the argumentation scheme, P the premises, and $\mathit{CQ}$ the associated critical questions.

Considering the logic language L, an argumentation scheme $⟨\mathit{sn}\mathrm{,}\mathit{C}\mathrm{,}\mathit{P}\mathrm{,}\mathit{CQ}⟩$ is represented using a (not ground) defeasible inference rule of the type ${\mathrm{(}{\mathit{p}}_{\mathit{i}}\mathrm{,}\dots \mathrm{,}{\mathit{p}}_{\mathit{j}}\Rightarrow {\mathit{p}}_{\mathit{k}}\mathrm{)}}_{[\mathit{sn}]}$ , in which $\{{\mathit{p}}_{\mathit{i}}\mathrm{,}\dots \mathrm{,}{\mathit{p}}_{\mathit{j}}\}=\mathit{P}$ and ${\mathit{p}}_{\mathit{k}}=\mathit{C}$ . Note that the inference rule is annotated3

³

We took inspiration from Labelled Deductive Systems (LBS) [24, 25] to model annotated formulæ.

with the name of the argumentation schemes $\mathit{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 $\{{\mathit{p}}_{0_{[\mathit{sn}]}}\mathrm{,}\dots \mathrm{,}{\mathit{p}}_{{\mathit{n}}_{[\mathit{sn}]}}\}\in \mathit{L}$ , with $\{{\mathit{p}}_{0_{[\mathit{sn}]}}\mathrm{,}\dots \mathrm{,}{\mathit{p}}_{{\mathit{n}}_{[\mathit{sn}]}}\}=\mathit{CQ}$ .

For example, the argumentation scheme role to know can be represented using the following defeasible inference rule:4 ⁴

Recall that an argumentation scheme is a non grounded reasoning pattern.

with the argumentation scheme name $\mathit{sn}=$ role_to_know, the conclusion C = Conclusion, and premises $\mathit{P}=\{$ role(Agent,Role), role_to_know(Role,Domain), asserts(Agent, Conclusion), about(Conclusion,Domain)}.

The associated critical questions $\mathit{CQ}$ are:

• role_to_know(Role,Conclusion) _{[as(role_to_know)]} .

• reliable(Agent) _{[as(role_to_know)]} .

• asserts(Agent,Conclusion) _{[as(role_to_know)]}

• role(Agent,Role) _{[as(role_to_know)]} .

Definition 2 (Argument).

An argument is a tuple ${⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{\mathtt{sn}}^{\mathit{\theta }}$ , where $⟨\mathtt{sn}\mathrm{,}\mathit{P}\mathrm{,}\mathit{C}\mathrm{,}\mathit{CQ}⟩$ is the argumentation scheme used to instantiate that argument, θ is a most-general unifier for the premises in P and the agent’s current beliefs, S is the set of premises and the inference rule of the scheme used to draw c (the conclusion of the argument). That is, S includes all instantiated premises from P – i.e., for all $\mathit{p}\in \mathit{P}$ , $\mathit{p}\mathit{\theta }\in \mathit{S}$  – and the inference rule corresponding to the scheme ( $\mathit{P}\Rightarrow \mathit{C}$ ); the conclusion c is the instantiation $\mathit{C}\mathit{\theta }$ such that $\mathit{S}\vDash \mathit{c}$ (c can be inferred from S).

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

Note that an agent can instantiate different arguments, say ${⟨{\mathit{S}}_1\mathrm{,}{\mathit{c}}_1⟩}_{\mathtt{sn}}^{{\mathit{\theta }}_2}$ and ${⟨{\mathit{S}}_2\mathrm{,}{\mathit{c}}_2⟩}_{\mathtt{sn}}^{{\mathit{\theta }}_1}$ , from the same argumentation scheme $\mathtt{sn}$ , when ${\mathit{\theta }}_1\ne {\mathit{\theta }}_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 $\mathtt{pietro}$ , asserts that “smoking does not cause cancer” – $\mathtt{asserts}\mathrm{(}\mathtt{pietro}\mathrm{,}\neg \mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}\mathrm{)}$ . Any agent aware of both assertion, John’s and Pietro’s assertions, is able to construct conflicting arguments for $\neg \mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ and $\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ (as we will see later, both attacking each other). However, the agents are able to question whether $\mathtt{john}$ and $\mathtt{pietro}$ are reliable (trustworthy) sources, if they really play the role of $\mathtt{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.5

⁵

Different agent profiles can be explored, for example, those presented in [58, 60]; they will be considered in our future work when applying our framework in argumentation-based dialogue. When using our framework for argumentation-based reasoning, it makes sense an agent to evaluate such arguments being able to answer all critical questions related to them.

For example, imagine that an agent has the information that “Pietro is not a reliable source” – $\neg \mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}$ . In that case, that agent is not able to answer positively the critical question $\mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}$ , 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 $\neg \mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ might not be an acceptable instance of the argumentation scheme role to know for such a rational agent.

Definition 3 (Acceptable instance of an argument from an argumentation scheme).

An argument ${⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{\mathtt{sn}}^{\mathit{\theta }}$ , instantiated from an argumentation scheme $⟨\mathtt{sn}\mathrm{,}\mathit{P}\mathrm{,}\mathit{C}\mathrm{,}\mathit{CQ}⟩$ , is an acceptable instance of that argumentation scheme to an agent $\mathit{ag}$ (with ${\mathrm{\Delta }}_{\mathtt{ag}}$ its knowledge base) iff: (i) for all premises $\mathit{p}\in \mathit{S}$ , ${\mathrm{\Delta }}_{\mathit{ag}}\vDash \mathit{p}\mathit{\theta }$ either because p is asserted in its knowledge base, or because p can be inferred from ${\mathrm{\Delta }}_{\mathit{ag}}$ (possibly using other acceptable instances of argumentation schemes); and (ii) all critical questions related to the argumentation scheme $⟨\mathtt{sn}\mathrm{,}\mathit{C}\mathrm{,}\mathit{P}\mathrm{,}\mathit{CQ}⟩$ are positively answered by $\mathit{ag}$ , that is, $\forall {\mathit{Cq}}_{\mathit{i}}\in \mathit{CQ}$ , ${\mathrm{\Delta }}_{\mathit{ag}}\vDash {\mathit{Cq}}_{\mathit{i}}\mathit{\theta }$ .

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.6

⁶

In ASPIC+ for example, attacks against the premises are described as undermine attacks [42].

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 – $\mathtt{not}\mathrm{(}\neg \mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}\mathrm{)}$ (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.

Definition 4 (Conflicting information).

Two pieces of information φ and ψ are said to be in conflict with each other when:

ψ and φ are the negation of each other, e.g., $\mathit{\psi }=\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ and $\mathit{\phi }=\neg \mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ .

ψ and φ are semantically declared as conflicting information, i.e., $\mathit{\psi }=\mathtt{reliable}\mathrm{(}\mathtt{john}\mathrm{)}$ and $\mathit{\phi }=\mathtt{unreliable}\mathrm{(}\mathtt{john}\mathrm{)}$ , with some declaration of complement, conflict, or contrary information, e.g., $\mathtt{complement}\mathrm{(}\mathtt{reliable}\mathrm{(}\mathtt{X}\mathrm{)}\mathrm{,}\mathtt{unreliable}\mathrm{(}\mathtt{X}\mathrm{)}\mathrm{)}$ .

For both cases we adopt a general operator for conflict $\bar{\mathit{\psi }}$ , in which $\mathit{\phi }\equiv \bar{\mathit{\psi }}$ means that ψ and φ are conflicting information. It follows that $\neg \mathit{\varphi }\equiv \bar{\mathit{\varphi }}$ and $\mathit{\varphi }\equiv \overline{\neg \mathit{\varphi }}$ .

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

Definition 5 (Attacks between arguments).

An argument ${⟨{\mathit{S}}_1\mathrm{,}{\mathit{c}}_1⟩}_{\mathtt{s}{n}_i}^{{\mathit{\theta }}_1}$ attacks another argument ${⟨{\mathit{S}}_2\mathrm{,}{\mathit{c}}_2⟩}_{\mathtt{s}{n}_j}^{{\mathit{\theta }}_2}$ , when:

${\mathit{c}}_1$ is in conflict with ${\mathit{c}}_2$ , i.e., ${\mathit{c}}_1\equiv \overline{{\mathit{c}}_2}$ .

${\mathit{c}}_1$ is in conflict with some part of ${\mathit{S}}_2$ , i.e., ${\mathit{c}}_1\equiv \bar{\mathit{\psi }}$ , with $\mathit{\psi }\in {\mathit{S}}_2$ . $$\begin{array}{c}{\mathrm{\Delta }}_{\mathit{ag}}=\left\{\begin{array}{c}\mathtt{reliable}\mathrm{(}\mathtt{john}\mathrm{)}\hfill \\ \mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}\hfill \\ \mathtt{asserts}\mathrm{(}\mathtt{john}\mathrm{,}\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}\mathrm{)}\hfill \\ \mathtt{asserts}\mathrm{(}\mathtt{pietro}\mathrm{,}\neg \mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}\mathrm{)}\hfill \\ \mathtt{role}\mathrm{(}\mathtt{john}\mathrm{,}\mathtt{doctor}\mathrm{)}\hfill \\ \mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{doctor}\mathrm{)}\hfill \\ \mathtt{role}\text{\_}\mathtt{to}\text{\_}\mathtt{know}\mathrm{(}\mathtt{doctor}\mathrm{,}\mathtt{cancer}\mathrm{)}\hfill \\ \mathtt{about}\mathrm{(}\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}\mathrm{,}\mathtt{cancer}\mathrm{)}.\hfill \end{array}\right\}\end{array}$$

For example, considering an agent $\mathtt{ag}$ and its knowledge base ${\mathrm{\Delta }}_{\mathit{ag}}$ , $\mathtt{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 $\mathtt{ag}$ , and it would not be able to conclude either $\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ or $\neg \mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ . However, imagine that $\mathtt{pietro}$ is not a doctor, i.e., $\mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{doctor}\mathrm{)}$ is not true (it was a misperception of $\mathtt{ag}$ ), and $\mathtt{ag}$ becomes aware of that information through the hospital director named $\mathtt{mathew}$ . $$\begin{array}{c}{\mathrm{\Delta }}_{\mathit{ag}}=\left\{\begin{array}{c}\mathtt{reliable}\mathrm{(}\mathtt{mathew}\mathrm{)}\hfill \\ \mathtt{asserts}\mathrm{(}\mathtt{mathew}\mathrm{,}\mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{cleaning}\text{\_}\mathtt{staff}\mathrm{)}\mathrm{)}\hfill \\ \mathtt{role}\mathrm{(}\mathtt{mathew}\mathrm{,}\mathtt{hospital}\text{\_}\mathtt{director}\mathrm{)}\hfill \\ \mathtt{role}\text{\_}\mathtt{to}\text{\_}\mathtt{know}\mathrm{(}\mathtt{hospital}\text{\_}\mathtt{director}\mathrm{,}\mathtt{employees}\mathrm{)}\hfill \\ \mathtt{about}\mathrm{(}\mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{cleaning}\text{\_}\mathtt{staff}\mathrm{)}\mathrm{,}\mathtt{employees}\mathrm{)}.\hfill \end{array}\right\}\end{array}$$

Given the knowledge that $\mathtt{ag}$ has about the hospital, partially shown above, in ${\mathrm{\Delta }}_{\mathit{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 $\neg \mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ is not an acceptable instance of the argumentation scheme role to know anymore, considering that $\mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{cleaning}\text{\_}\mathtt{staff}\mathrm{)}$ is conflicting information with $\mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{doctor}\mathrm{)}$ (semantically declared at $\mathtt{ag}$ knowledge base). At this point, it would be reasonable for $\mathtt{ag}$ to conclude $\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ .

Definition 6 (Acceptable arguments).

An argument ${⟨{\mathit{S}}_1\mathrm{,}{\mathit{c}}_1⟩}_{\mathtt{s}{n}_i}^{\mathit{\theta }}$ is acceptable to an agent if it is an acceptable instance of the argumentation scheme $\mathtt{s}{n}_i$ , according to Definition 3, and either it is not attacked by any other acceptable argument instance or, when attacked, the attacking argument is itself attacked by an acceptable argument. That is, considering the set of arguments an agent is able to construct from its knowledge base, an acceptable argument is either not attacked by any other argument, or when it is attacked by another argument, that other argument is attacked by some other acceptable argument.

Considering the three arguments above, the argument concluding that $\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ is attacked by the argument concluding $\neg \mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ , which is attacked by the argument concluding $\mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{cleaning}\text{\_}\mathtt{staff}\mathrm{)}$ . Considering that the argument concluding $\mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{cleaning}\text{\_}\mathtt{staff}\mathrm{)}$ is not attacked by any other argument, $\mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{cleaning}\text{\_}\mathtt{staff}\mathrm{)}$ and $\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ are the two acceptable conclusions (and their respective arguments) in our example. We write ${\mathrm{\Delta }}_{\mathtt{ag}}\vDash {⟨{\mathit{S}}_1\mathrm{,}{\mathit{c}}_1⟩}_{\mathtt{s}{n}_i}^{\mathit{\theta }}$ to represent when ${⟨{\mathit{S}}_1\mathrm{,}{\mathit{c}}_1⟩}_{\mathtt{s}{n}_i}^{\mathit{\theta }}$ is an acceptable argument for $\mathtt{ag}$ . Also, we write ${\mathrm{\Delta }}_{\mathtt{ag}}\vDash {\mathit{c}}_1$ to represent that ${\mathit{c}}_1$ is an acceptable conclusion for $\mathtt{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.1. Representing and reasoning with argumentation schemes

It is important to mention that in our approach we are able to specify argumentation schemes for agents with different levels of bounded rationality, depending on the application needs. This is an important characteristic of our approach, given that different applications might require different levels of specificity for argumentation schemes [84]. The most common approach when applying argumentation schemes in multi-agent systems is to consider only one argumentation scheme without chained arguments. Examples of this kind of argumentation schemes are found in [28, 34, 57, 79, 81]. In all those cases, during reasoning, agents check if they are able to construct acceptable instances of arguments from the argumentation schemes, according to Definition 3, used in a particular application domain. When the application domain does not require chained arguments, then premises and critical questions related to an argument are directly asserted (or omitted from) agents’ belief bases. Thus, after constructing acceptable instances of arguments, an agent will check for conflicts between the conclusions of arguments,7

⁷

We are considering that argumentation schemes are consistently modelled, and they do not allow circular arguments [90].

determining the acceptable ones, according to Definition 6. When the application domain requires chained arguments (e.g., as in [46]), agents check if they are able to infer the premises and critical questions of a particular argument, according to Definition 3, then constructing acceptable instances of arguments from the argumentation schemes available to them. Thus, agents check the acceptability of those instances of arguments, checking both kinds of attacks, given that premises can be inferred from arguments and those arguments can be attacked by other arguments.

Consider the argumentation scheme from role to know, extensively used as an example in this paper; its representation was introduced in Section 2.2 followed by a few examples demonstrating how agents are able to reason using arguments instantiated from it. In the first example given, $\mathit{ag}$ uses the argumentation scheme role to know to instantiate arguments for and against the conclusion that “smoking causes cancer”. In the second example, the agent $\mathit{ag}$ uses the same argumentation scheme to construct an argument supporting that Pietro is a cleaner, which then is used to attack the argument concluding that “smoking does not cause cancer” based on Pietro’s assertions, because now $\mathit{ag}$ does not believe Pietro is in a role to know about the subject of cancer. Here, we extend those examples to demonstrate when agents are also able to construct arguments supporting/attacking critical questions of other arguments using this single argumentation scheme.

Imagine a scenario in which an agent $\mathtt{ag}$ needs to make a decision about quitting smoking or not, and it will make that decision based on information about whether smoking causes cancer or not. That is, the agent will quit smoking if it concludes that smoking causes cancer. In our scenario, $\mathit{ag}$ will reason about that conclusion based on Pietro’s and John’s assertions (assuming that both are doctors). $$\begin{array}{c}{\mathrm{\Delta }}_{\mathit{ag}}=\left\{\begin{array}{c}\mathtt{asserts}\mathrm{(}\mathtt{john}\mathrm{,}\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}\mathrm{)}\hfill \\ \mathtt{asserts}\mathrm{(}\mathtt{pietro}\mathrm{,}\neg \mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}\mathrm{)}\hfill \\ \mathtt{role}\mathrm{(}\mathtt{john}\mathrm{,}\mathtt{doctor}\mathrm{)}\hfill \\ \mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{doctor}\mathrm{)}\hfill \\ \mathtt{role}\text{\_}\mathtt{to}\text{\_}\mathtt{know}\mathrm{(}\mathtt{doctor}\mathrm{,}\mathtt{cancer}\mathrm{)}\hfill \\ \mathtt{about}\mathrm{(}\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}\mathrm{,}\mathtt{cancer}\mathrm{)}.\hfill \end{array}\right\}\end{array}$$

However, initially $\mathtt{ag}$ does not know if John and Pietro are reliable, $\mathtt{reliable}\mathrm{(}\mathtt{john}\mathrm{)}$ and $\mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}\notin {\mathrm{\Delta }}_{\mathit{ag}}$ . Thus, $\mathtt{ag}$ asks other agents (we will call those agents reliability advisers) whether Pietro and John are reliable or not, executing a broadcast message and receiving the following assertions from Ana: $\mathtt{asserts}\mathrm{(}\mathtt{ana}\mathrm{,}\mathtt{reliable}\mathrm{(}\mathtt{john}\mathrm{)}\mathrm{)}$ , $\mathtt{asserts}\mathrm{(}\mathtt{ana}\mathrm{,}\neg \mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}\mathrm{)}$ , Jana: $\mathtt{asserts}\mathrm{(}\mathtt{jana}\mathrm{,}\mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}\mathrm{)}$ , $\mathtt{asserts}\mathrm{(}\mathtt{jana}\mathrm{,}\neg \mathtt{reliable}\mathrm{(}\mathtt{john}\mathrm{)}\mathrm{)}$ , and Carlo: $\mathtt{asserts}\mathrm{(}\mathtt{carlo}\mathrm{,}\neg \mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}\mathrm{)}$ , $\mathtt{asserts}\mathrm{(}\mathtt{carlo}\mathrm{,}\mathtt{reliable}\mathrm{(}\mathtt{john}\mathrm{)}\mathrm{)}$ . $$\begin{array}{c}{\mathrm{\Delta }}_{\mathit{ag}}=\left\{\begin{array}{cc}\mathtt{asserts}\mathrm{(}\mathtt{ana}\mathrm{,}\neg \mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}\mathrm{)}\hfill & \hfill \mathtt{asserts}\mathrm{(}\mathtt{ana}\mathrm{,}\mathtt{reliable}\mathrm{(}\mathtt{john}\mathrm{)}\mathrm{)}\\ \mathtt{asserts}\mathrm{(}\mathtt{jana}\mathrm{,}\mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}\mathrm{)}\hfill & \hfill \mathtt{asserts}\mathrm{(}\mathtt{jana}\mathrm{,}\neg \mathtt{reliable}\mathrm{(}\mathtt{john}\mathrm{)}\mathrm{)}\\ \mathtt{asserts}\mathrm{(}\mathtt{carlo}\mathrm{,}\neg \mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}\mathrm{)}\hfill & \hfill \mathtt{asserts}\mathrm{(}\mathtt{carlo}\mathrm{,}\mathtt{reliable}\mathrm{(}\mathtt{john}\mathrm{)}\mathrm{)}\\ \mathtt{role}\mathrm{(}\mathtt{ana}\mathrm{,}\mathtt{reliability}\text{\_}\mathtt{adviser}\mathrm{)}\hfill & \hfill \mathtt{reliable}\mathrm{(}\mathtt{ana}\mathrm{)}\\ \mathtt{role}\mathrm{(}\mathtt{jana}\mathrm{,}\mathtt{reliability}\text{\_}\mathtt{adviser}\mathrm{)}\hfill & \hfill \neg \mathtt{reliable}\mathrm{(}\mathtt{jana}\mathrm{)}\\ \mathtt{role}\mathrm{(}\mathtt{carlo}\mathrm{,}\mathtt{reliability}\text{\_}\mathtt{adviser}\mathrm{)}\hfill & \hfill \mathtt{reliable}\mathrm{(}\mathtt{carlo}\mathrm{)}\\ \mathtt{role}\text{\_}\mathtt{to}\text{\_}\mathtt{know}\mathrm{(}\mathtt{reliability}\text{\_}\mathtt{adviser}\mathrm{,}\mathtt{reliability}\mathrm{)}\hfill \\ \mathtt{about}\mathrm{(}\mathtt{reliable}\mathrm{(}\text{\_}\mathrm{)}\mathrm{,}\mathtt{reliability}\mathrm{)}\hfill \\ \mathtt{about}\mathrm{(}\neg \mathtt{reliable}\mathrm{(}\text{\_}\mathrm{)}\mathrm{,}\mathtt{reliability}\mathrm{)}\hfill \end{array}\right\}\end{array}$$

Considering the assertions made by Ana, Jana, and Carlo (the reliability advisers), and also considering that $\mathtt{ag}$ believes Ana and Carlo are reliable advisers and Jana is not a reliable adviser, as shown in the knowledge base above, $\mathtt{ag}$ concludes that John is reliable, $\mathtt{reliable}\mathrm{(}\mathtt{john}\mathrm{)}$ , and that Pietro is not reliable, $\neg \mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}$ . Both conclusions are supported by acceptable arguments, according to Definition 6, which are first built as acceptable instances of the argumentation scheme role to know, according to Definition 3. While Ana’s and Carlo’s assertions are used to instantiate arguments that are acceptable instances of the argumentation scheme role to know, and they are used to support information used to help answering critical questions by $\mathtt{ag}$ , Jana’s assertions are ignored because Jana is not reliable and then $\mathtt{ag}$ is not able to build acceptable instances of arguments from the argumentation scheme role to know using her assertions, according to Definition 3, i.e., $\mathtt{ag}$ is not able to answer the critical question related to the reliability of Jana.

Using that information, $\mathtt{ag}$ concludes that smoking causes cancer, given it has an acceptable argument supporting $\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ based on John’s assertion, also considering that John is a reliable source of information, which is supported by arguments built using Carlo’s and Ana’s assertions, who also are reliable. On the other hand, the information that smoking does not cause cancer, $\neg \mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ , is not supported by an acceptable argument, given that $\mathtt{ag}$ is not able to construct an acceptable instance of argument using the argumentation scheme role to know based on Pietro’s assertion, according to Definition 3, because it concludes that Pietro is not a reliable source of information, which is supported by the arguments built using Ana’s and Carlo’s assertions.

4.2. Experimental results

We have implemented our approach8

⁸

The implementation is available in https://github.com/AlisonPanisson/ASinMAS.

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,9 ⁹

For example, when considering chained argumentation schemes with 2 premises and 2 critical questions, besides answering the 2 critical questions of the main argumentation scheme, the premises of the main argument are the conclusion of 2 different arguments constructed from different argumentation schemes which also have 2 premises and 2 critical questions to be positively answered.

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 $\mathit{conc}$ using chained argumentation schemes (i.e., all ${\mathit{sn}}_{\mathit{i}}$ argumentation schemes are chained to the argumentation scheme $\mathit{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.

Definition 7 (Scheme awareness).

An agent $\mathit{ag}$ is aware of an argumentation scheme $⟨\mathtt{sn}\mathrm{,}\mathit{P}\mathrm{,}\mathit{C}\mathrm{,}\mathit{CQ}⟩$ when that argumentation scheme is in its knowledge base ${\mathrm{\Delta }}_{\mathit{ag}}$ . We write $⟨\mathtt{sn}\mathrm{,}\mathit{P}\mathrm{,}\mathit{C}\mathrm{,}\mathit{CQ}⟩\in {\mathrm{\Delta }}_{\mathit{ag}}$ to represent the fact that $\mathit{ag}$ is aware of the argumentation scheme $\mathtt{sn}$ .

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 $\mathtt{ag}$ receives an argument ${⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{\mathtt{s}{n}_i}^{\mathit{\theta }}$ from another agent, it is able to check whether or not that information is acceptable to itself, adding S to its knowledge base ${\mathrm{\Delta }}_{\mathtt{ag}}$ (i.e., ${\mathrm{\Delta }}_{\mathtt{ag}}={\mathrm{\Delta }}_{\mathtt{ag}}\cup \mathit{S}$ ) and checking the acceptability of c. Thus, it is essential that such an agent is aware of the argumentation scheme $\mathtt{s}{n}_i$ 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 ${\mathrm{\Delta }}_{\mathtt{ag}}\vDash \mathit{c}$ to say that agent $\mathtt{ag}$ is able to construct an acceptable argument ${⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{\mathtt{s}{n}_i}^{\mathit{\theta }}$ according to Definition 6, with $\mathit{S}\subset {\mathrm{\Delta }}_{\mathtt{ag}}$ . Argument ${⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{\mathtt{s}{n}_i}^{\mathit{\theta }}$ refers to an acceptable instance of the argumentation scheme $⟨\mathtt{s}{n}_i\mathrm{,}\mathit{P}\mathrm{,}\mathit{C}\mathrm{,}\mathit{CQ}⟩\in {\mathrm{\Delta }}_{\mathtt{ag}}$ . An agent never has acceptable arguments for conflicting information, i.e., ${\mathrm{\Delta }}_{\mathtt{ag}}\vDash \mathit{c}$ and ${\mathrm{\Delta }}_{\mathtt{ag}}\vDash \bar{\mathit{c}}$ never both hold simultaneously. We use ${\mathrm{\Delta }}_{\mathtt{ag}}⊭\mathit{c}$ to mean that an agent is not able to construct an acceptable argument for c. ${\mathrm{\Delta }}_{\mathtt{ag}}⊭\mathit{c}$ does not imply ${\mathrm{\Delta }}_{\mathtt{ag}}\vDash \bar{\mathit{c}}$ ; however, ${\mathrm{\Delta }}_{\mathtt{ag}}\vDash \mathit{c}$ implies ${\mathrm{\Delta }}_{\mathtt{ag}}⊭\bar{\mathit{c}}$ .

5.1. Performatives for argumentation-based dialogues

In the multi-agent paradigm, communication is often based on the speech-act theory [75]. In such approaches, messages have the following format $⟨\mathtt{Ags}\mathrm{,}\mathtt{performative}\mathrm{,}\mathtt{content}⟩$ , where $\mathtt{Ags}$ represents the agent (or set of agents) to which the message is addressed, $\mathtt{performative}$ denotes the illocutionary force of the speech act, and $\mathtt{content}$ is the (propositional) content of the message. The performatives we use in this work, and their intended meaning are informally presented below:

• $\mathtt{assert}$ : the performative $\mathtt{assert}$ is used by agents to introduce a particular claim in the dialogue. The agents receiving such a message become aware of that claim.

• $\mathtt{question}$ : the performative $\mathtt{question}$ is used by agents to question a claim, part of arguments, or a critical question related to an argument, put forward by agents in the dialogue. The $\mathtt{content}$ will be a proposition φ that either: (i) refers to a claim put forward by some agent in the dialogue; or (ii) refers to part of the support of an argument put forward by some agent in the dialogue, i.e., $\mathit{\phi }\in \mathit{S}$ for some argument ${⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{\mathtt{sn}}^{\mathit{\theta }}$ that has been put forward by some agent in the dialogue; or (iii) a critical question associated to an argument that has been put forward by some agent in the dialogue, i.e., $\mathit{\phi }=\mathit{q}{\mathit{\theta }}_{\mathtt{sn}}$ , with $\mathit{q}\in \mathcal{CQ}$ , for an argumentation scheme10

  ¹⁰

  Recall that S is different from $\mathcal{P}$ , considering that $\mathcal{P}$ are non-instantiated premises, and S the entire support for c.

  $⟨\mathtt{sn}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩$ , with ${⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{\mathtt{sn}}^{\mathit{\theta }}$ the argument.

  $\mathtt{justify}$ : the performative $\mathtt{justify}$ is used by agents to introduce an argument in the dialogue. The content will be ${⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{\mathtt{sn}}^{\mathit{\theta }}$ , the argument supporting c.

  $\mathtt{refuse}$ : the performative $\mathtt{refuse}$ is used by agents to refuse a previous proposition put forward by some agent in the dialogue.

  $\mathtt{accept}$ : the performative $\mathtt{accept}$ is used by agents to accept a previous proposition put forward by some agent in the dialogue.

  $\mathtt{question}\text{\_}\mathtt{scheme}$ : the performative $\mathtt{question}\text{\_}\mathtt{scheme}$ is used by agents to question which argumentation scheme has been used to instantiate an argument previously communicated during the dialogue by another agent.

  $\mathtt{inform}\text{\_}\mathtt{scheme}$ : the performative $\mathtt{inform}\text{\_}\mathtt{scheme}$ is used by agents to inform another agent about the argumentation scheme it has used to instantiate an argument previously communicated by it during the dialogue.

  In the course of argumentation-based dialogues, agents make commitments based on which speech act they use. These commitments are stored in the commitment store (CS) that consists of one or more structures, accessible to all agents in a dialogue.11 ¹¹

  Other names are used for CS, such as dialogue obligation store in [40] and dialogue store in [73].

  The CS is simply a subset of the knowledge base, and the union of the CSs can be viewed as the global state of the dialogue at a given time [59]. The rules that define how CSs are updated, depending on the speech act used by agents, are summarised as follows: (i)  $\mathtt{assert}$ : the agent’s CS is updated with the asserted content p, $\mathit{CS}\leftarrow \mathit{CS}\cup \{\mathit{p}\}$ ; (ii)  $\mathtt{accept}$ : the agent’s CS is updated with the accepted content p, $\mathit{CS}\leftarrow \mathit{CS}\cup \{\mathit{p}\}$ ; (iii)  $\mathtt{question}$ and $\mathtt{refuse}$ : no effect over the CS; (iv)  $\mathtt{justify}$ : the agent’s CS is updated with the justified content contained in the set of rules and facts S (the support of the intended argument for p), $\mathit{CS}\leftarrow \mathit{CS}\cup \mathit{S}$ ; and (v)  $\mathtt{question}\text{\_}\mathtt{scheme}$ and $\mathtt{inform}\text{\_}\mathtt{scheme}$ : no effect over the CS. Using these speech acts, various protocols can be specified.

  5.2. A framework for argumentation-based dialogues

  In this section, we describe a framework for the specification of dialogue games. In previous work [54], we used this framework to model argumentation-based dialogues based on a particular protocol. Here, we use the same framework to specify an argumentation-based protocol based on our approach for argumentation schemes in multi-agent systems. The framework for dialogue games is based on work by McBurney et al. [38, 39], in which the elements that correspond to the dialogue game specification are:

• we have the initial conditions (corresponding to the commencement rules of the dialogue game), which do not require any moves to have been previously executed. $$\begin{array}{c}\underset{\begin{array}{c}0\mathrm{<}\mathtt{k}⩽\mathtt{n}\mathrm{,}\\ \mathtt{j}\in \mathtt{P}\end{array}}{{\displaystyle \bigwedge }}\mathrm{(}{\mathtt{C}}_{\mathtt{k}}\Rightarrow {\mathtt{M}}_{\mathtt{k}}^{\mathtt{j}}\mathrm{(}\mathit{\alpha }\mathrm{,}\mathit{\beta }\mathrm{,}{\mathtt{content}}_{\mathtt{k}}\mathrm{,}{\mathtt{t}}_0\mathrm{)}\end{array}$$ where ${\mathtt{t}}_0$ is the initial time and $\mathtt{n}$ is the number of allowed moves that α could make initially.

Using this framework for dialogue games, we will define a protocol that takes argumentation schemes under consideration. we then show how we implement that protocol (and respective dialogue rules) for Jason agents [12].

In order to define the dialogue rules we use the following notation:

We write ${\mathrm{\Delta }}_{\mathtt{ag}}$ to represent agent $\mathtt{ag}$ ’s knowledge base. ${\mathrm{\Delta }}_{\mathtt{ag}}$ includes $\mathtt{ag}$ ’s private knowledge and argumentation schemes.

We write ${\mathtt{CS}}_{\mathtt{ag}}$ to represent agent $\mathtt{ag}$ ’s commitment store, which is updated according to the rules described in Section 5.1.

We write ${\mathrm{\Delta }}_{\mathtt{ag}}\vDash {⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{\mathit{sn}}^{\mathit{\theta }}$ to denote that an agent $\mathtt{ag}$ is able to instantiate an acceptable argument supporting c (according Definition 6) from the information available in its knowledge base ${\mathrm{\Delta }}_{\mathtt{ag}}$ , which includes the argumentation scheme $\mathit{sn}$ used to instantiate that argument.

We write $\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{i}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{j}}}\mathrm{)}\vDash {⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{\mathit{sn}}^{\mathit{\theta }}$ to denote that an agent ${\mathit{ag}}_{\mathit{i}}$ is able to construct an acceptable argument supporting c from its knowledge base and ${\mathit{ag}}_{\mathit{j}}$ ’s commitment store.

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 $\mathtt{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:

an agent ${\mathit{ag}}_{\mathit{i}}$ starts a dialogue with another agent ${\mathit{ag}}_{\mathit{j}}$ , executing an $\mathtt{assert}$ move $\mathtt{assert}\mathrm{(}\mathit{a}{g}_i\mathrm{,}\mathit{a}{g}_j\mathrm{,}\mathit{p}\mathrm{)}$ , trying to make ${\mathit{ag}}_{\mathit{j}}$ believe in p; p becomes the subject of the dialogue (the protocol goes to (2)).

an agent ${\mathit{ag}}_{\mathit{j}}$ receives an $\mathtt{assert}$ move $\mathtt{assert}\mathrm{(}\mathit{a}{g}_i\mathrm{,}\mathit{a}{g}_j\mathrm{,}\mathit{p}\mathrm{)}$ , and it checks if it has an argument against p. When it has no argument against p, it accepts p executing an $\mathtt{accept}$ move $\mathtt{accept}\mathrm{(}\mathit{a}{g}_j\mathrm{,}\mathit{a}{g}_i\mathrm{,}\mathit{p}\mathrm{)}$ (the protocol goes to (5)). Otherwise, when ${\mathit{ag}}_{\mathit{j}}$ is able to construct an argument against p, it executes a $\mathtt{question}$ move $\mathtt{question}\mathrm{(}\mathit{a}{g}_j\mathrm{,}\mathit{a}{g}_i\mathrm{,}\mathit{p}\mathrm{)}$ , asking for an argument supporting that assertion (the protocol goes to (3)).

an agent ${\mathit{ag}}_{\mathit{i}}$ receives a $\mathtt{question}$ move $\mathtt{question}\mathrm{(}\mathit{a}{g}_j\mathrm{,}\mathit{a}{g}_i\mathrm{,}\mathit{p}\mathrm{)}$ , and it responds with a $\mathtt{justify}$ move $\mathtt{justify}\mathrm{(}\mathit{a}{g}_i\mathrm{,}\mathit{a}{g}_j\mathrm{,}{⟨\mathit{S}\mathrm{,}\mathit{p}⟩}_{\mathit{sn}}^{\mathit{\theta }}\mathrm{)}$ , introducing an argument which supports the questioned proposition (the protocol goes to (4)).

an agent ${\mathit{ag}}_{\mathit{j}}$ receives a $\mathtt{justify}$ move $\mathtt{justify}\mathrm{(}\mathit{a}{g}_i\mathrm{,}\mathit{a}{g}_j\mathrm{,}{⟨\mathit{S}\mathrm{,}\mathit{p}⟩}_{\mathit{sn}}^{\mathit{\theta }}\mathrm{)}$ , checking whether it is aware of the argumentation scheme $\mathit{sn}$ used to build that argument. When it is not aware of the argumentation scheme $\mathit{sn}$ , it questions ${\mathit{ag}}_{\mathit{i}}$ about the scheme executing a $\mathtt{question}\text{\_}\mathtt{scheme}$ move $\mathtt{question}\text{\_}\mathtt{scheme}\mathrm{(}\mathit{a}{g}_j\mathrm{,}\mathit{a}{g}_i\mathrm{,}\mathit{sn}\mathrm{)}$ (the protocol goes to (6)). Otherwise, when it is aware of the argumentation scheme used by ${\mathit{ag}}_{\mathit{i}}$ , then it checks if the new information received from ${\mathit{ag}}_{\mathit{i}}$ 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 ${\mathit{ag}}_{\mathit{i}}$ . In case ${\mathit{ag}}_{\mathit{j}}$ has no argument against the subject of the dialogue, it accepts the subject of the dialogue executing an $\mathtt{accept}$ move $\mathtt{accept}\mathrm{(}\mathit{a}{g}_j\mathrm{,}\mathit{a}{g}_i\mathrm{,}\mathit{p}\mathrm{)}$ (the protocol goes to (5)). Otherwise, when ${\mathit{ag}}_{\mathit{j}}$ is able to construct an argument against the subject of the dialogue, either (i) it executes an $\mathtt{assert}$ move12

¹²

Note that ${\mathit{ag}}_{\mathit{j}}$ is able to execute this move only when it did not assert $\neg \mathit{p}$ previously, i.e., $\neg \mathit{p}\notin {\mathit{CS}}_{{\mathit{ag}}_{\mathit{j}}}$ .

$\mathtt{assert}\mathrm{(}\mathit{a}{g}_j\mathrm{,}\mathit{a}{g}_i\mathrm{,}\neg \mathit{p}\mathrm{)}$ , committing itself to provide support for $\neg \mathit{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 $\mathit{sn}$ that ${\mathit{ag}}_{\mathit{i}}$ has used to instantiate its argument. In the case it is able to answer negatively a critical question from $\mathit{sn}$ , it executes an $\mathtt{assert}$ move $\mathtt{assert}\mathrm{(}\mathit{a}{g}_j\mathrm{,}\mathit{a}{g}_i\mathrm{,}\neg \mathit{cq}\mathrm{)}$ , with $\mathit{cq}$ the critical question (the protocol goes to (2)).

an agent ${\mathit{ag}}_{\mathit{j}}$ receives an $\mathtt{accept}$ move $\mathtt{accept}\mathrm{(}\mathit{a}{g}_i\mathrm{,}\mathit{a}{g}_j\mathrm{,}\mathit{p}\mathrm{)}$ , 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.

an agent ${\mathit{ag}}_{\mathit{j}}$ receives a $\mathtt{question}\text{\_}\mathtt{scheme}$ move $\mathtt{question}\text{\_}\mathtt{scheme}\mathrm{(}\mathit{a}{g}_i\mathrm{,}\mathit{a}{g}_j\mathrm{,}\mathit{sn}\mathrm{)}$ and answers that move by informing ${\mathit{ag}}_{\mathit{i}}$ about the argumentation scheme $\mathit{sn}$ executing a $\mathtt{inform}\text{\_}\mathtt{scheme}$ move $\mathtt{inform}\text{\_}\mathtt{scheme}\mathrm{(}\mathit{a}{g}_j\mathrm{,}\mathit{a}{g}_i\mathrm{,}⟨\mathit{sn}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩\mathrm{)}$ (the protocol goes to (7)).

an agent ${\mathit{ag}}_{\mathit{j}}$ receives an $\mathtt{inform}\text{\_}\mathtt{scheme}$ move $\mathtt{inform}\text{\_}\mathtt{scheme}\mathrm{(}\mathit{a}{g}_i\mathrm{,}\mathit{a}{g}_j\mathrm{,}⟨\mathit{sn}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩\mathrm{)}$ , recalling the subject of the dialogue and then checking if it has no argument against the subject of the dialogue. In case ${\mathit{ag}}_{\mathit{j}}$ has no argument against the subject of the dialogue, it accepts the subject of the dialogue executing an $\mathtt{accept}$ move $\mathtt{accept}\mathrm{(}\mathit{a}{g}_j\mathrm{,}\mathit{a}{g}_i\mathrm{,}\mathit{p}\mathrm{)}$ (the protocol goes to (5)). Otherwise, when ${\mathit{ag}}_{\mathit{j}}$ is able to construct an argument against the subject of the dialogue, either (i) it executes an $\mathtt{assert}$ move $\mathtt{assert}\mathrm{(}\mathit{a}{g}_j\mathrm{,}\mathit{a}{g}_i\mathrm{,}\neg \mathit{p}\mathrm{)}$ , committing itself to provide support for $\neg \mathit{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 $\mathit{sn}$ that ${\mathit{ag}}_{\mathit{i}}$ has used to instantiate its argument. In case it is able to answer negatively a critical question from $\mathit{sn}$ , it executes an $\mathtt{assert}$ move $\mathtt{assert}\mathrm{(}\mathit{a}{g}_j\mathrm{,}\mathit{a}{g}_i\mathrm{,}\neg \mathit{cq}\mathrm{)}$ , with $\mathit{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 $\mathtt{subject}\mathrm{(}\mathtt{p}\mathrm{)}$ means that the atomic formula $\mathtt{p}$ is the subject of the dialogue). Each dialogue has only one $\mathtt{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 $\mathtt{Pr}$ and $\mathtt{Op}$ , respectively, to refer to them). $$\begin{array}{c}{\mathtt{C}}_{\mathit{in}1}\Rightarrow \mathtt{assert}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}\mathtt{p}\mathrm{)}\end{array}$$ where: $$\begin{array}{l}{\mathtt{C}}_{\mathit{in}1}=\exists {⟨\mathit{S}\mathrm{,}\mathit{p}⟩}_{\mathit{sn}}^{\mathit{\theta }}:{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{i}}}\vDash {⟨\mathit{S}\mathrm{,}\mathit{p}⟩}_{\mathit{sn}}^{\mathit{\theta }}\end{array}$$

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 ${\mathrm{\Delta }}_{\mathtt{AS}}$ , according to Definition 6.

Assert Rules: We have two dialogue rules that restrict the possible next move for agents to respond to an $\mathtt{assert}$ move: $$\begin{array}{cc}\hfill & \mathtt{assert}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}\mathtt{p}\mathrm{)}\wedge {\mathtt{C}}_{\mathit{as}1}\Rightarrow \mathtt{accept}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}\mathtt{p}\mathrm{)}\hfill \\ \hfill & \mathtt{assert}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}\mathtt{p}\mathrm{)}\wedge {\mathtt{C}}_{\mathit{as}2}\Rightarrow \mathtt{question}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}\mathtt{p}\mathrm{)}\hfill \end{array}$$ where: $$\begin{array}{l}{\mathtt{C}}_{\mathit{as}1}=\nexists {⟨\mathit{S}\mathrm{,}\bar{\mathit{p}}⟩}_{\mathit{sn}}^{\mathit{\theta }}:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash {⟨\mathit{S}\mathrm{,}\bar{\mathit{p}}⟩}_{\mathit{sn}}^{\mathit{\theta }}\\ {\mathtt{C}}_{\mathit{as}2}=\exists {⟨\mathit{S}\mathrm{,}\bar{\mathit{p}}⟩}_{\mathit{sn}}^{\mathit{\theta }}:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash {⟨\mathit{S}\mathrm{,}\bar{\mathit{p}}⟩}_{\mathit{sn}}^{\mathit{\theta }}\end{array}$$

The options of the agent are: (i) to accept the previous claim, where condition ${\mathtt{C}}_{\mathit{as}1}$ 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, ${\mathtt{C}}_{\mathit{as}2}$ , 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 $\mathtt{question}$ message is: $$\begin{array}{c}\mathtt{question}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}\mathtt{p}\mathrm{)}\wedge {\mathtt{C}}_{\mathit{qs}1}\Rightarrow \mathtt{justify}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{⟨\mathit{S}\mathrm{,}\mathit{p}⟩}_{\mathit{sn}}^{\mathit{\theta }}\mathrm{)}\end{array}$$ where: $$\begin{array}{l}{\mathtt{C}}_{\mathit{qs}1}=\exists {⟨\mathit{S}\mathrm{,}\mathit{p}⟩}_{\mathit{sn}}^{\mathit{\theta }}:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash {⟨\mathit{S}\mathrm{,}\mathit{p}⟩}_{\mathit{sn}}^{\mathit{\theta }}\end{array}$$

Considering that the agent has asserted $\mathtt{p}$ previously (which allowed the $\mathtt{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 $\mathtt{justify}$ move: $$\begin{array}{ll}\hfill & \mathtt{justify}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{{\mathit{sn}}_{\mathit{i}}}^{\mathit{\theta }}\mathrm{)}\wedge {\mathtt{C}}_{\mathit{js}1}\Rightarrow \mathtt{question}\text{\_}\mathtt{scheme}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{sn}}_{\mathit{i}}\mathrm{)}\\ \hfill & \mathtt{justify}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{{\mathit{sn}}_{\mathit{i}}}^{\mathit{\theta }}\mathrm{)}\wedge {\mathtt{C}}_{\mathit{js}2}\Rightarrow \mathtt{accept}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}\mathit{p}\mathrm{)}\\ \hfill & \mathtt{justify}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{{\mathit{sn}}_{\mathit{i}}}^{\mathit{\theta }}\mathrm{)}\wedge {\mathtt{C}}_{\mathit{js}3}\Rightarrow \mathtt{assert}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}\bar{\mathit{p}}\mathrm{)}\\ \hfill & \mathtt{justify}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{{\mathit{sn}}_{\mathit{i}}}^{\mathit{\theta }}\mathrm{)}\wedge {\mathtt{C}}_{\mathit{js}4}\Rightarrow \mathtt{assert}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}\overline{\mathit{cq}}\mathrm{)}\\ \hfill & \mathtt{justify}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{{\mathit{sn}}_{\mathit{i}}}^{\mathit{\theta }}\mathrm{)}\wedge {\mathtt{C}}_{\mathit{js}5}\Rightarrow \mathtt{closedialogue}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{)}\\ \hfill & \mathtt{justify}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{⟨\mathit{S}\mathrm{,}\mathit{c}⟩}_{{\mathit{sn}}_{\mathit{i}}}^{\mathit{\theta }}\mathrm{)}\wedge {\mathtt{C}}_{\mathit{js}6}\Rightarrow \mathtt{justify}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{c}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\mathrm{)}\end{array}$$ where: $$\begin{array}{l}{\mathtt{C}}_{\mathit{js}1}=⟨{\mathit{sn}}_{\mathit{i}}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩\notin {\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\\ {\mathtt{C}}_{\mathit{js}2}=\nexists {⟨{\mathit{S}}^{\prime }\mathrm{,}\bar{\mathit{p}}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash {⟨{\mathit{S}}^{\prime }\mathrm{,}\bar{\mathit{p}}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\wedge \mathtt{Op}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{)}\wedge \mathtt{subject}\mathrm{(}\mathit{p}\mathrm{)}\\ {\mathtt{C}}_{\mathit{js}3}=\exists {⟨{\mathit{S}}^{\prime }\mathrm{,}\bar{\mathit{p}}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash {⟨{\mathit{S}}^{\prime }\mathrm{,}\bar{\mathit{p}}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\wedge \bar{\mathit{p}}\notin {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{j}}}\wedge \mathtt{Op}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{)}\wedge \mathtt{subject}\mathrm{(}\mathit{p}\mathrm{)}\\ {\mathtt{C}}_{\mathit{js}4}=\exists \overline{\mathit{cq}}\mathit{\theta }:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash \overline{\mathit{cq}}\mathit{\theta }\wedge \overline{\mathit{cq}}\mathit{\theta }\notin {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{j}}}\wedge \mathit{cq}\mathit{\theta }\in \mathcal{CQ}\wedge ⟨{\mathit{sn}}_{\mathit{i}}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩\in {\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\\ {\mathtt{C}}_{\mathit{js}5}=\nexists {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\wedge {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\notin {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{j}}}\wedge \mathtt{Pr}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{)}\wedge \mathtt{subject}\mathrm{(}\mathit{p}\mathrm{)}\\ {\mathtt{C}}_{\mathit{js}6}=\exists {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\wedge {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\notin {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{j}}}\wedge \mathtt{Pr}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{)}\wedge \mathtt{subject}\mathrm{(}\mathit{p}\mathrm{)}\end{array}$$

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, ${\mathtt{C}}_{\mathit{js}2}$ , 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, ${\mathtt{C}}_{\mathit{js}3}$ , or it will assert that some critical question related to that argument are not positively answered, ${\mathtt{C}}_{\mathit{js}4}$ . 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, ${\mathtt{C}}_{\mathit{js}5}$ . In the final case, the agent sends a new argument13

¹³

The argument is new because, as defined in the protocol, the agent cannot repeat a move with the same content.

to support the subject of the dialogue, ${\mathtt{C}}_{\mathit{js}6}$ .

Accept Rule: The dialogue rule that restricts the moves when an agent receives an $\mathtt{accept}$ message is: $$\begin{array}{c}\mathtt{accept}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}\mathtt{p}\mathrm{)}\wedge {\mathtt{C}}_{\mathit{ac}1}\Rightarrow \mathtt{closedialogue}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{)}\end{array}$$ where: $$\begin{array}{l}{\mathtt{C}}_{\mathit{ac}1}=\mathtt{subject}\mathrm{(}\mathtt{p}\mathrm{)}\wedge \mathtt{Pr}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{)}\end{array}$$

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 $\mathtt{question}\text{\_}\mathtt{scheme}$ message is: $$\begin{array}{c}\mathtt{question}\text{\_}\mathtt{scheme}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{sn}}_{\mathit{i}}\mathrm{)}\wedge {\mathtt{C}}_{\mathit{qsc}1}\Rightarrow \mathtt{inform}\text{\_}\mathtt{scheme}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}⟨{\mathit{sn}}_{\mathit{i}}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩\mathrm{)}\end{array}$$ where: $$\begin{array}{l}{\mathtt{C}}_{\mathit{qsc}1}=⟨{\mathit{sn}}_{\mathit{i}}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩\in {\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\end{array}$$

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 $\mathtt{question}\text{\_}\mathtt{scheme}$ message are: $$\begin{array}{l}\mathtt{inform}\text{\_}\mathtt{scheme}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}⟨{\mathit{sn}}_{\mathit{i}}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩\mathrm{)}\wedge {\mathtt{C}}_{\mathit{iss}1}\Rightarrow \mathtt{accept}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}\mathit{p}\mathrm{)}\\ \mathtt{inform}\text{\_}\mathtt{scheme}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}⟨{\mathit{sn}}_{\mathit{i}}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩\mathrm{)}\wedge {\mathtt{C}}_{\mathit{iss}2}\Rightarrow \mathtt{assert}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}\bar{\mathit{p}}\mathrm{)}\\ \mathtt{inform}\text{\_}\mathtt{scheme}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}⟨{\mathit{sn}}_{\mathit{i}}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩\mathrm{)}\wedge {\mathtt{C}}_{\mathit{iss}3}\Rightarrow \mathtt{assert}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}\overline{\mathit{cq}}\mathrm{)}\\ \mathtt{inform}\text{\_}\mathtt{scheme}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}⟨{\mathit{sn}}_{\mathit{i}}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩\mathrm{)}\wedge {\mathtt{C}}_{\mathit{iss}4}\Rightarrow \mathtt{closedialogue}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{)}\\ \mathtt{inform}\text{\_}\mathtt{scheme}\mathrm{(}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathit{ag}}_{\mathit{j}}\mathrm{,}⟨{\mathit{sn}}_{\mathit{i}}\mathrm{,}\mathcal{C}\mathrm{,}\mathcal{P}\mathrm{,}\mathcal{CQ}⟩\mathrm{)}\wedge {\mathtt{C}}_{\mathit{iss}5}\Rightarrow \mathtt{justify}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{,}{\mathit{ag}}_{\mathit{i}}\mathrm{,}{\mathtt{S}}^{\prime }\mathrm{)}\end{array}$$ where: $$\begin{array}{l}{\mathtt{C}}_{\mathit{iss}1}=\nexists {⟨{\mathit{S}}^{\prime }\mathrm{,}\bar{\mathit{p}}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash {⟨{\mathit{S}}^{\prime }\mathrm{,}\bar{\mathit{p}}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\wedge \mathtt{Op}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{)}\wedge \mathtt{subject}\mathrm{(}\mathit{p}\mathrm{)}\\ {\mathtt{C}}_{\mathit{iss}2}=\exists {⟨{\mathit{S}}^{\prime }\mathrm{,}\bar{\mathit{p}}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash {⟨{\mathit{S}}^{\prime }\mathrm{,}\bar{\mathit{p}}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\wedge \bar{\mathit{p}}\notin {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{j}}}\wedge \mathtt{Op}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{)}\wedge \mathtt{subject}\mathrm{(}\mathit{p}\mathrm{)}\\ {\mathtt{C}}_{\mathit{iss}3}=\exists \overline{\mathit{cq}}\mathit{\theta }:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash \overline{\mathit{cq}}\mathit{\theta }\wedge \overline{\mathit{cq}}\mathit{\theta }\notin {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{j}}}\wedge \mathit{cq}\mathit{\theta }\in \mathcal{CQ}\\ {\mathtt{C}}_{\mathit{iss}4}=\nexists {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\wedge {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\notin {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{j}}}\wedge \mathtt{Pr}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{)}\wedge \mathtt{subject}\mathrm{(}\mathit{p}\mathrm{)}\\ {\mathtt{C}}_{\mathit{iss}5}=\exists {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}:\mathrm{(}{\mathrm{\Delta }}_{{\mathit{ag}}_{\mathit{j}}}\cup {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{i}}}\mathrm{)}\vDash {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\wedge {⟨{\mathit{S}}^{\prime }\mathrm{,}\mathit{p}⟩}_{{\mathit{sn}}_{\mathit{j}}}^{\mathit{\theta }}\notin {\mathtt{CS}}_{{\mathit{ag}}_{\mathit{j}}}\wedge \mathtt{Pr}\mathrm{(}{\mathit{ag}}_{\mathit{j}}\mathrm{)}\wedge \mathtt{subject}\mathrm{(}\mathit{p}\mathrm{)}\end{array}$$

The dialogue then follows as when the agent receives a justify move being aware of the argumentation scheme used by ${\mathit{ag}}_{\mathit{i}}$ , recovering the subject of the dialogue, accepting the subject of the dialogue, ${\mathtt{C}}_{\mathit{iss}1}$ , 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, ${\mathtt{C}}_{\mathit{iss}2}$ , or it will assert that some critical question related to that argument are not positively answered, ${\mathtt{C}}_{\mathit{iss}3}$ . 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, ${\mathtt{C}}_{\mathit{iss}4}$ . In the final case, the agent sends a new argument14 ¹⁴

The argument is new because, as defined in the protocol, the agent cannot repeat a move with the same content.

to support the subject of the dialogue, ${\mathtt{C}}_{\mathit{iss}5}$ .

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 $+!\mathtt{msg}\text{\_}\mathtt{received}\mathrm{(}\mathtt{Sender}\mathrm{,}\mathtt{Performative}\mathrm{,}\mathtt{Content}\mathrm{)}$ 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 $\mathit{proponent}$ and $\mathit{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 $\mathit{proponent}$ starts a dialogue asserting that $\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ , which becomes the subject of the dialogue. The $\mathit{proponent}$ ’s knowledge is denoted by ${\mathrm{\Delta }}_{\mathit{proponent}}$ , as defined below. $$\begin{array}{c}{\mathrm{\Delta }}_{\mathit{proponent}}=\left\{\begin{array}{c}\mathtt{reliable}\mathrm{(}\mathtt{john}\mathrm{)}\hfill \\ \neg \mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}\hfill \\ \mathtt{asserts}\mathrm{(}\mathtt{john}\mathrm{,}\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}\mathrm{)}\hfill \\ \mathtt{role}\mathrm{(}\mathtt{john}\mathrm{,}\mathtt{doctor}\mathrm{)}\hfill \\ \mathtt{role}\text{\_}\mathtt{to}\text{\_}\mathtt{know}\mathrm{(}\mathtt{doctor}\mathrm{,}\mathtt{cancer}\mathrm{)}\hfill \\ \mathtt{about}\mathrm{(}\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}\mathrm{,}\mathtt{cancer}\mathrm{)}.\hfill \end{array}\right\}\end{array}$$

In the case where agent $\mathit{opponent}$ has no argument against the subject of the dialogue, i.e., $\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}$ , 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 $\mathit{proponent}$ has an argument against the subject of the dialogue, we have a different output. $$\begin{array}{c}{\mathrm{\Delta }}_{\mathit{opponent}}=\left\{\begin{array}{c}\mathtt{asserts}\mathrm{(}\mathtt{pietro}\mathrm{,}\neg \mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}\mathrm{)}\hfill \\ \mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{doctor}\mathrm{)}\hfill \\ \mathtt{role}\text{\_}\mathtt{to}\text{\_}\mathtt{know}\mathrm{(}\mathtt{doctor}\mathrm{,}\mathtt{cancer}\mathrm{)}\hfill \\ \mathtt{about}\mathrm{(}\mathtt{causes}\mathrm{(}\mathtt{smoking}\mathrm{,}\mathtt{cancer}\mathrm{)}\mathrm{,}\mathtt{cancer}\mathrm{)}.\hfill \end{array}\right\}\end{array}$$

Considering the $\mathit{opponent}$ ’s knowledge represented as ${\mathrm{\Delta }}_{\mathit{opponent}}$ , in which the $\mathit{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 $\mathit{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 $\mathit{proponent}$ agent has asked reliability advisers about whether Pietro and John are reliable sources of information or not. Then, the $\mathit{proponent}$ is able to provide an argument supporting that Pietro is not reliable, i.e., $\neg \mathtt{reliable}\mathrm{(}\mathtt{pietro}\mathrm{)}$ , 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 $\mathit{opponent}$ agent believes that Pietro is a doctor because he is dressing white and he is in the hospital, i.e., $\mathtt{role}\mathrm{(}\mathtt{pietro}\mathrm{,}\mathtt{doctor}\mathrm{)}$ 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 $\mathit{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 $\mathtt{context}{\mathrm{(}C\mathrm{)}}_{[\mathit{sn}]}$ , that is, requiring a particular context $\mathtt{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.