Acquiring knowledge from expert agents in a structured argumentation setting

1.Introduction

In multi-agent systems, agents can have different aims and goals, and it is normal to assume that there is no central control over their behaviour. One of the advantages of these systems is that the information is decentralised. Hence, the agents have to interact in order to obtain the information they need, or to share part of their knowledge.

In this work, we propose a strategy for automatic knowledge acquisition which involves two different kinds of agents: one agent that has expertise in a particular domain or field of knowledge and a client agent that lacks that quality. In our approach, the client agent will initially make a query to the expert agent in order to acquire some knowledge about a topic it does not know about or partially knows about. Since the client conceives the other agent as an expert, it will be committed to believe in the answer for its query. Unlike other approaches in the literature, we consider that the client may have previous strict knowledge that is in contradiction with the information the expert knows about the consulted topic. Hence, the client may require to ask further questions and adapt its previous knowledge in order to be aligned with what the expert says.

A naive solution to the proposed problem would be for the expert to send its whole knowledge base to the client. However, this is not a sensible nor feasible solution for several reasons. First, depending on the application domain, the expert could have private information that is sensitive and should not be shared. Second, its knowledge base could be very extensive and merging it with the client’s could be computationally impracticable in a real-time and dynamic environment. Finally, the merged knowledge bases would probably have many contradictions whose relevance is outside of the domain of the query. Ignoring these inconsistencies would lead to undesired results and conclusions, but solving them would be time-consuming and irrelevant for the query. Another solution would be for the client to revise its initial knowledge base to believe in the expert’s opinion in a single step. However, as will be shown in the following sections, this may imply the unnecessary removal of pieces of information that, from the expert’s perspective, are valid.

In [47], the concept of information-seeking dialogues was introduced, in which one participant is an expert in a particular domain or field of knowledge and the other is not. By asking questions, the non-expert participant elicits the expert’s opinion (advice) on a matter in which the questioner itself lacks direct knowledge. The questioner’s goal is to accept the expert’s opinion while the expert’s goal is to provide just the necessary information to help the questioner understand its opinion about the consulted topic. In this particular type of dialogue, the questioner can arrive at a presumptive conclusion which gives a plausible expert-based answer to its question. Information-seeking has already been addressed in literature when defining dialogue frameworks for agents. However, some of these approaches do not consider that the questioner may have previous strict knowledge in contradiction to the expert’s [31], while others, which consider such a possibility, simply disregard conflicting interactions [17–19].

Differently from existing approaches, our proposal not only considers that agents may have previous strict knowledge in contradiction, but also focuses on a strategy which guarantees that the information-seeking goals are always achieved. That is, once a client-expert interaction finishes, the client agent will believe the same as the expert agent about the initial query. Since the client conceives the other agent as an expert, whenever a contradiction between their knowledge arises the client will always prefer the expert’s opinion. However, in order to avoid the unnecessary removal of pieces of information that – from the expert’s perspective – are valid, the client will keep asking questions to the expert until the goal is achieved.

In order to provide a dialogue protocol specification that satisfies the aforementioned goals, one of the main contributions of our proposal is a definition of the operational semantics in terms of a transition system. Although we will formalise a two-agent interaction, this strategy can be applied in a multi-agent environment in which an expert agent could have several simultaneous interactions with different clients – each one in a separate session.

The research on the use of argumentation to model agent interactions is a very active field, including argumentation-based negotiation approaches [3,26,27,36], persuasion [6,12,32,33], general dialogue formalizations [17], strategic argumentation [12,43,44], among others. In our proposal, agents will be equipped with the structured argumentation reasoning mechanism of DeLP (Defeasible Logic Programming) [22]. DeLP allows the involved agents to represent tentative or weak information in a declarative manner. Such information is used to build arguments, which are sets of coherent information supporting claims. The acceptance of a claim will depend on an exhaustive dialectical analysis (formalised through a proof procedure) of the arguments in favour of and against it. This procedure provides agents with an inference mechanism for warranting their entailed conclusions. We will use the structured argumentation formalism DeLP for knowledge representation and reasoning since the purpose of this paper is to show how to solve the problems associated to the agents’ argument structures in an information-seeking setting. In particular, DeLP has been used to successfully implement inquiries [1,42,45], another type of dialogue defined by [47]. In contrast to other approaches that use argumentation as a tool for deciding among dialogue moves, similarly to [4,8] we use structured argumentation just as the underlying representation formalism for the involved agents.

