# Credulous and Skeptical Argument Games for Complete Semantics in Conflict Resolution based Argumentation

Argumentation is one of the most popular approaches of defining a non-monotonic formalism and several argumentation based semantics were proposed for defeasible logic programs. Recently, a new approach based on notions of conflict resolutions was proposed, however with declarative semantics only. This paper gives a more procedural counterpart by developing skeptical and credulous argument games for complete semantics and soundness and completeness theorems for both games are provided. After that, distribution of defeasible logic program into several contexts is investigated and both argument games are adapted for multi-context system.

## Authors

• 1 publication
07/10/2002

### Well-Founded Argumentation Semantics for Extended Logic Programming

This paper defines an argumentation semantics for extended logic program...
03/19/2021

### Weakly Complete Semantics Based on Undecidedness Blocking

In this paper we introduce a novel family of semantics called weakly com...
11/08/2018

### On the Graded Acceptability of Arguments in Abstract and Instantiated Argumentation

The paper develops a formal theory of the degree of justification of arg...
08/09/2017

### Measuring Inconsistency in Argument Graphs

There have been a number of developments in measuring inconsistency in l...
12/14/2016

### Web-based Argumentation

Assumption-Based Argumentation (ABA) is an argumentation framework that ...
12/16/2013

### Strategic Argumentation is NP-Complete

In this paper we study the complexity of strategic argumentation for dia...
08/17/2020

### Logical Semantics, Dialogical Argumentation, and Textual Entailment

In this chapter, we introduce a new dialogical system for first order cl...
##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Argumentation is successfully applied as an approach of defining non-monotonic formalisms. The main advantage of semantics based on formal models of argumentation is its closeness to real humans discussions. Therefore, the semantics can be explained also for people not trained in formal logic or mathematics.

To capture the knowledge, a logical language is needed. Usually the language of Defeasible Logic Programming (DeLP) is considered, where two kinds for rules are distinguished. Strict rules represent deductive reasoning: whenever their preconditions hold, we accept the conclusion. On the other hand, defeasible rules formalize tentative knowledge that can be defeated. Several semantics based on argumentation were proposed for defeasible logic programs [Prakken and Sartor1997], [García and Simari2004], [Caminada and Amgoud2007], [Prakken2010], [Modgil and Prakken2011], [Baláž, Frtús, and Homola2013]. However, as Caminada and Amgoud [Caminada and Amgoud2007] pointed out, careless design of semantics may lead to very unintuitive results, such as inconsistency of the system (justification for both an atom and its negation is provided) or unsatisfying of strict rules (system justifies all preconditions, but not the conclusion of a strict rule).

In this paper we take the approach by Baláž et al. [Baláž, Frtús, and Homola2013] as the starting point, since it both respects intuitions of logic programming and satisfies desired semantical properties. In [Baláž, Frtús, and Homola2013] notion of conflict resolutions and new methodology of justification of arguments is introduced, however only in a declarative way. Our main goal, in this paper, is to give a more procedural counterpart. This is especially useful when dealing with algorithms and implementations. We adapt skeptical and credulous argument games for complete semantics and prove soundness and completeness for both of them, what is the main contribution of this paper. Then we are investigating with distribution of defeasible logic program into several contexts (programs) and both argument games are adapted for distributed computing. This can be useful in ambient intelligence environments, where distributed and contextual defeasible reasoning is heavily applied.

The paper is structured as follows: first preliminaries of Dung’s abstract argumentation frameworks and defeasible logic programming are introduced. Then the declarative conflict resolution based semantics introduced in [Baláž, Frtús, and Homola2013] is recapitulated. Argument games are developed and their properties are proved in the next section. The last section is devoted to contextualization of defeasible logic programs.

## 2 Preliminaries

### 2.1 Argumentation Framework

###### Definition 1 (Abstract Argumentation Framework [Dung1995]).

An abstract argumentation framework is a pair where

1. is a set of arguments, and

2. is an attack relation on .

An argument attacks an argument if . A set of arguments attacks an argument if an argument in attacks . A set of arguments is attack-free111Note that we will use the original term “conflict-free” in slightly different context. if does not attack an argument in . A set of arguments defends an argument if each argument attacking is attacked by . An attack-free set of arguments is admissible iff defends each argument in . The characteristic function of an argumentation framework is a mapping where for all , is defined as .

###### Definition 2 (Extension [Dung1995]).

An admissible set of arguments is

1. complete extension iff contains each argument defended by .

2. the grounded extension iff is the least complete extension.

3. preferred extension iff is a maximal complete extension.

4. stable extension iff attacks each argument which does not belong to .

We will prove following lemma222Note that all proofs are presented in the extended version of the paper available at http://dai.fmph.uniba.sk/~frtus/nmr2014.pdf, which will be used in procedural formalization of the grounded semantics. Its intuitive meaning is that an argument to be in the grounded extension, it can not be defended only by itself.

###### Lemma 1.

Given an argumentation framework and a finite ordinal , argument iff for each argument defeating , there is an argument such that and .

### 2.2 Defeasible Logic Program

An atom is a propositional variable. A classical literal is either an atom or an atom preceded by classical negation . A default literal is a classical literal preceded by default negation . A literal is either a classical or a default literal. By definition equals to and equals to , for an atom and a classical literal . By we will denote the set of all default literals. By convention equals to for any set of literals .

strict rule is an expression of the form where , each , , is a literal, and is a classical literal. A defeasible rule is an expression of the form where , each , , is a literal, and is a classical literal. A defeasible logic program is a finite set of of strict rules and defeasible rules . In the following text we use the symbol to denote either strict or defeasible rule.

## 3 Conflict Resolution based Semantics

Existing argumentation formalisms [Prakken2010, García and Simari2004, Prakken and Sartor1997] are usually defined through five steps. At the beginning, some underlying logical language is chosen for describing knowledge. The notion of an argument is then defined within this language. Then conflicts between arguments are identified. The resolution of conflicts is captured by an attack relation among conflicting arguments. The status of an argument is then determined by the attack relation.

The conflict resolution based approach [Baláž, Frtús, and Homola2013] diverge from this methodology. Instead of attacking a conflicting argument, one of the weaker building blocks (called vulnerabilities) used to construct the argument is attacked. Specifically, the resolution of a conflict is either a default assumption or a defeasible rule. The status of an argument does not depend on attack relation between arguments but on attack relation between conflict resolutions.

Conflict resolution based semantics for the DeLP consists of five steps:

1. Construction of arguments on top of the language of defeasible logic programs.

2. Identification of conflicts between arguments.

3. Proposing a conflict resolution strategy.

4. Instantiation of Dung’s AFs with conflict resolutions.

5. Determination of the status of default assumptions, defeasible rules, and arguments with respect to successful conflict resolutions.

A vulnerability is a part of an argument that may be defeated to resolve a conflict. It is either a defeasible rule or a default literal.

###### Definition 3 (Vulnerability).

Let be a defeasible logic program. A vulnerability is a defeasible rule in or a default literal in . By we will denote the set of all vulnerabilities of .

Two kinds of arguments are usually be constructed in the language of defeasible logic programs. Default arguments correspond to default literals. Deductive arguments are constructed by chaining of rules. The following is a slightly more general definition, where a knowledge base denotes literals for which no further backing is needed.

###### Definition 4 (Argument).

Let be a defeasible logic program. An argument for a literal over a knowledge base is

1. , where

 \textscConc(A) =L \textscVuls(A) ={L}∩D
2. where each , , is an argument for a literal , is a rule in .

 \textscConc(A) =L \textscVuls(A) =\textscVuls(A1)∪⋯∪\textscVuls(An)∪({r}∩Δ)

By we will denote the set of all arguments of .

The typical example of knowledge base within the language of defeasible logic programming is the set of default literals and we will not specify until the section about contextual DeLP. Therefore, whenever the is left unspecified, it is implicitly set to . Arguments created by chaining of rules will be called deductive.

###### Example 1.

Consider the following defeasible logic program :

 ⇒a⇒c⇒b⇒da,b→hc,d→¬h