There is plenty of work on revision of argumentation frameworks (AFs) [11,13,14,30,38] which, regardless of their individual goals, end up adding or removing arguments or attacks and returning a new AF or set of AFs as output. Our proposal differs from all those approaches in that the client agent will not just revise its “initial framework” in order to warrant the expert’s opinion. Instead, the client will keep asking questions and acquiring knowledge from the expert agent (that is relevant to the initial query) in order to avoid removing from its knowledge base pieces of information that, from the expert’s perspective, are valid. As will be explained in detail in the following sections, in order to be able to believe in the expert’s qualified opinion, the client will only revise its previous knowledge if it is in contradiction with the expert’s. In other words, our proposal differs from other approaches in that unnecessary modifications are avoided by maintaining the communication with the expert, with the additional benefit of acquiring more relevant knowledge and making informed changes considering a qualified opinion.

It has been recognised in the literature [22,37] that the argumentation mechanism provides a natural way of reasoning with conflicting information while retaining much of the process a human being would apply in such situations. Thus, defeasible argumentation provides an attractive paradigm for conceptualising common-sense reasoning, and its importance has been shown in different areas of Artificial Intelligence such as multi-agent systems [10], recommender systems [5], decision support systems [23], legal systems [34], agent internal reasoning [2], multi-agent argumentation [42,45], agent dialogues [7,8], among others (see [37]). In particular, DeLP has been used to equip agents with a qualitative reasoning mechanism to infer recommendations in expert and recommender systems [9,24,41]. Below, we introduce an example to motivate the main ideas of our proposal.

It is important to note that, in the example above, the expert M could have much more knowledge (related or not to the topic in question) that will not be sent to B. As will be explained in more detail below, in our proposal the expert will just send the necessary information that the client needs to infer the answer to its query. Examples of different situations that can arise during the client-expert interaction will be introduced along the presentation of the paper. The contributions of this paper are:

The rest of this work is organised as follows. In Section 2 we introduce the background related to the agents’ knowledge representation and reasoning formalism. Then, in Section 3, we explain the client-expert interaction in detail, and we define the operational semantics of the proposed strategy using transition rules. Next, in Section 4, we define some operators that the expert can use to minimise or reduce the information exchange with the client. Section 5 follows with an extension to the operational semantics that allows the client to reject the expert’s opinion, relaxing the assumption of commitment. Then, in Section 6 we discuss on some design choices of our formalism. Next, in Section 7, related work is included. Finally, in Section 8, we present conclusions and comment on future lines of work. At the end of the paper we include an Appendix with the proofs for the formal results of our approach.

2.Knowledge representation and reasoning

In this section, the background related to the agents’ knowledge representation and reasoning is included. In our approach, both the expert and the client represent their knowledge using DeLP, a language that combines results of Logic Programming and Defeasible Argumentation [21]. As in Logic Programming, DeLP allows to represent information declaratively using facts and rules. A DeLP program consists of a finite set of facts and defeasible rules. Facts are used for the representation of irrefutable evidence, and are denoted with ground literals: that is, either atomic information (e.g., has_new_product(acme)), or the negation of atomic information using the symbol “∼” of strong negation (e.g., ∼in_fusion(magma)). In turn, defeasible rules are used for the representation of tentative information, and are denoted L0⤙L1,…,Ln, where L0 (the head of the rule) is a ground literal and {Li}i>0 (the body) is a set of ground literals. A defeasible rule “Head⤙Body” establishes a weak connection between “Body” and “Head” and can be read as “reasons to believe in the antecedent Body give reasons to believe in the consequent Head”. When required, a DeLP program P will be noted as (Π,Δ), distinguishing the subset Π of facts and the subset Δ of defeasible rules. Although defeasible rules are ground, following the usual convention proposed in [28] we will use “schematic rules” with variables denoted with an upper-case letter. The other language elements (literals and constants) will be denoted with an initial lower-case letter. Given a literal q, the complement of q with respect to “∼” will be denoted q‾, i.e., q‾=∼q and ∼q‾=q. An example of a DeLP program follows:

In the set ΠM there are eight facts that represent evidence that the expert M has about the stock market domain (for instance: “Acme and Steel are in fusion”, “Magma is not in fusion”, “Steel is a strong company”, “Starter is a new company”, “Acme has announced a new product”). The set ΔM has nine (schematic) defeasible rules that M can use to infer tentative conclusions. Note that the first two rules will allow to infer buy_stocks(acme), the third and fourth to infer ∼buy_stocks(acme), and the fifth to infer ∼risky_co(acme). The last four defeasible rules represent knowledge that M has, but were not sent to B in the motivating example because they were not relevant with respect to the queries that B made.

We will briefly include below some concepts related to the argumentation inference mechanism of DeLP. We refer to [21] for the details. In a valid DeLP program the set Π must be non-contradictory. Since in this proposal Π is a set of facts, this means that Π cannot have a pair of contradictory literals, and this should be considered every time the client adopts new knowledge from the expert. In DeLP a ground literal L will have a defeasible derivation from a program (Π,Δ) if there exists a finite sequence of ground literals L1,L2,…,Ln=L, where Li is a fact in Π, or there exists a rule Ri with head Li and body B1,B2,…,Bm such that every literal of the body is an element Lj of the sequence appearing before Li (j<i). Since strong negation can appear in the head of defeasible rules, complementary literals can be defeasibly derived. For the treatment of contradictory knowledge, DeLP uses an argumentative inference mechanism which identifies the pieces of knowledge that are in contradiction, and then uses a dialectical process for deciding which conclusions prevail as warranted. This process involves the construction and evaluation of arguments that are either for or against the query under analysis.

Given A=⟨R,h⟩ we say that h is the conclusion of A, denoted claim(A)=h. For instance, in (ΠM,ΔM) from Example 2, M1 is an argument for the literal buy_stocks(acme), and M2 is an argument for the literal stock_will_rise(acme). Both M1 and M2 have rules that are instances of the schematic rules of ΔM.

The evidence of A is bodies(A)∖heads(A) when the set of rules is not empty, and is {claim(A)} otherwise. For instance, bodies(M1)={has_new_product(acme),stock_will_rise(acme)}, heads(M1)={stock_will_rise(acme),buy_stocks(acme)}, and evidence(M1)={has_new_product(acme)}. Note that ⟨∅,strong_co(steel)⟩ is an argument for strong_co(steel), and evidence(⟨∅,strong_co(steel)⟩)={strong_co(steel)}. Given S=⟨R1,h1⟩ and A=⟨R2,h2⟩, S is a sub-argument of A when ∅⊂R1⊆R2 or when R1=∅ and claim(S)∈evidence(A). In particular, every argument is a sub-argument of itself. For instance, M2 is a sub-argument of M1, and ⟨∅,has_new_product(acme)⟩ is a sub-argument of M2. If an argument A has more than one rule, then the head of each rule represents an intermediate reasoning step and it corresponds to the conclusion of a sub-argument of A. The following four arguments can also be built from (ΠM,ΔM):

M3 and M1 are in conflict since they have contradictory conclusions, and so are M5 and M4, and M6 and M2. In DeLP, in order to solve conflicts, preferences among arguments can be provided in a modular way and hence, the most appropriate criterion for the application domain can be used. Since the argument comparison criterion is not the focus of our proposal, in the examples below we will assume that it is given as a relation denoted “>”. That is, considering that ARGSP is the set of all the arguments that can be obtained from a DeLP program P, the relation >⊆(ARGSP×ARGSP) establishes the preference among the arguments of ARGSP. We refer the interested reader to [20,21,41] where different argument preference criteria are described.

In this paper, agents will be characterised by three elements: (Π,Δ,>). The first element (Π) is a set of facts which represents the evidence that the agent has, whereas the second element (Δ) is a set of defeasible rules. Thus, from (Π,Δ) the agent will be able to build a set of arguments denoted ARGS(Π,Δ). The third element (>) is an argument comparison criterion, i.e., >⊆(ARGS(Π,Δ)×ARGS(Π,Δ)). For instance, in Example 2 we assume that the expert M has the following preferences: M5>MM4 and M2>MM6. Preferences allow to decide which argument prevails between two conflicting arguments:

Continuing with Example 2, for the agent M the argument M5 is a proper defeater for M4 because M5>MM4, and M3 is a blocking defeater for M1 because M3 and M1 are in conflict and there is no preference between M3 and M1. On the contrary, M6 is not a defeater for M1 because M2>MM6.