Six deductive arguments can be constructed from

 A1=[⇒a]A4=[⇒c]A2=[⇒b]A5=[⇒d]A3=[A1,A2→h]A6=[A3,A4→¬h]

Vulnerabilities of arguments are are and .

Two kinds of conflicts among arguments may arise, each corresponds to one type of negation.

###### Definition 5 (Conflict).

Let be a defeasible logic program. Arguments are conflicting iff rebuts or undercuts where

1. rebuts iff and are deductive arguments and ,

2. undercuts iff is a deductive argument, is a default argument, and .

The set is called a conflict. The first kind is called a rebutting conflict and the second kind is called an undercutting conflict. By we will denote the set of all conflicts of .

Conflicts are resolved by defeating one of the building blocks of conflicting arguments. Each default assumption or defeasible rule used to construct a conflicting argument is a possible resolution. Strict rules can not be used as a resolution of any conflict because they have to be always satisfied.

###### Definition 6 (Conflict Resolution).

Let be a defeasible logic program. A vulnerability is a resolution of a conflict if . The pair is called a conflict resolution. By we will denote the set of all conflict resolutions of .

In general, each conflict may have more resolutions. Some of them may be more preferred than others. The choice of preferred conflict resolutions is always domain dependent. Some vulnerabilities can be defeated in one domain, but they may as well stay undefeated in another. Therefore we allow the user to choose any conflict resolution strategy she might prefer.

###### Definition 7 (Conflict Resolution Strategy).

Let be a defeasible logic program. A conflict resolution strategy is a finite subset of . We say that a vulnerability is a -resolution of a conflict if . A conflict resolution strategy is total iff for each conflict there exists a -resolution of .

In existing approaches various conflict resolution strategies are applied. Examples of default, last-link and weakest-link conflict resolution strategies are presented in [Baláž, Frtús, and Homola2013].

###### Example 2 (Continuation of Example 1).

The only conflict in the defeasible logic program is the . Consider following six conflict resolutions.

 R1=(C,⇒a)R3=(C,⇒c)R2=(C,⇒b)R4=(C,⇒d)

Then , , are examples of conflict resolution strategies for . We can see that strategies , are total.

To determine in which way conflicts will be resolved, Dung’s AF is instantiated with conflict resolutions. The intuitive meaning of a conflict resolution is “the conflict will be resolved by defeating the vulnerability ”. The conflict resolution based semantics is built on three levels of attacks: attacks on the vulnerabilities, attacks on the arguments, and attacks on the conflict resolutions. Such an approach is necessary: if a vulnerability is defeated, so should be all arguments built on it, and consequently all conflict resolutions respective to the argument.

###### Definition 8 (Attack).

A conflict resolution attacks

• a vulnerability iff .

• an argument iff attacks a vulnerability in .

• a conflict resolution iff either

1. and attacks an argument in or

2. and attacks all arguments in .

A set of conflict resolutions attacks a vulnerability (resp. an argument or a conflict resolution ) iff a conflict resolution in attacks (resp. or ).

Intuitively, it should not happen that both a conflict resolution and a vulnerability are accepted. Therefore, if is accepted, and all arguments constructed on top of it should be defeated. The notion of attack between conflict resolutions formalizes the ideas that there may be more alternatives how to resolve a conflict and a conflict resolution may resolve other conflicts as well, thus causing other conflict resolutions to be irrelevant. The distinction between two kinds of attacks between conflict resolutions is necessary to achieve the intended semantics when dealing with self-conflicting arguments. The interested reader is kindly referred to [Baláž, Frtús, and Homola2013] for demonstrative examples.

###### Definition 9 (Instantiation).

The instantiation for a conflict resolution strategy is an abstract argumentation framework where

• is the attack relation on from the Definition 8.

Now thanks to the instantiation we can use the Dung’s semantics in order to compute which vulnerabilities (resp. arguments, conflict resolutions) are undefeated (status In), defeated (status Out), or undecided (status Undec).

###### Definition 10 (Defense).

Let be a conflict resolution strategy for a defeasible logic program . A set of conflict resolutions defends a vulnerability (resp. an argument or a conflict resolution ) iff each conflict resolution in attacking (resp. or ) is attacked by .

###### Definition 11 (Status).

Let be a conflict resolution strategy for a defeasible logic program and be a complete extension of the instantiation for . The status of a vulnerability (resp. an argument or a conflict resolution ) with respect to is

• In if defends (resp. or ),

• Out if (resp. or ) is attacked by ,

• Undec otherwise.

Let . By we denote the set of all arguments with the status with respect to a complete extension .

The following definitions define actual semantics of the DeLP program and entailment relation between a program and a literal .

###### Definition 12 (Output).

Let be a conflict resolution strategy for a defeasible logic program and be a complete extension of the instantiation for . The output of is a set of literals .

Note that we will omit default literals in output to improve the legibility.

###### Definition 13 (Entailment).

Let be a conflict resolution strategy for a defeasible logic program and be the instantiation for . Defeasible logic program skeptically (resp. credulously) entails a literal , (resp. ) iff for each (resp. at least one) complete extension of , .

###### Example 3 (Continuation of Example 2).

Consider the conflict resolution strategy from Example 2. The instantiation for is on the Figure 1.

All conflict resolutions are now exclusive, since to resolve the conflict, it is sufficient to reject only one of the defeasible rules. Therefore induces the complete graph.

There are five complete extensions , , , , of the instantiation and each of them determine one program output , , , , .

## 4 Procedural Semantics

In the previous section we recapitulated [Baláž, Frtús, and Homola2013] conflict resolution based semantics in the original declarative way. Although this declarative approach is very elegant and provides nice algebraic investigations, the more procedural style of semantics is appropriate when dealing with algorithms and implementations. One can see a parallel in a mathematical logic where we are similarly interested in a logical calculi (proof theory) which is sound and complete with respect to defined model-theoretic semantics. In this section our goal is to define skeptical and credulous argument games for complete semantics.

For a conflict resolution we define auxiliary functions which will be frequently used.

 con(R) ={A,B} res(R) =V vuls(R) =(\textscVuls(A)∖{V})∪(\textscVuls(B)∖{V})∪ (\textscVuls(A)∩\textscVuls(B)∩{V})

denotes the conflict and the resolution of a conflict resolution . The meaning of the set of vulnerabilities can be explained as following: suppose is in a conflict resolution strategy and is a complete extension of instantiation for . If and all the vulnerabilities in have the status In, then in order to resolve the conflict , the status of the vulnerability is Out.

Now we characterize the attack between conflict resolutions in terms of aforementioned functions. This will be useful in proofs for soundness and completeness of argument games.

###### Proposition 1.

Let be a defeasible logic program, a conflict resolution strategy and , are conflict resolutions. Then attacks iff .

Argumentation can be seen and thus also formalized as a discussion of two players. The aim of the first player (called proponent Pro) is to prove an initial argument. The second player is an opponent (Opp), what means that her goal is to prevent proponent to prove the initial argument. Hence a dispute essentially is a sequence of moves where each player gives a counterargument to the last stated.

Proof theory of argumentation is well studied area and argument games for various semantics were proposed [Modgil and Caminada2009], [Prakken and Sartor1997]. The process of proving a literal via an argument game, in conflict resolution based setting, considered in this paper, takes two steps:

1. Find an argument with conclusion .

2. Justify all vulnerabilities in .

Intuitively, a move is a triple denoting: player claims that the set of vulnerabilities is true and resolution is a reason for the other player why her set of vulnerabilities is not justified.

###### Definition 14 (Move).

Let be a conflict resolution strategy for a defeasible logic program . A move is a triple , where denotes the player, is a resolution and is a set of vulnerabilities.

Now since the very first move in a dialogue does not counter argue any of the previous move, the resolution will be left unspecified and in such case we will write . Convention and will be used for denoting the opposite players. We say that a move attacks a move iff .

###### Definition 15 (Argument Dialogue).

dialogue is a finite nonempty sequence of moves , where:

• (Opp) iff

is odd (even)

• attacks