In DeLP, in order to determine whether a query h can be accepted as warranted from a program P, first it is necessary to find out if at least one argument A for h can be constructed from P. If such argument exists, then all the defeaters for A that can be constructed from P are considered as potential reasons against h. If there is one argument A for h and there are no defeaters for A, then A and its conclusion h are warranted from P. However, since defeaters are arguments, if one or more defeaters for A exists, then there may be defeaters for them, defeaters for those defeaters, and so on. Thus, for each defeater D, all the defeaters for D that can be constructed from P must be considered. This leads to the generation of a tree structure called dialectical tree with root A in which every node – except for the root – is a defeater for its parent. Figure 1 further below depicts different examples of dialectical trees. We will distinguish proper and blocking defeaters with different types of arrows. An unidirectional arrow from an argument D to another argument A denotes that D is a proper defeater for A. On the contrary, a bidirectional arrow from D to A denotes that D is a blocking defeater for A.

Given a dialectical tree T for A=⟨R,h⟩, every path from the root A to one leaf is called argumentation line, and each argumentation line represents a different sequence that alternates arguments in favour of h (called pro arguments) and arguments against h (called con arguments). That is, given an argumentation line Λ=[A1,A2,A3,A4,A5,…] the set of pro arguments is ΛP={A1,A3,A5,…} and the set of con arguments is ΛC={A2,A4,…}. A dialectical tree is considered acceptable when all its argumentation lines are acceptable (see Definition 4). Informally, that occurs when the argumentation lines satisfy certain constraints imposed on them to avoid infinite or circular argumentation and other undesirable situations. For instance, an argument cannot appear twice in the same argumentation line, and if an argument is defeated by a blocking defeater, that blocking defeater can only be defeated by a proper defeater. In addition, both the set of pro arguments and the set of con arguments must be concordant, that is, no contradictions must be derived when joining Π with all the defeasible rules from the arguments in ΛP or when joining Π with all the defeasible rules from the arguments in ΛC. We refer the interested reader to [21] and [22] for a complete explanation of those constraints.

Note that, given an acceptable dialectical tree, all the leaves of the tree are undefeated arguments. Therefore, to determine if A is either defeated or undefeated, the computation process of DeLP performs a marking of every node of the dialectical tree for A as follows: First, the leaves of the tree are marked as ⓤ (undefeated). Then the inner nodes – including the root – are marked as Ⓓ (defeated) if they have at least one child marked as ⓤ, or are marked as ⓤ if all their children are marked as Ⓓ.11

Figure 1 (left) shows the marked dialectical tree TM that the expert M can build for the query buy_stock(acme). Observe that the root of TM is marked as ⓤ. Given a query h, there can be more than one argument for h, and for each argument a different marked dialectical tree can be constructed. The next example shows how the expert agent proceeds in a scenario in which more than one dialectical tree for the same query can be constructed.

Fig. 1.

Marked dialectical trees from Example 2 and Example 3.

In Fig. 1 we show four marked dialectical trees that can be constructed from (ΠE,ΔE,>E). In figures, nodes of the dialectical trees will be depicted with triangles with the argument’s name inside, the argument’s conclusion at the top vertex, and the mark (ⓤ or Ⓓ) at the rightmost vertex. Given a marked dialectical tree T and a node A of T, root(T) denotes the argument that is the root of T, rootmark(T) denotes the mark assigned to root(T) and mark(A,T) denotes the mark assigned to A in T. For instance, in Fig. 1, root(T1) = A1, rootmark(T1)=ⓤ and mark(A4,T1)=Ⓓ. Given an argument A marked as Ⓓ in a dialectical tree T, a denier for A is a defeater D for A marked as ⓤ in T. That is, D precludes A from being marked as ⓤ in T. For instance, in Fig. 1, A6 is a denier for A3 in the dialectical tree T3.

We say that a literal q (respectively an argument A=⟨R,q⟩) is warranted by the agent (Π,Δ,>) if there exists at least one dialectical tree T for A constructed from (Π,Δ,>) such that rootmark(T)=ⓤ (i.e. A results undefeated). For instance, considering (ΠE,ΔE) and >E from Example 3, the agent E=(ΠE,ΔE,>E) warrants the literal a and the arguments A1 and A2, and does not warrant ∼a. Considering (ΠM,ΔM) and >M from Example 2, the agent M=(ΠM,ΔM,>M) warrants the literal buy_stocks(acme) and the argument M1.