Intuitively, for a given argument, there can be more than one counterargument. This leads to a tree representation of discussion. Now, since the burden of proof is on the player Pro, proponent proves an initial argument if she wins all disputes. On the other hand, the burden of attack is on the player Opp, meaning that opponent must “play” all possible counterarguments, against Pro’s last argument, forming new branches in a discussion tree.

###### Definition 16 (Argument Game).

Let be a conflict resolution strategy for a defeasible logic program . An argument game for an argument is a finite tree such that:

• is the root,

• all branches are dialogues,

• if move played by Pro is a node in the tree, then every move defeating is a child of .

• if , are any moves played by Pro in then does not defeat .

A player wins a dispute if the counterpart can not make any move (give a counterargument). This can roughly be paraphrased as “the one who has the last word laughs best”. Since the burden of proof is on the proponent, Pro, in order to win, has to win all branches in the game. On the other hand, for opponent to win an argument game, it is sufficient to win at least one branch of the game.

###### Definition 17 (Winner).

A player wins a dialogue iff she plays the last move in it. Player Pro (resp. Opp) wins an argument game iff she wins all (resp. at least on of the) branches in the argument game . An argument game is successful iff it is won by Pro.

###### Definition 18 (Proved Literal).

Let be a conflict resolution strategy for a defeasible logic program . A literal is :

• proved in an argument game iff is a successful argument game for an argument with .

• proved iff there is an argument game proving .

Now we propose two particular argument games and prove their soundness and completeness with respect to declarative semantics defined in the previous section.

### 4.1 Argument Game for Skeptical Complete Semantics

First we will investigate with skeptical complete semantics which corresponds to the grounded semantics. Since the grounded semantics gives the highest burden of proof on membership of the extension it defines, the opponent is allowed to repeat her moves and proponent is not.

###### Definition 19 (Skeptical Game).

An argument game is called skeptical iff in each branch of holds: if , are two moves played by Pro, then .

Argument game for skeptical complete semantics is sound and complete with respect to declarative conflict resolution based grounded semantics.

###### Proposition 2.

Let be a defeasible logic program and be a literal. iff is skeptically proved333literal is skeptically proved iff there is an skeptical argument game such that is proved in ..

Let demonstrate the skeptical argument game in example.

###### Example 4.

Consider the following defeasible logic program with conflict resolution strategy . There are two deductive arguments , , one conflict and two conflict resolutions , .

 A1=[⇒a]A2=[⇒¬a]C={A1,A2}R1=(C,⇒a)R2=(C,⇒¬a)

We would like to skeptically prove literal . The skeptical argument game for argument is on the Figure 2.

Proponent cannot repeat her move and therefore she loses the game.

### 4.2 Argument Game for Credulous Complete Semantics

Credulous complete semantics corresponds to the preferred semantics, where an argument can be defended by itself. Therefore, in credulous game, proponent is allowed to repeat her moves and opponent is not.

###### Definition 20 (Credulous Game).

An argument game is called credulous iff in each branch of holds: if , are two moves played by Opp, then .

Argument game for credulous complete semantics is sound and complete with respect to declarative conflict resolution based preferred semantics.

###### Proposition 3.

Let be a defeasible logic program and be a literal. iff is credulously proved444literal is credulously proved iff there is an credulous argument game such that is proved in ..

Now we will consider the defeasible logic program and conflict resolution strategy from Example 4 and try to prove literal credulously.

###### Example 5 (Continuation of Example 4).

We would like to credulously prove literal . The credulous argument game for argument is on the Figure 3.

Opponent cannot repeat her move and therefore the game is successful.

In [Governatori et al.2004, Billington et al.2010] several variants of defeasible logics with procedural semantics are proposed. Repeating an argument for Pro in our approach corresponds to the proof tag of [Billington et al.2010] and repeating an argument by Opp in our approach corresponds to the proof tag of [Billington et al.2010].

## 5 Contextual DeLP

In the previous section we developed a procedural semantics based on argument games, now we will generalize these ideas to a distributive setting, where not only one, but the whole set of defeasible logic programs is assumed. Each of these programs may be viewed as a context (i.e. agent), which describes the world within its own language (i.e. propositional symbols). Contexts are interconnected into multi-context system through non-monotonic bridge rules, which import knowledge (foreign literals) from other contexts.