Given a DeLP program P and a literal q, dtrees(P,q) will denote the set of all dialectical trees that can be constructed from P such that the root’s claim is the literal q. The set U-dtrees(P,q)⊆dtrees(P,q) is defined as U-dtrees(P,q)={T∈dtrees(P,q)|rootmark(T)=ⓤ}. That is, U-dtrees(P,q) contains all the dialectical trees from P that provide a warrant for q, and it will be empty if no warrant for q exists. Observe that U-dtrees(P,q‾) includes all the dialectical trees from P that provide a warrant for q‾. For instance, in Fig. 1, U-dtrees((ΠE,ΔE),a)={T1,T2} and U-dtrees((ΠE,ΔE),∼a)={}.

3.Client-expert interaction

The whole interaction between both agents is called a session, which starts with a query and finishes when the client believes in the expert’s position. We assume that the expert’s knowledge does not change during a session and that the client does not simultaneously maintain more than one session. If the client has specific personal information that represents a context for its query and would affect the expert’s answer, then this contextual information is sent before the session starts.

Once a new session has started, its current state will be determined by a session state. Intuitively, a session state is a structure that keeps track of all the elements that both agents had already communicated, and also other elements that the client needs to ask about and remain pending. As will be explained in detail below, those pending elements will allow the client to acquire the knowledge that it needs to understand the expert’s position while avoiding unnecessary loss of information. In the rest of the paper, we will distinguish the client agent with C=(ΠC,ΔC,>C) and expert agent with E=(ΠE,ΔE,>E). As stated above, the expert should know in advance all the relevant specific personal information from the client in order to give a proper answer. Since our approach focuses on the changes made on the client’s knowledge base, we assume that this specific contextual information is already considered in (ΠE,ΔE,>E). Session states will be used to formalise the elements that actually change during the client-expert interaction, and thus the client agent C will be part of the 5-tuple of the session states whereas the expert agent E will not.

When there is no ambiguity, session states will be simply referred to as “states”, and the query subscript q will be omitted. The first component in a state’s 5-tuple is the client agent C that made the query q. C is characterised by its knowledge and preferences among arguments (ΠC,ΔC,>C), which can change from state to state during the client-expert interaction. Although the other four components will be formalised and explained in detail further below, their intuitive meaning are introduced next: F is a set of arguments received by C which are all in favour of the claim of the justification sent by the expert. The goal of the client is to leave all the arguments in F marked as ⓤ. P is a set of pending preference questions, which are pairs of arguments (A,B) representing the question “What do you think about the preference between A and B?”. D is a set of pending denier questions, which are arguments for which the client needs defeaters from the expert. Finally, I is a sequence that gathers all the interaction elements, composed by preference questions and denier questions that were previously asked by C, and by defeaters and preferences that were previously sent by the expert.

Note that once a query q is posed to an expert agent, one of the following three alternatives could occur: (1) the expert believes in q (i.e. q is warranted by E), (2) the expert believes in the opposite (i.e. q‾ is warranted by E), or (3) the expert does not believe in q nor q‾ (i.e. q and q‾ are not warranted by E). In our approach, a session will only exist if one of the first two alternatives hold, that is, the expert has enough knowledge for a warrant for either q or q‾. When this occurs, the expert’s answer for the client’s query will be either an argument for q or an argument for q‾. This argument is called justification and will be denoted J. As will be proved further below, when the session which started by the query q finishes, J will be warranted by the client agent, and hence, the client will believe in claim(J).

Fig. 2.

Session evolution outline.

Figure 2 shows a directed graph that outlines how session states could evolve during a client-expert interaction. In that graph, nodes – identified with Greek letters – represent different session states of the interaction, while the directed arcs represent transitions among session states. All these transitions will be formally specified with transition rules during the rest of this section. For instance, the transition rule t1 will specify how the session evolves from the initial state (α) into a new state (β) in which the client has adopted information sent by the expert, whereas the transition rule t2 will specify the necessary conditions for the session to reach the final state. We will refer to Fig. 2 along the rest of this section in order to explain all the details of our approach.

First, two special session states will be distinguished: the initial state and the final state. Observe that a session starts (see α in Fig. 2) when a client agent C makes a query q to the expert agent – and, if necessary, sends specific contextual information from ΠC∪ΔC (see Section 6). Hence, an initial state contains the elements that characterise C before receiving anything from the expert, i.e. (ΠC,ΔC,>C), and the other four components are empty as follows: (C,[],∅,∅,∅)q