Our goal is to adapt the argument games to multi-context systems and satisfy following requirements:

• To minimize the necessary communication complexity between contexts. The conflict between arguments can be decided in other context, but the structure of arguments should not be communicated.

• Contexts provide just distributive computing, they should not change the semantics. Hence if we look at multi-context system as a monolithic program, the output should be the same as in distributive case.

Note that the distributed reasoning is a very complex task involving also issues of communication protocols and information security. In this chapter we abstract from this and focus only on the reasoning part.

Distributed computing of semantics is a hot topic in the area of multi-agent systems, for García and Simari’s [García and Simari2004] DeLP a distributed argumentation framework was proposed in [Thimm and Kern-Isberner2008]. Contextual defeasible reasoning is also applied in environment of Ambient Intelligence [Bikakis and Antoniou2010], where devices, software agents and services are supposed to integrate and cooperate in support of human objectives.

A vocabulary is a set of propositional variables. We say that a literal is local if its propositional variable is in , otherwise it is foreign. A local rule contains only local literals. A mapping rule contains local literal in the head and at least one foreign literal in the body. A contextual defeasible logic program is a set of local strict rules, and local or mapping defeasible rules.

Sometimes we will denote the context pertaining to a foreign literal. For example means that foreign literal is imported from the second context.

###### Definition 21 (Context).

context is a triple where is a set of propositional variables, is a contextual defeasible logic program and is a conflict resolution strategy.

Since, within the one context we do not know the structure of an argument supporting some foreign literal, foreign literals cannot be used as resolutions of conflicts (their set of vulnerabilities is empty).

Contextual argument is an argument, where some of the literals (foreign) do not need a further backing and are considered as an import of the knowledge from the other context.

###### Definition 22 (Contextual Argument).

Given a context and the set of foreign literals , a contextual argument is an argument over a knowledge base . The set of all foreign literals contained by an argument in a set of arguments will be denoted .

Contextual argument is foreign if it is of the form , where is a foreign literal.

Following proposition means that foreign literals cannot incorporate a conflict.

###### Proposition 4.

Given a context and the set of foreign literals , a foreign argument cannot be in conflict with by any contextual argument from context .

###### Definition 23 (Multi-Context System).

multi-context system 555Note that symbol was originally used to denote a conflict and symbol for denoting the set of all conflicts. However, the denotation of symbols will always be clear from the actual text. is a finite nonempty set of contexts where , each , , is a context and is a partition of the set of all propositional variables in .

A multi context system is cyclic iff there are contexts , such that context , , contains a mapping rule with a foreign literal from the context and , contains a mapping rule with a foreign literal from the context . A multi context system is acyclic iff it is not cyclic.

Sometimes it is useful to look at a multi-context system as a monolithic defeasible logic program and vice versa. We say that a multi-context system is a contextualization of a defeasible logic program and conflict resolution strategy iff and . The idea of contextualization of a program or an argument is illustrated in the following example.

###### Example 6.

Consider the following multi-context system consisting of two contexts

Six contextual arguments can be constructed in

 A11=[⇒a]A14=[c]A12=[b]A15=[⇒d]A13=[A11,A12→h]A16=[A14,A15→¬h]

Two contextual arguments can be constructed in

 A21=[⇒b]A22=[⇒c]

We can see that is a contextualization of defeasible logic program and conflict resolution strategy from Example 2. Similarly, we will define a notion of contextual version of argument by examples: arguments , , , are (in order) contextual versions of arguments , , , , but , are not contextual versions of arguments , in Example 1.

The process of proving a literal via an argument game in contextual setting is still consisting of two steps:

1. Find a contextual argument with conclusion .

2. Justify all vulnerabilities in and send acceptance queries to contexts pertaining to foreign literals .

The second step means that whenever a player plays in a dialogue a move , not only all vulnerabilities of but also all foreign literals occurring in must be justified in order to will be the winner.

It is not hard to see that support dependency through foreign literals may be cyclic in a multi-context system. For example context may use a foreign literal from context and vice versa. Therefore we have to take care of termination of the queries to other contexts.

###### Example 7.

Consider the following multi-context system consisting of two contexts, each using foreign literal from the other context.

Context 1 Context 2

Where conflict and conflict .

Consider now query about credulous acceptance of literal . There is only one rule deriving and the only conflict resolution defeating it. Recall the intuitive meaning of conflict resolution in distributive setting: If the vulnerability and foreign literal are accepted, rule is defeated. Defeasible rule is not a resolution of any conflict so its trustworthiness is not a subject of dispute. Now the query about acceptance of the foreign literal is given to the Context 2. The process of proving in Context 2 is similar, therefore we skip details and only remark that query about acceptance of the foreign literal is given back to the Context 1. We can see that naive adaptation of argument games may lead to infinite sending of queries between contexts which have cyclic support dependency.

To overcome problem illustrated in the previous example, from now on in this paper we investigate with acyclic multi-context systems only and more general cases are left for the future work.

Now we will define notions for contextual proving and argument games. Contextual argument game is an argument game accompanied with a query function defining queries for every move in . Intuitively, a query is a foreign literal that needs to proved in other context.

###### Definition 24 (Contextual Argument Game).