A final session state (see ω in Fig. 2) will have at least one interaction element in the tuple’s second component, and the last three components will be empty (i.e. all the pending issues will have been solved). The final state’s first component (C′) will characterise the client agent with all the knowledge that it will have adopted from the expert by the end of the session: (C′,[I1,…,In],∅,∅,∅)q

Once a session has started, the expert has to consider the initial query q made by the client and send one argument J which justifies its answer. As was shown in Section 2, the expert may have more than one dialectical tree whose root is suitable to be sent to the client as the justification J for the submitted query. Formally, the set U-dtrees((ΠE,ΔE),q) (or either U-dtrees((ΠE,ΔE),q‾)) can have more than one element. For instance, consider the example depicted in Fig. 1 and suppose that the client has sent the query a. Then, U-dtrees((ΠE,ΔE),a)={T1,T2}, and thus the expert has two dialectical trees’ roots as possible candidates to be the justification J. Since there can exist different strategies for selecting one element, our approach is defined in a modular way and we assume the existence of an operator select-dtree that selects one dialectical tree from a set of dialectical trees. Therefore, the most appropriate implementation for the dialectical tree selection could be used depending on the represented application domain. For instance, the expert could select – among the roots of the dialectical trees – the most relevant argument in that domain, or the strongest argument with respect to the used comparison criterion. The analysis and comparison of different implementations for select-dtree is out of the scope of this paper and is left as future work (see Section 8). Hence, the justification J sent by the expert agent for a query q is determined by the operator expert-justification introduced next:

As was explained above, the client’s goal is to accept the expert’s opinion, and hence, when the interaction is finished the client should believe the same as the expert about the submitted query. Therefore, when the client C receives the expert’s justification J, its goal is to be able to warrant claim(J) from its knowledge base (ΠC,ΔC). In order to achieve this, the client will first adopt the received argument J. Adopting an argument will consist in making the minimum necessary changes to (ΠC,ΔC) in order to be able to construct J. The client will then add rules and facts to its knowledge base and, in some cases, it will have to withdraw from ΠC the elements which are inaccurate from the expert’s point of view. The adoption of an argument is determined by the operator argument-adoption introduced next:

Consider a client agent (ΠC,ΔC,>C) that adopts an argument A=⟨R,h⟩. On the one hand, all the defeasible rules of R will be added to ΔC and the evidence of A will be added to ΠC. This added knowledge will allow the client to infer h. On the other hand, all the facts from ΠC that contradict the evidence from A or contradict the head of a rule in R will be erased from ΠC. Those erased elements would prevent the argument A from being built from the client’s knowledge base (see Section 2). Also, due to the minimality constrain that an argument should satisfy, all the facts from ΠC that are a head of a rule in R are also removed. The proof of Proposition 1 included in the appendix shows in detail why the literals in the sets X, Y, Z have to be erased upon an argument adoption. The following two examples show how the adoption operator behaves in two different scenarios. In the first one, the client (Kyle) has nothing to erase. In the second one, the client (Randy) has to erase elements in order to adopt the received argument. Note that, given an argument that can be constructed by both the client and the expert, for convenience the same argument name will be given to both.

The following proposition shows that, whenever the client agent adopts an argument from the expert agent, it is guaranteed that the client will be able to construct that argument. The proofs of all the formal results are in the Appendix section at the end of the paper.

Fig. 3.

Client agent Kyle before and after adopting A1.

Fig. 4.

Client agent Randy before and after adopting A1.

As it will be explained below, the justification J sent by the expert may not be the only argument that the client will need to adopt from the expert in order to achieve its goal. Thus, the operator argument-adoption will be used whenever the client receives an argument from the expert. Another important property that holds in our approach is that, whenever the client adopts a new argument, it is still able to construct all the arguments that it adopted previously from the expert:

In order to formally define our strategy and then prove its properties, the operational semantics of the interaction will be defined in terms of a transition system. A transition system is a set of transition rules for deriving transitions. In addition, a transition is a transformation of one session state into another. A transition rule has the form

When the transition rule t1 is executed, the justification J is added to the current session state’s second component and, therefore, the first interaction element in the sequence will always be that argument. J is also added to the current state’s third component (the set of received arguments in favour of the claim of J) because it will need to be analysed by the client. For instance, in Example 5, the transition rule t1 makes the session between Kyle and the expert evolve from the initial state (K1,[],∅,∅,∅)a into the state (K2,[A1],{A1},∅,∅)a. Consider also Example 6: since the expert sends Randy and Kyle the same justification, then Randy’s session evolves from the state (R1,[],∅,∅,∅)∼a into the state (R2,[A1],{A1},∅,∅)∼a. Nevertheless, as we will show below, given that both agents have different previous knowledge their sessions will evolve differently.

Recall that, in our approach, the client conceives the other agent as an expert and its goal is to believe in the expert’s qualified opinion. Since the client may have previous knowledge that can be in conflict with the information acquired from the expert agent (e.g. it could build a defeater for J), and its goal is to adopt all the expert knowledge, then the client may need to adapt its previous knowledge losing as little information as possible in order to be aligned with the expert’s position. As we will show next, the involved agents will exchange arguments until the client has a warrant for J from its own knowledge. From the client’s point of view, J will be the root of a dialectical tree T constructed from (ΠC,ΔC,>C) and, in order to warrant J, the result of rootmark(T) has to be ⓤ. Hence, whenever this mark is Ⓓ, the client should ask the expert for more information. This situation is captured by a session state (C,I,F,∅,∅) with F≠∅ (see β in Fig. 2) in which the client agent will check what it thinks about the previously adopted arguments in F in order to determine the course of the session. That could be: either it can warrant J and then the session finishes (see transition t2 to ω), or it still does not have a warrant for J and then it is necessary to ask subsequent questions to the expert agent (see transition t3 to γ). In order to determine this, the client will introspect into its own knowledge to check the mark (ⓤ or Ⓓ) of the previously adopted arguments.

Note that introspections check the mark of an argument in a particular dialectical tree. As we mentioned above, the client is only interested in the mark of that argument in the dialectical tree whose root is the justification J sent by the expert. When no confusion arises, when we talk about the mark of an argument, we implicitly refer to the mark of that argument in the dialectical tree (of the client or the expert, accordingly) whose root is J.

If the client makes an introspection to check the mark of the justification J (see β in Fig. 2) and results in ⓤ, this implies that it has a warrant for the claim of J and, therefore, the session can end. This behaviour is reflected in the following transition rule:

Recall that the first element in a session state’s second component is always the expert’s justification. If the transition rule t2 is executed the current state’s third component becomes empty, making the session evolve into the final state (see ω in Fig. 2). Example 7 illustrates a scenario in which the client does not have knowledge opposing the expert’s justification. That argument is adopted and no other changes are needed in the client’s knowledge in order to warrant it. In consequence, the session finishes.

Fig. 5.

Dialectical trees from Example 7 (left) and Example 8 (right).

In contrast to Example 7, the following example shows a scenario in which the client has a denier for the received justification. Hence, the result of the introspection would be Ⓓ and the session would not be able to end immediately. The client-expert interaction will continue with the client’s goal of having a warrant for the received justification.

A denier (as A4 in Example 8) is an argument defeating another argument which, from the expert’s position, is undefeated (as A1 in Example 8). Clearly the expert will not have deniers for the arguments that it sends to the client. However, since the client could have different knowledge, the client may construct a defeater that the expert cannot. In addition, the comparison criteria of both agents could differ. Finally, the expert could have a defeater for the denier that the client does not. Hence, in order to deal with its deniers, the client will first ask preference questions to the expert in order to adjust its preferences among its arguments. In DeLP the argument comparison criterion is modular and the most appropriate for the application domain being modelled can be used. Hence, we opted to formalize the preference between arguments as the relations >C and >E in order to abstract away from the details of the agents’comparison criteria. A discussion on how a particular comparison criterion can be applied to our approach can be found in Section 6. The operator preference-questions is defined as follows:

For instance, since in Example 8 A4 prevents A1 from being marked as ⓤ, the client will obtain a set of preference questions preference-questions(K,A1,A1)={(A4,A1)} and then will ask to the expert about its preference between both arguments. Similarly to introspections, the set of preference questions for a given argument is obtained from the dialectical tree whose root is the expert’s justification. The following proposition states that, if an argument is marked as Ⓓ, the set of preference questions that can be generated for that argument is not empty.