Let be a context and be a move . A contextual argument game for a contextual argument is a pair , where is an argument game for and is a query function

 Q(μ)={F({A})if μ % is the root of the treeF(con(R))otherwise

assigning queries for each move.

We say that a contextual argument game for a literal is a contextual argument game for a contextual argument with . Given a query function , the set of all foreign literals, played by a player in a contextual argument game , will be denoted by .

Contextual skeptical and credulous games respect conditions of move repetitions. That is, in contextual skeptical (credulous) game, opponent (proponent) is allowed to repeat her moves and proponent (opponent) is not. However, since parts of the argument game can be queried to another contexts, we have to take care that requirements of (non)repetitions of moves are satisfied also there. Realize that each time a query about foreign literal to other context is sent from a move in an argument game , no matter whether is proponent or opponent, the argument game for in context will be started by proponent. Therefore, if is Pro, the semantics of argument game in context does not change. On the other hand, if is is Opp, the semantics of argument game in context will switch in order to keep the requirements of (non)repetitions of moves.

This leads into two mutually recursive definitions of skeptical and credulous contextual argument games. Note however that the recursion is well-founded (always terminates) since we are considering multi-context systems with acyclic support dependency only.

###### Definition 25 (Contextual Skeptical Game).

Let be a move . A contextual argument game is called skeptical iff

• is skeptical game and

• for each move in with there is a  contextual argument game, where

 sem(μ)={skepticalif pl=\textscProcredulousotherwise

defines the acceptance semantics for queries.

###### Definition 26 (Contextual Credulous Game).

Let be a move . A contextual argument game is called credulous iff

• is credulous game and

• for each move in with there is a  contextual argument game, where

 sem(μ)={credulousif pl=\textscProskepticalotherwise

defines the acceptance semantics for queries.

Recall that player , in order to be the winner, has to justify not only all the vulnerabilities played by her, but also all ’s queries have to successful. Hence, although player does not play the last move in a dialogue, she can still be a winner if a query of the second player is not justified.

Again, the definition is recursive but the assumption of acyclicity guarantees its termination.

###### Definition 27 (Contextual Winner).

Let be a contextual argument game. A player wins a dialogue in contextual argument game iff

• all contextual argument games for literals in are successful and

• at least one of the following holds:

• plays the last move in the dialogue, or

• at least one of the contextual argument game for literals in is not successful.

A player Pro (resp. Opp) wins a contextual argument game iff she wins all (resp. at least one of the) branches in the contextual argument game. A contextual argument game is successful iff it is won by Pro.

###### Definition 28 (Contextually Proved Literal).

Let be a multi-context system and be a context. A literal is (skeptically, resp. credulously) proved in:

• a contextual argument game iff there is a contextual argument with , is an (skeptical, resp. credulous) argument game for and is successful.

• a context iff , and there is a contextual argument game (skeptically, resp. credulously) proving .

• a multi-context system iff there is a context such that is (skeptically, resp. credulously) proved in .

One of our goals was that contextualization of a program provides just a distributive computing and should not change its output. The following proposition claims that we are successful by achieving it.

###### Proposition 5.

Let be an acyclic contextualization of a defeasible logic program and be a literal.

1. iff is skeptically proved in .

2. iff is credulously proved in .

Distribution of argument games is demonstrated in example.

###### Example 8.

Consider the following multi-context system consisting of two contexts

Three contextual arguments can be constructed in

 A11=[⇒a]A12=[b]A13=[A12⇒¬a]

Two contextual arguments can be constructed in

 A21=[⇒b]A22=[⇒¬b]

The contextual argument game (both skeptical and credulous) is on the Figure 4, the contextual game for query is on the Figure 5.

Although the proponent did not play the last move in , she is still winner, since the query about foreign literal was not successful.

## 6 Conclusion

We have developed a procedural conflict resolution based semantics by adaptation of skeptical and credulous argument games for complete semantics. The soundness and completeness properties for both type of games are proved, what is the main contribution of this paper. At the end we have showed how the semantics of defeasible logic program can be computed in a distributive fashion and both skeptical and credulous argument games were modified for multi-context systems. However, only multi-context systems with acyclic support dependency have been considered and the more general cases were left for the future work.

## References

• [Baláž, Frtús, and Homola2013] Baláž, M.; Frtús, J.; and Homola, M. 2013. Conflict resolution in structured argumentation. In

Proceedings of the 19th International Conference on Logic for Programming, Artificial Intelligence, and Reasoning

.
• [Bikakis and Antoniou2010] Bikakis, A., and Antoniou, G. 2010. Defeasible Contextual Reasoning with Arguments in Ambient Intelligence. IEEE Transactions on Knowledge and Data Engineering 22(11):1492–1506.
• [Billington et al.2010] Billington, D.; Antoniou, G.; Governatori, G.; and Maher, M. 2010. An inclusion theorem for defeasible logics. ACM Trans. Comput. Logic 12(1):6:1–6:27.
• [Caminada and Amgoud2007] Caminada, M., and Amgoud, L. 2007. On the evaluation of argumentation formalisms. Artificial Intelligence 171(5-6):286–310.
• [Dung1995] Dung, P. M. 1995. On the acceptability of arguments and its fundamental role in nonmonotonic reasoning, logic programming and n-person games. Artificial Intelligence 77(2):321–357.
• [García and Simari2004] García, A. J., and Simari, G. R. 2004. Defeasible logic programming: an argumentative approach. Theory and Practice of Logic Programming 4(2):95–138.
• [Governatori et al.2004] Governatori, G.; Maher, M. J.; Antoniou, G.; and Billington, D. 2004. Argumentation semantics for defeasible logic. J. Log. and Comput. 14:675–702.
• [Modgil and Caminada2009] Modgil, S., and Caminada, M. 2009. Proof theories and algorithms for abstract argumentation frameworks. In Rahwan, I., and Simari, G., eds., Argumentation in Artificial Intelligence. Springer Publishing Company Incorporated. 105–129.
• [Modgil and Prakken2011] Modgil, S., and Prakken, H. 2011. Revisiting Preferences and Argumentation. In Proceedings of the Twenty-Second International Joint Conference on Artificial Intelligence, 1021–1026. AAAI Press.
• [Prakken and Sartor1997] Prakken, H., and Sartor, G. 1997. Argument-based extended logic programming with defeasible priorities. Journal of Applied Nonclassical Logics 7(1):25–75.
• [Prakken2010] Prakken, H. 2010. An abstract framework for argumentation with structured arguments. Argument & Computation 1(2):93–124.
• [Thimm and Kern-Isberner2008] Thimm, M., and Kern-Isberner, G. 2008. A distributed argumentation framework using defeasible logic programming. In Proceedings of the 2008 Conference on Computational Models of Argument: Proceedings of COMMA 2008, 381–392. Amsterdam, The Netherlands, The Netherlands: IOS Press.