We mentioned above that the justification for the initial query may not be the only argument that the client will need to adopt during the session. As we will explain in detail below, other arguments – also in favour of the claim of the justification (called “pro arguments”) – can be received. Then, if the client makes an introspection to check the mark of the justification (see β in Fig. 2) and does not result in ⓤ, it means that some of these pro arguments are marked as Ⓓ. In this case, the client agent will proceed to ask preference questions for one of the furthest deniers from the root (see γ in Fig. 2). When this pro argument becomes marked as ⓤ later in the session, the pro argument marked as Ⓓ above in the same argumentation line may also become marked as ⓤ and so on, like a cascade effect. This behaviour is reflected in the following transition rule:

The transition rule t3 specifies how the set of preference questions P is generated in order to deal with those deniers. The rightmost (last) argument marked as Ⓓ in [I1,…,In] is selected, and the corresponding set of preference questions is added to the session state’s fourth component. For instance, consider again Example 8 in which the current session state is (K2,[A1],{A1},∅,∅)a after Kyle adopted the expert’s justification A1. It was shown that introspection(K2,A1,A1)=Ⓓ and, since preference-questions(K,A1,A1)={(A4,A1)}, the transition rule t3 can be executed, making the session evolve into (K2,[A1],{A1},{(A4,A1)},∅)a. That is, the new session state’s fourth component contains a preference question that will be sent to the expert. In the following example the client has more than one denier to deal with.

Fig. 6.

Dialectical tree from Example 9.

Whenever a set of preference questions P={(A2,A1),…,(An,A1)} is generated, the expert will answer them one by one by sending to the client its own preference between the corresponding pair of arguments. Then, the client will adopt such preference in order to deal with the deniers. Given a pair of arguments, the expert can either prefer the first over the second, prefer the second over the first, or believe that they are unrelated by the preference order, in which cases the expert will answer grt (greater), les (less), or unr (unrelated), respectively. Given a set of preference questions P={(A2,A1),…,(An,A1)} the expert agent always knows and is able to construct the second element of each pair because it corresponds to an argument that the client has previously received from the expert. However, the first argument in a preference question may not be considered as valid by the expert, either because it contains defeasible rules that are not in ΔE, uses evidence that is not in ΠE, or simply because it cannot be constructed (it is non-minimal or uses evidence that is contradictory to ΠE). In this case, considering the assumptions we have made for the expert, it will always prefer an argument that it can construct over an argument that it does not consider as valid; and the answer will be les (less). Then, the preference sent by the expert for a pair of arguments is determined by the operator expert-preference:

When the client receives from the expert a preference between two arguments, it will adjust its own preferences accordingly. Similarly to an argument adoption, in a preference adoption the client respects the expert’s opinion. The adoption of a preference is determined by the operator preference-adoption:

Note that the adoption of new preferences may require to withdraw from >C a preference between a pair of arguments which, from the expert’s position, is inaccurate.

The transition rules t4 and t5 will specify how the session evolves once a received preference is adopted. On the one hand, t4 is applicable when the adopted preference directly solves the problem with the denier. In this case, the corresponding preference question (A,B) is removed from P. On the other hand, t5 is applicable when the received preference is not enough to solve the problem with the denier. In this case, as with t4 the pair (A,B) is removed from P, but in addition A is added to the set of denier questions D. Every denier question A is an argument for which the client needs an undefeated argument D from the expert such that D defeats A.

Recall that, given a preference question (A,B) asked by the client, B is always undefeated from the expert’s point of view and, consequently, either A is marked as Ⓓ or A is an invalid argument that is not part of the dialectical tree. After adopting the corresponding preference for (A,B) from the expert, the client will make an introspection to check the mark of A. If A is not marked as ⓤ then A is no longer a denier (transition rule t4). On the contrary, if A is marked as ⓤ (i.e., A is still a denier for B) the client will need from the expert an undefeated defeater C for A (transition rule t5). C must exist because otherwise – from the expert’s point of view – B would not be an undefeated argument in favour of the justification. Note that the transition rules t4 and t5 will be executed until P is empty (see γ in Fig. 2).

Consider again the Example 8 in which the transition rule t3 was executed and the session reached the state (K2,[A1],{A1},{(A4,A1)},∅)a. Here, although P is not empty and expert-preference((A4,A1))=GRT, the transition rule t4 cannot be executed because introspection(K2,A1,A4)=ⓤ. Nevertheless, t5 is applicable and the session evolves into (K2,[A1],{A1},∅,{A4})a.