Paraconsistent argumentation schemes 1

Abstract

Various types of everyday arguments are represented as argumentation schemes, originating from the Legal Argumentation literature. The recent achievements in this domain can be applied to multi-agent settings to enrich the paradigmatic aspects of communication and reasoning. Agents typically populate complex environments where incompleteness and inconsistency of information is rather a rule than exception. Although the problem how to tackle inconsistencies is already present in argumentation, a paraconsistent (that is, tolerating inconsistency) approach is still missing from the literature. The contribution of this research is a computationally-friendly framework for formalizing paraconsistent argumentation schemes. This is achieved by extending agent’s reasoning capabilities with non-deductive methods rooted in argumentation. To this end we provide a generic paraconsistent program template for implementation of various argumentation schemes.

Our methodology is strongly influenced by ideas underlying 4QL: a four-valued, rule-based, Datalog^¬¬-like query language. Thanks to its properties, the tractability of the solution (so hardly obtainable in logical modeling) has been reached. The paper concludes with examples of several paraconsistent argumentation schemes implemented in 4QL.

Keywords

Multi-agent systems communication nonmonotonic reasoning paraconsistent argumentation schemes

1. Modeling assumptions

The logical modeling of complex phenomena appearing in the context of intelligent distributed systems sometimes lacks realism. What emerges, is often both computationally complex and idealized theories not fitting well the modeled reality. A great deal of this mismatch lies in the quality of information available in dynamic and unpredictable environments. Intelligent agents, viewed as autonomous information sources, may perceive the surrounding reality differently while building their informational stance. The information they need to handle comes from multiple sources of diverse credibility, quality or significance. Even though consistency of their beliefs is a desirable property, in practice it is hard to achieve. Thus, when modeling real-world situations, ignorance and inconsistency of information occurs naturally. However, instead of making a reasoning process trivial, what is a hindrance in classical logical systems, we view inconsistency as a first-class citizen and try to efficiently deal with it. This leads to creating logical systems which tolerate inconsistencies, i.e., to paraconsistent systems. On the other hand, as missing knowledge can be completed and inconsistent information can be disambiguated, the realistic modeling of agency requires nonmonotonic reasoning mechanisms, where new information may invalidate previously obtained conclusions. Such approach to lacking and inconsistent information is the basis of realistic models of agency. Despite the rich field of non-monotonic reasoning and paraconsistent formalisms (see Section 1.1 and 1.2 for a survey), in general a tractable approach that combines both aspects was missing from the multi-agent systems (MAS) literature.

The approaches to modeling agency typically feature the informational and motivational stance of an agent, comprising beliefs, intentions and commitments. From multiple available frameworks (see a discussion about realistic models of agency in Section 1.3), our solution falls into the category of rule-based systems: we associate individual agents with programs composed of a set of facts and reasoning rules organized into a layered architecture by the use of modules.

To reflect the diversity of possibilities we view agents as heterogeneous reasoners. Following Dunin-Kȩplicz and Szałas [23], the way the individual agents deal with conflicting or lacking information is encoded in their epistemic profile (see Section 3). Typically, an epistemic profile embodies agents’ reasoning capabilities. These in turn influence the agent’s deductive processes to finally affect their belief structures, i.e., agents’ informational stance [23]. Moreover, various agents may reason differently using diverse methods of information disambiguation.

This paper is a part of a larger research program, whose overall goal is a creation of a paraconsistent model of agents’ communication, suitable for dealing with unsure and incomplete information especially in applications related to multi-agent systems. Generally, MAS are created for the synergistic effect of collaborating agents, thus their essence is complex interactions. They are vital to the paradigmatic activities like coordination, collaboration and negotiation, which naturally include phases of communication and reasoning. Therefore, an adequate modeling of communication is one of the challenges in building autonomous agents.

Communication has a long tradition as an important topic in computer science, specifically in (distributed) artificial intelligence and recently in MAS [15,45]. Starting from fixed communication protocols in distributed systems, we now attempt to approach flexible dialogues among agents (see e.g., [14]). To achieve the goal of agents communicating freely in the paraconsistent world, we build upon Austin and Searle’s theory of speech acts [3,44] and Walton and Krabbe semi-formal theory of dialogue [55]. We view the dialogue participants as independent information sources, which try to expand, contract, update, and revise their beliefs through communication. Taking this perspective, speech acts are “actions that change your mind” [51] and provide the necessary building blocks to construct complex dialogues, such as information seeking, inquiry, persuasion, negotiation or deliberation.

We have initiated our research program, by proposing a paraconsistent framework for perceiving new facts [21]. That enabled the agents to discuss their informational stance, i.e.,:

inform one another about values of different propositions via assertions,

ask for other agents’ values via requests,

acknowledge the common values via concessions, and

question the contradictory values via challenges.

The second step was a preliminary analysis on communication involving reasoning rules [17]. In that paper, a model for assertions and concessions regarding reasoning rules was proposed, permitting the agents to accept or reject another agent’s reasoning rule according to a defined admissibility criterion. Recently, these building blocks were used to construct tractable, sound and complete inquiry dialogues in the paraconsistent settings [20]. In the current paper we show how to extend agent’s reasoning capabilities with non-deductive methods like argumentation skills, which will later enable agents to conduct arguments over reasoning rules. To this end, we study so-called argumentation schemes [56] (see Section 1.3).

Indeed, the question whether to adopt, challenge or reject a reasoning rule has no single straightforward answer. This issue has been studied from multiple angles. In the Belief Revision approach the influence of reasoning rules on agents’ knowledge bases was studied. Our solution proposed in [17] followed this approach. A different approach leverages the social choice theory methods where the decision about the admissibility of a rule is made on the social level (see e.g., [19]). Finally, yet another research thread concerns the methods originating form the Legal Reasoning, where argumentation schemes are proxies for an ontology of reasoning methods. In such approach a reasoning rule can be accepted if it is an instance (or a template) of an established argumentation scheme.

1.1. Paraconsistency in multi-agent settings

In real-world applications one should accept uncertainty and inconsistency of information, assuming that four types of situations may occur:

fact a holds,

fact a does not hold,

it is not known whether a holds (no source has any information about a),

information about a is inconsistent (some sources claim a holds, other that a does not hold).

Modeling assumptions of this research require the use of a paraconsistent and paracomplete formalism. Put crudely, paraconsistency is a property of logics whose logical consequence relation is not explosive (i.e., where ex contradictione quodlibet (ECQ) does not hold). Indeed, the principle of explosion is controversial to paraconsistent logicians who argue that “the move from a contradiction to an arbitrary formula does not seem like reasoning” and provide examples of such absurd “proofs” [40].

Needless to say, paraconsistency was studied from multiple angles (see e.g., [7,9,12,40] for paraconsistent reasoning techniques):

discussive logic of Jaśkowski [27] aimed at ensuring that contradictory sentences do not arise by blocking the rule of adjunction;

preservationist school of Schotch and Jennings [43] for reasoning with consistent subsets of premisses;

relevance logics (Orlov, Belnap, Anderson, see [2] and references therein) required that premisses are relevant to the conclusion;

C-System of da Costa [11] (and its generalization: logics of formal inconsistency) allowed to distinguish consistent sentences from inconsistent ones and reason about them differently;

Priest’s logic of paradox [38] utilized third truth value (both) and identified designated values (true, both) to allow reasoning about paradoxes;

logic of Belnap [4] added unknown and inconsistent truth values to reason about information from many sources.

Although to model phenomena such as lack and inconsistency of information, the Belnap’s four-valued logic is commonly used, it often provides counter-intuitive results in ares we focus on (see [16,53] for details). Let us recall the well-known example to show one problematic situation.

Example 1.
A family owns two cars: $c_{1}$ and $c_{2}$ . Then, $safe (c_{1}) \lor safe (c_{2})$ expresses whether the family has a safe car. The safety of car $c_{1}$ was checked by two different mechanics $m_{1}$ and $m_{2}$ . The first expert $m_{1}$ confirmed the safety of the car but the second expert $m_{2}$ denied the car is safe. Car $c_{2}$ has not gone through any safety tests yet. Thus, the truth values of $safe (c_{1})$ and $safe (c_{2})$ are: $i$ and $u$ respectively. When ∨ is defined by Belnap’s truth ordering, we get $safe (c_{1}) \lor safe (c_{2}) = i \lor u = t$ . However, due to contradictory results of safety tests, the safety of car $c_{1}$ is unclear. Moreover, we know nothing about safety of car b. Similar example shows that also Belnap’s ∧ operator yields counter-intuitive results.

The logic underpinning our implementation tool (see Section 5) does not share such problems therefore is better suited for this research.
1.2. Nonmonotonic reasoning in agency

The second important aspect of realistic modeling is allowing that “additional information may invalidate conclusions” [50]. Indeed, agents are situated in environments where only incomplete information is available, so any monotonic formalism (where new information never invalidates conclusions) is inadequate to capture this phenomenon.

Currently, there is a variety of nonmonotonic techniques (see e.g. Chapter 6 in [50] for general nonmonotonic/defeasible reasoning techniques):

Reiter’s default reasoning [41], consisting of applying defaults, i.e., meta-rules of the form “in the absence of any information to the contrary assume…” [50];

Closed World Assumption (CWA) [42], to represent how databases handle negative information;

Moore’s autoepistemic logic [34] to formalize how perfectly rational agents form beliefs;

McCarthy’s Circumscription [33] to model “jumping to conclusions” by minimizing the extent of abnormal predicate;

Preferential models [28] based on preference relation expressing typicality of possible worlds (e.g., Shoham’s preference logic);

Nute’s Defeasible Logic [35] encompassing strict and defeasible rules together with a preference relation among defeasible rules.

As typically these nonmonotonic techniques were designed to formalize phenomena appearing in commonsense reasoning, they are suitable for modeling rational agents. On the other hand, argumentation schemes attempt to classify the various types of everyday arguments, utilizing the ideas underlying the formalisms described above. As characterized in [56], argumentation schemes (AS)

“are argument forms that represent inferential structures of arguments used in everyday discourse, and in special contexts like legal argumentation, scientific argumentation and especially in AI”.

Each scheme is accompanied by a set of critical questions, used to evaluate the argument (see e.g., Table 1). Although the various argumentation schemes may represent different types of reasoning (e.g., deduction, induction, abduction, presumption, see also the tentative classification given in [56], Chapter 10), in general their goal is to model plausible, thus defeasible, reasoning.

1.3. Looking for tractability

The entire line of our research is characterized by a shift in perspective: instead of creating complex logical theories, we tailor them to their tractable versions, like rule-based systems. Then, instead of reasoning in logical systems of high complexity we query paraconsistent knowledge bases.

Many important aspects of classical agency have to be adjusted when adopting a paraconsistent semantics. First of all, the AGM postulates for Belief Revision [1] are no longer valid (but see [39,48]). On the other hand, some assumptions underlying classical formalizations of agency (Dynamic Epistemic Logic (DEL) [49], intention logic [10]; BDI [26] & KARO [52] frameworks) are unpractical: real agents do not have infinite resources (like time) available for reasoning and they are not logically perfect reasoners. Therefore a formalism which does not require such assumptions would be preferred.

Our approach is strongly influenced by ideas underlying 4QL: a four-valued paraconsistent query language introduced by Małuszyński and Szałas (see [29,30] and Section 5 for details). We have chosen 4QL as a suitable tool for formalizing paraconsistent argumentation schemes (PAS), as it provides simple, yet powerful constructs for application of a range of well-known nonmonotonic techniques (see [22] for examples of default reasoning, autoepistemic reasoning, defeasible reasoning and the (Local) Closed World Assumption expressed in 4QL).

The contribution of the paper is extending epistemic profiles with paraconsistent argumentation schemes, providing templates for their implementation and ensuring tractability of reasoning by using 4QL.

This paper is an extended version of our conference paper [18]. In comparison to [18] we:

provide implementation and discussion of additional five argumentation schemes,

show scheme embedding, based on the Reputation and Prudence schemes to reason about trust,

elaborate on the role of communicative relations and their relationship to the Ethotic Argument,

revise and extend discussion and background.

The paper is structured in the following way. First, in Section 2, we describe the computational approach to argumentation schemes. Next, in Section 3 the language and logic used throughout the paper as well as the concept of epistemic profiles and belief structures are introduced. Section 4 presents the main contribution of this paper, namely the formalization of the paraconsistent argumentation scheme as a part of epistemic profile. In Section 5 our implementation tool of choice is described. Section 6 presents the formalization of paraconsistent argumentation schemes with use of the notion of well-supported models as well as the implemented solution, which we illustrate on four argumentation schemes: Expert Opinion, Position to Know, Perception and Ethos. In Section 7 we show how to embed schemes, utilizing the Reputation and Prudence scheme for reasoning about trust. Section 8 concludes the paper.

2. Computational perspective on paraconsistent argumentation schemes

The aim of this work is augmentation of agents’ inferential capabilities with the methods rooted in argumentation. Our primary goal is to provide means for implementing the paraconsistent argumentation schemes in a tractable way. This computational approach aims at combining techniques of classical reasoning with non-monotonic, argumentative reasoning. The conclusions obtained with the use of both methods exist on equal terms, but possibly can be used in different situations.

Following [37], we simplify the set of critical questions to those pointing to the specific undercutters, called exceptions. Thus, the exceptions serve as means to both undercut the argument and shift the burden of proof to the other side [56].

Observation that most common sense rules have exceptions gave birth to nonmonotonic reasoning techniques [50], however the difficulty lied in specifying all the ‘abnormal’ cases. Here, through modeling critical questions as exceptions, we try to minimize the set of abnormalities under which the scheme is not applicable. All in all, the opponent may attack the claim in three ways:

by rebutting the premisses,

by rebutting the conclusion,

by undercutting the argument using the exceptions.

In addition, we encourage a rigorous separation of various aspects of reasoning:

the information,

the opinion about the information and its source,

the disambiguation of inconsistent information.

To illustrate this, consider our running example: the argument from Expert Opinion. It is summarized in Table 1 (see also its implementation in 4QL presented in Fig. 4). The first column conveys the original form of the argument, including the scheme (premises, conclusion) and critical questions (as in [56]). The second column presents the adapted, paraconsistent version of the argument. There, the set of critical questions is replaced with the set of exceptions and the original premises are encoded by four-valued literals. Importantly, the conclusion is tetravalent (

v (is (X)) = V

means that the value of

is (X)

is V, where V can be one of:

t

f

i

u

). Consider an expert e states that “it is unknown whether a medicament m is safe to use during pregnancy”. In this case, the conclusion of the Expert Opinion scheme, safe(m, pregnancy), should take the

unknown

value, which is far more expressive and accurate than

false

, which would have been chosen in the standard 2-valued approach under the Closed World Assumption.

Table 1
Expert Opinion Argumentation Scheme

Original Argumentation Scheme

Scheme A is an expert in domain D

A asserts that X is true

X is within D

X is true

Critical Questions How credible is A as an expert source?

Is A an expert in domain D?

What did A assert that implies X?

Is A personally reliable as a source?

Is X consistent with what other experts assert?

Is A’s assertion of X based on evidence?

Paraconsistent Argumentation Scheme

P-Scheme isExpert(A, D)

assert(A, X, V)

inDomain(X, D)

$v (is (X)) = V$

Exceptions ¬isReliable(A)

¬evidenceBased(A, X, V)

	Original Argumentation Scheme
Scheme	A is an expert in domain D
A asserts that X is true
X is within D

X is true
Critical Questions	How credible is A as an expert source?
Is A an expert in domain D?
What did A assert that implies X?
Is A personally reliable as a source?
Is X consistent with what other experts assert?
Is A’s assertion of X based on evidence?
	Paraconsistent Argumentation Scheme
P-Scheme	isExpert(A, D)
assert(A, X, V)
inDomain(X, D)

$v (is (X)) = V$
Exceptions	¬isReliable(A)
¬evidenceBased(A, X, V)

Now, the various aspects of the reasoning can be easily distinguished:

object level, e.g., the claim $assert (A, X, V)$ ,

meta-level:

the reasoning about the claim, e.g., using $inDomain (X, D)$ , $evidenceBased (A, X, V)$ ,

the reasoning about the sender agent, e.g., using $isExpert (A, D)$ , $isReliable (A)$ .

meta-meta-level: reasoning about the compatibility of experts’ opinions (here it is excluded from the scheme, as it corresponds to disambiguation of inconsistent information arising from multiple sources of opinion).

Our formalization concerns a mechanism for specifying any argumentation scheme. In addition, when formalized in 4QL, the solution becomes tractable. Since 4QL captures all tractable queries, the expressiveness is maintained.

3. Language and epistemic profiles

The heterogeneity of agents’ means, among others, that even when seeing the same thing, the particular individuals may draw different conclusions. The powerful notion of epistemic profile [23] explicitly models this problem. In general, it defines the way an agent reasons (e.g., in this paper a rule-based agent implementation is assumed), including the manner of dealing with conflicting or lacking information (e.g., by combining various forms of reasoning available to the agent, including belief fusion, disambiguation of conflicting beliefs or completion of lacking information).

The following definitions are adapted from [23], where intuition and examples can be found.

In what follows all sets are finite except for sets of formulas. We deal with the classical first-order language over a given vocabulary without function symbols presented in [23,29,46]. We assume that $Const$ is a fixed set of constants, $Var$ is a fixed set of variables and $Rel$ is a fixed set of relation symbols. We shall use this notation in the following definitions.

Definition 1.
A literal is an expression of the form $R (\bar{τ})$ or $\neg R (\bar{τ})$ , with $\bar{τ}$ being a sequence of parameters, $\bar{τ} \in {(Const \cup Var)}^{k}$ , where k is the arity of R. Ground literals over $Const$ , denoted by $G (Const)$ , are literals without variables, with all constants in $Const$ . If $ℓ = \neg R (\bar{τ})$ then $\neg ℓ \overset{def}{=} R (\bar{τ})$ . $⊲$

Though we use classical first-order syntax, the semantics substantially differs from the classical one as truth values $t, i, u, f$ (true, inconsistent, unknown, false) are explicitly present; the semantics is based on sets of ground literals rather than on relational structures. This allows one to deal with lack of information as well as inconsistencies. Because 4QL is based on the same principles, it can directly be used as implementation tool.

The semantics of propositional connectives is summarized in Table 2. Observe that definitions of ∧ and ∨ reflect minimum and maximum with respect to the ordering: $\begin{matrix} (1) & f < u < i < t, \end{matrix}$ as argued in [13,29,53].

Table 2
Truth tables for ∧, ∨, → and ¬ (see [29,31,53])

It is worth noting that whenever truth values are restricted to ${f, t}$ , the semantics we consider is compatible with the semantics of classical first-order logic.

Let $v : Var ⟶ Const$ be a valuation of variables. For a literal ℓ, by $ℓ (v)$ we understand the ground literal obtained from ℓ by substituting each variable x occurring in ℓ by constant $v (x)$ .
Definition 2.
The truth value $ℓ (L, v)$ of a literal ℓ w.r.t. a set of ground literals L and valuation v, is defined by: $\begin{matrix} ℓ (L, v) \overset{def}{=} \{\begin{matrix} t & if ℓ (v) \in L and (\neg ℓ (v)) \notin L; \\ i & if ℓ (v) \in L and (\neg ℓ (v)) \in L; \\ u & if ℓ (v) \notin L and (\neg ℓ (v)) \notin L; \\ f & if ℓ (v) \notin L and (\neg ℓ (v)) \in L . ⊲ \end{matrix} \end{matrix}$

For a formula $α (x)$ with a free variable x and $c \in Const$ , by $α {(x)}_{c}^{x}$ we understand the formula obtained from α by substituting all free occurrences of x by c. Definition 2 is extended to all formulas in Table 3, where α denotes a first-order formula, v is a valuation of variables, L is a set of ground literals, and the semantics of propositional connectives appearing at righthand sides of equivalences is given in Table 2.

Table 3
Semantics of first-order formulas

Belief structures can now be defined as in [23]. If S is a set, then $F IN (S)$ represents the set of all finite subsets of S.
Definition 3.
Let $C \overset{def}{=} F IN (G (Const))$ be the set of all finite sets of ground literals over constants in Const. Then:
a constituent is any set $C \in C$ ;

an epistemic profile is any function $E : F IN (C) ⟶ C$ ;

by a belief structure over epistemic profile $E$ is meant a structure $B^{E} = ⟨C, F⟩$ ; here $C \subseteq C$ is a nonempty set of constituents and $F \overset{def}{=} E (C)$ is the consequent of $B^{E}$ . $⊲$

Final beliefs are represented as consequents.

Notice, that the epistemic profile, being any function, can encode any reasoning schema (especially when we disregard complexity issues). In this paper we extend agent’s repertoire to include user-defined argumentation schemes, that employ incomplete and uncertain information. In the sequel, we will show the theoretical foundations, and then the implementation in 4QL.
4. Argumentation schemes as parts of epistemic profiles

Until now, the epistemic profiles, being arbitrary functions, conveyed all reasoning capabilities of agents (and groups of agents) [23], including their communicative strategies [21]. Here we distinguish yet another component, namely, argumentation schemes that extend an agent’s (or a group’s) epistemic profile.

4.1. Paraconsistent argumentation schemes: Intuition

Argumentation schemes are modeled with the use of the sets of premisses and exceptions, the latter one replacing the concept of critical questions (see Section 6 for the alternative formalization using the well-supported models of 4QL modules). In our approach, the conclusion of the paraconsistent argumentation scheme can be: $true$ , $false$ , $inconsistent$ or $unknown$ . We assume that a scheme has been applied when it leads to $true$ , $false$ or $inconsistent$ conclusions. Otherwise (when the conclusion’s value is $unknown$ ) the scheme was not applicable. This happens in two cases:

when the premisses are lacking, or

when the exceptions are present.

If the conclusion may be drawn, then its value is logically equivalent to conclusion resulting from the premisses.

Let us give some intuitions first, before defining the paraconsistent argumentation scheme. Since we admit premisses, exceptions and conclusions to take any of the four logical values, what happens when inconsistent and missing information regards the premisses of the argumentation scheme? To this end, recall the argument from Expert Opinion (see Table 1). When the premise “a is an expert in domain D” is:

$unknown$ or $false$ , it cannot serve to draw conclusions,

$true$ or $inconsistent$ , it can be used. In the worst scenario, the overall outcome will become inconsistent.

Thus, attacking an argument on premisses can be achieved by:

proving one of them is $false$ or $unknown$ (rebutting),

proving their inconsistency (undercutting).

Next, let’s consider the set of exceptions. It contains all the exceptions potentially applicable in the scheme. Whenever any of them becomes true, the schema is blocked and cannot be applied. For example, consider the exception regarding the expert’s reliability:

if the expert is not reliable ( $\neg isReliable$ is $true$ ), the Expert Opinion scheme cannot be applied,

otherwise, the exception is not triggered.

Therefore, as regards exceptions, their attacking power matters only when they are

true

4.2. Paraconsistent argumentation schemes: Definition

In our framework for paraconsistent argumentation schemes we deal with the three sets of ground literals: Premisses (P), Exceptions (E) and Conclusions ( $Con$ ), and a function $PAS ({P, E}) = Con$ , which represents the paraconsistent argumentation scheme.

The high-level structure of our running example is presented in Fig. 1. The ovals correspond to the sets of ground literals, arranged into above-mentioned sets of Conclusions, Premisses and Exceptions, as well as: Expert, Ontology, Evidence, Assertions and Reliability, which are specific for a particular scheme (here the Expert Opinion utilizes the set of Assertions for constructing both the Premisses and Exceptions). The arrows (from Premisses and Exceptions to Scheme) represent the function of the paraconsistent argumentation scheme ( $PAS$ ).

Fig. 1.

Modular architecture of Expert Opinion Scheme.

The elements of the Conclusions set (literals) are conclusions of the argumentation scheme as expressed by the function $PAS$ . In case of single-threaded reasoning (reasoning about one subject at a time), the Conclusions set is a singleton. In case of a multi-threaded reasoning (reasoning about many subjects simultaneously), the set of Conclusions can be larger, with one literal corresponding to one conclusion on the subject.

The set of Premisses contains candidates for conclusion of the scheme. They are obtained by means specific to every argumentation scheme.

The elements of the set of Exceptions are triggers that, when present, forbid the respective candidate conclusion from being drawn. Intuitively, a conclusion c cannot be obtained when the exceptions indicate $\neg c$ .

Ultimately, the conclusion of the scheme is obtained in the following way. If there exists a tetravalent candidate for a conclusion $c \in Premisses$ (value of c is not $unknown$ ), check whether there exists a trigger blocking this candidate: $\neg c \in Exceptions$ (value of $\neg c$ is $true$ ).

If there is no such a trigger, the candidate conclusion becomes the ultimate conclusion of the scheme.

Otherwise, the scheme cannot be applied causing that the value of $c \in Conclusions$ is $unknown$ .

To sum up (adopting the notation from Definition 4), a conclusion c is established based on the supporting arguments given by the set of Premisses (i.e. $c (P, v) = t$ ) and (lack of) rebutting triggers provided by the set of Exceptions (i.e. $\neg c (E, v) \neq t$ ).

Definition 4.

Recall that

$C = F IN (G (Const))$ stands for the set of all finite sets of ground literals over the finite set of constants Const,

$v : Var ⟶ Const$ is a valuation of variables.

by a constituent we understand any set $C \in C$ .

Let:

P and E be two constituents, representing the set of premisses and exceptions, respectively,

$S = {P, E}$ be a nonempty set of constituents ( $S \subseteq C$ ),

$Con \in C$ be a finite set of ground literals, representing the conclusions.

Then, paraconsistent argumentation scheme is a partial function

PAS : F IN (C) ⟶ C

PAS ({P, E}) = Con

, such that:

\begin{matrix} c (Con, v) \overset{def}{=} \{\begin{matrix} t & iff c (P, v) = t and \neg c (E, v) \neq t; \\ i & iff c (P, v) = i and \neg c (E, v) \neq t; \\ u & iff c (P, v) = u or \neg c (E, v) = t; \\ f & iff c (P, v) = f and \neg c (E, v) \neq t . \end{matrix} \end{matrix}

By belief structure over

PAS

we mean

B^{PAS} = ⟨S, Con⟩

, where:

$S = {P, E}, S \subseteq C$ is a nonempty set of constituents;

$Con \overset{def}{=} PAS (S)$ is the consequent of $B^{PAS}$ .

We identify the belief structure over

PAS

with the instance of a paraconsistent argumentation scheme.

⊲

The above definition presents the paraconsistent argumentation scheme as a partial function: a fragment of agent’s epistemic profile that expresses agent’s argumentative skills. The implementation of PAS in 4QL is presented in Definition 7, where also the analogy between both definitions is explained.

5. 4QL: An implementation tool

The rule language 4QL has been introduced in [29] and further developed in [31,46]. In 4QL, beliefs are distributed among modules. The 4QL language allows for negation in premisses and conclusions of rules. In particular, negation in rule heads may lead to inconsistencies. 4QL is based on the four-valued logic described in Section 3. The semantics of 4QL is defined by well-supported models [29–31,46], i.e., models consisting of (positive or negative) ground literals, where each literal is a conclusion of a derivation starting from facts. For any set of rules, such a model is uniquely determined:

“Each module can be treated as a finite set of literals and this set can be computed in deterministic polynomial time” [29,31].

Thanks to this correspondence and the fact that 4QL captures PTime, the constituents and consequents of Definition 3, can be directly implemented as 4QL modules [24].

Typically, in multi-agent architectures, 4QL would be situated in the layer that processes qualitative information, as opposed to the lower-level quantitative information processing layer, for which various techniques, including fuzzy, rough set and probabilistic approaches, can be used (e.g., for image, voice and other sensor data processing).

For specifying rules and querying modules, we adapt the language of [46]. To this end we need the notion of multisource formulas defined as follows.

Definition 5.
A multisource formula is an expression of the form: $m . A$ or $m . A \in T$ , where:
m is a module name;

A is a first-order or a multisource formula;

$T \subseteq {t, i, u, f}$ .
We write $m . A = v$ (respectively, $m . A \neq v$ ) to stand for $m . A \in {v}$ (respectively, $m . A \notin {v}$ ). $⊲$

The intuitive meaning of a multisource formula $m . A$ is:
“return the answer to query expressed by formula A, computed within the context of module m”.
The value of ‘ $m . A \in T$ ’ is: $\begin{matrix} \{\begin{matrix} t & when the truth value of A in m is in the set T; \\ f & otherwise . \end{matrix} \end{matrix}$ Let $A (X_{1}, \dots, X_{k})$ be a multisource formula with $X_{1}, \dots, X_{k}$ being its all free variables and D be a finite set of literals (a belief base). Then A, understood as a query, returns tuples $⟨d_{1}, \dots, d_{k}, t v⟩$ , where $d_{1}, \dots, d_{k}$ are database domain elements and the value of $A (d_{1}, \dots, d_{k})$ in D is $t v$ .
Definition 6.

Rules are expressions of the form: $\begin{matrix} (2) & conclusion :– premisses . \end{matrix}$ where conclusion is a positive or negative literal and premisses are expressed by a multisource formula.

A fact is a rule with empty premisses (such premisses are evaluated to $t$ ).

A module is a syntactic entity encapsulating a finite number of facts and rules.

A 4QL program is a set of modules, where it is assumed that there are no cyclic references to modules involving multisource formulas of the form $m . A \in T$ . $⊲$

Openness of the world is assumed, but rules can be used to close it locally or globally.

Fig. 2.
Example of a 4QL program.

Let us illustrate 4QL, consider Fig. 2, where we use syntax of the 4QL interpreter inter4QL.2
²
The interpreter, developed by P. Spanily and revised by Ł. Białek, can be downloaded from http://www.4ql.org/.

The program shown in Fig. 2 consists of two modules: r and $perceived$ . The program uniquely determines the following well-supported model for module perceived: $\begin{matrix} (3) & {is (fire), \neg is (heat)} \end{matrix}$ and the following well-supported model for module r: $\begin{matrix} (4) & {is (heat), \neg is (heat), is (fire), do (extinguish)} . \end{matrix}$

From the epistemic profile perspective, the two modules: r and $perceived$ define sets of ground literals (3) and (4) and can be seen as a belief structure with one constituent $perceived$ and a consequent r. The epistemic profile is defined by rules of module r. As well-supported models are sets of ground literals (with deterministic polynomial time data complexity), we alternate between the notions of the set of consequents and well-supported models (as mentioned in Sections 3 and 6).
6. Paraconsistent argumentation schemes in 4QL

Each argumentation scheme is a standalone entity, with a dedicated 4QL module, containing two specific rules:

is(X):- Premisses.is(X), -Exceptions.is(X) in {false,unknown,incons}.

and

-is(X):- -Premisses.is(X), -Exceptions.is(X) in {false,unknown,incons}.

The multisource formulas in the bodies of the rules pertain to two other specific sub-modules: one corresponding to the premisses and one to the exceptions. Intuitively, these rules express the mechanism of drawing the scheme conclusions using the premisses and exceptions in the way described in Section 4. Altogether, the 3-modular 4QL architecture reflects the structure of the argumentation scheme:

the set of $premisses$ is translated to the module SN_ Premisses,

the set of $exceptions$ is captured in the module SN_ Exceptions,

the $conclusion$ (is(X)) is evaluated in the SN (scheme name) module.

Fig. 3.

General 4ql Template for Argumentation Schemes.

These three modules constitute the standard approach to argumentation schemes in 4QL. They are captured in a generic template of a 4QL program consisting of the three modules: SN, SN_ Exceptions and SN_Premisses (see Fig. 3). Evaluation of an instance of an argumentation scheme amounts to computing the well-supported model for the module SN, implementing this scheme (see e.g., Fig. 4 for an implementation of the Expert Opinion scheme).

Fig. 4.

Argumentation Scheme from Expert Opinion.

The two rules encoded in module SN allow for drawing true, false or inconsistent conclusions. Recall that a conclusion c can be obtained when the exceptions do not conclusively indicate $\neg c$ . Again, let’s first investigate, when the scheme cannot be applied?

The conclusion cannot be drawn due to the exceptions. This situation is encoded using the literal -SN_ Exceptions.is(X) in both rules.

When it is $true$ , both rules in the SN module cannot be executed (as the rule premisses evaluate to $false$ , see Table 2).

The conclusion cannot be drawn due to the lack of premisses. Consider valuations of the first literal: (-)SN_Premisses.is(X).

The only situation where both rules cannot be executed due to it, is when the value of (-)SN_Premisses.is(X) is unknown.

Indeed, otherwise:

if it’s true, the first rule would be executed,

if it’s false, the second rule would be executed,

if it’s inconsistent, both rules would be executed.

Consider a situation, where there are both exceptions from the argumentation scheme and also not all premisses are present. This would correspond to the following case for both rules:

the first literal is $unknown$ ,

the second literal is $true$ .

Then, the conjunction would evaluate to

unknown

(see Table 2) and none of the rules applies.

If there are no exceptions prohibiting the scheme from being applied, the conclusion is(X) in the SN module evaluates to the same value as is(X) in the SN_Premisses module (as explained in Section 4).

As mentioned before, the burden of proving the premisses lies on the proponent. The opponent can fight a successful argument is two ways. Either by rebutting it (by proving the conclusion is unknown) or by undercutting it (by proving the conclusion is inconsistent). The first goal can be achieved in two ways:

by showing that in the SN_Premisses module at least one of the premisses is false or unknown, or

by showing that -SN_Exceptions.is(X) is true, i.e., at least one of the exceptions is true.

To undercut a successful argument the opponent may attack the true premisses by proving their inconsistency.

In what follows we present the definition of a paraconsistent argumentation scheme, which is, in fact, an implementation of Definition 4 in 4QL. The analogy between both definitions is founded on the following observations:

the functions are represented as the sets of rules (4QL modules),

the sets of ground literals correspond to well-supported models (see Section 5).

Definition 7.

Recall that L stands for the set of ground literals with constants in Const. Let $Exceptions$ , Premisses and $Scheme$ be three sets of rules. A Paraconsistent Argumentation Scheme is a tuple $PAS = ⟨ Exceptions, Premisses, Scheme ⟩$ , such that if:

$M_{S}$ is a well supported model of Scheme,

$M_{P}$ is a well supported model of Premisses,

$M_{E}$ is a well supported model of Exceptions,

then

\exists c \in L

, such that

\begin{matrix} M_{S} (c) \overset{def}{=} \{\begin{matrix} t & iff M_{P} (c) = t and M_{E} (\neg c) \neq t; \\ i & iff M_{P} (c) = i and M_{E} (\neg c) \neq t; \\ u & iff M_{P} (c) = u or M_{E} (\neg c) = t; \\ f & iff M_{P} (c) = f and M_{E} (\neg c) \neq t . \end{matrix} \end{matrix}

Is such case we define c as the conclusion of the paraconsistent argumentation scheme.

⊲

Fig. 5.

Modular architecture of Expert Opinion Scheme.

The above definition presents PAS as a tuple of specific 4QL modules (sets of rules). Figure 5 illustrates it with the rectangles depicting the 4QL modules, as in the Figs 4, 7 and 6. On the other hand, Definition 4 expresses PAS as a partial function: a fragment of agent’s epistemic profile. Here, the $PAS$ function (see Definition 4) is represented by the $Scheme$ module (Scheme rectangle in the Fig. 5). The set of conclusions of the scheme ( $Con$ ) corresponds to the well-supported model of the $Scheme$ module ( $M_{S}$ ). In general, the ovals in Fig. 1 correspond to the well-supported models of the modules depicted by the rectangles in the Fig. 5.

Any argumentation scheme that can be represented as PAS can be implemented in 4QL. Obtaining conclusion c of the scheme is in polynomial time, as it amounts to computing the well-supported model of the module $Scheme$ . This complexity result allows to reason and compare conclusions obtained with the use of multiple different argumentation schemes at once.

6.1. Example: Argument from Expert Opinion

As a showcase for our solution, consider the Argument from Expert Opinion. The modules implementing the scheme (eo, eoExceptions, eoPremisses) and the agent (agent) are shown in Fig. 4. Module agent, represents the reasoning capabilities of the $agent$ . $Agent$ ’s epistemic profile is composed of two rules: $\begin{matrix} \begin{matrix} is(X) :- eo.is(X,A) . \\ -is(X) :- -eo.is(X,A) . \end{matrix} \end{matrix}$ It utilizes the Expert Opinion scheme to adjudicate about the final conclusion $is (X)$ on the matter X. In this simple strategy of dealing with inconsistencies, the $agent$ acknowledges all opinions of experts A regarding X, that were admitted by the Expert Opinion module. This way the object, meta- and meta-meta levels (see Section 2) are separated. For a more restrictive strategy for dealing with inconsistency, a different solution can be applied.

The implementation of the Expert Opinion scheme deals with two explicit exceptions (as argued in Section 2):

evidence-based claim: -evidence.claim(A,X) and

reliability: -reliability.isReliable(A).

Fig. 6.

Modules for Exceptions.

The sub-modules implementing particular exceptions are presented in Fig. 6. The reliability and evidence modules include the starting sets of facts, stating that:

$bob$ is not trusted: isTrusted(bob) and

evidently, it rained: sensorsLog(bob,rain).

The sub-modules (expert, ontology, assertions) implementing particular premisses are presented in Fig. 7. Here, and for the remaining schemes we equip the modules with some basic facts that can be treated as test cases for a given argumentation scheme.

Module expert decides that an expert in field F is an agent that does a job J which is related to that field, e.g., a meteorologist is an expert in weather. The assertions module translates the messages perceived from agents (A) about their opinions (values $t$ , $f$ , $i$ ) on various subjects (X) into assertions in 4QL. The starting sets of facts include the information about agents meteorologists: $bob$ , $ag1$ , $ag2$ , $ag3$ .

This example allows us to test various scenarios of missing and inconsistent information appearing in the Expert Opinion scheme. If we load the program to the interpreter and ask: agent.is(X), we would get information that there are no known facts (the well-supported model of the agent module is empty). Indeed, there are no perceived messages in the module assertions to start from. Now, if we add the following facts to the module assertions:

perceived(bob,rain,true),

perceived(ag1,rain,true),

perceived(ag2,rain,false),

and reload the module, the same question would yield the following results: agent.is(rain):inconsistent.

Fig. 7.

Modules for Premisses.

If we intend to learn which experts’ opinions were essential to that verdict, we should ask: eo.is(X,Y). This query leads to the generation of the well-supported model of the eo module. It contains the following facts: ${eo . is (rain, ag1), - eo . is (rain, ag2)}$ . Clearly, $bob$ ’s opinion didn’t count (as absent from the model). On the other hand, both $ag1$ ’s and $ag2$ ’s opinions were admitted. Indeed, the only triggered exception, was the one concerning $bob$ (the well-supported model of the eoExceptions module contains only ${- is (rain, bob)}$ ). Although $bob$ ’s claim was based on evidence ( $evidence . claim (bob, rain) = t$ ) he was not reliable ( $reliability . isReliable (bob) = f$ ).

Now, what should happen, if in the reliability module’s fact: -isTrusted(bob) we replace $bob$ with $ag2$ ? Clearly, the two experts whose testimony is admitted by the Expert Opinion scheme are now: $ag1$ and $bob : eo . is (rain, bob) = t \land eo . is (rain, ag1) = t$ . The overall conclusion becomes: $agent . is (rain) = t$ .

6.2. Example: Argument from Perception

Consider the following argumentation scheme, which allows agents to reason about percepts. The classical scheme has two premisses and one critical question (see Table 4). Since the second premise expresses the link between the first premise and the conclusion, it is redundant. The critical question works as an undercutter for that link and as such remains in our framework. The Argument from Perception scheme, viewed solely as an argumentation or reasoning pattern, is quite simple. All the difficulty connected with assessing the reliability of perception is extracted to the relation isPerceptionReliable(). In practical applications, this relation would be implemented with use of a dedicated module responsible for adjudicating about the reliability of perception. In our example, the final conclusion about $is (rain)$ will be that of $alice$ , since $bob$ ’s perception is not reliable.

Table 4
Perception: from Original to Paraconsistent

Original Argumentation Scheme as in [ 56 ]

Scheme a has a φ image (an image of a perceptible property)

To have a φ image (an image of a perceptible property) is a prima facie reason to believe that the circumstances exemplify φ

It is reasonable to believe that φ is the case

* Are the circumstances such that having a φ image is not a reliable indicator of φ?

Adapted to Communicative Settings

Scheme a has a φ percept

φ is the case

** The circumstances are such that having a φ percept is a reliable indicator of φ

Paraconsistent Argumentation Scheme

Scheme percept(Agent, X)

is(X)

** isPerceptionReliable(Agent, X)

	Original Argumentation Scheme as in [ 56 ]
Scheme	a has a φ image (an image of a perceptible property)
To have a φ image (an image of a perceptible property) is a prima facie reason to believe that the circumstances exemplify φ

It is reasonable to believe that φ is the case
*	Are the circumstances such that having a φ image is not a reliable indicator of φ?
	Adapted to Communicative Settings
Scheme	a has a φ percept

φ is the case
**	The circumstances are such that having a φ percept is a reliable indicator of φ
	Paraconsistent Argumentation Scheme
Scheme	percept(Agent, X)

is(X)
**	isPerceptionReliable(Agent, X)

– Critical Questions

^**

– Assumptions

Fig. 8.

Perception Argumentation Scheme in 4QL.

6.3. Example: Argument from Position to Know

Let’s consider another example of an argumentation scheme: argument from Position to Know. The original form of this scheme is presented in Table 5. It consist of just two premisses and three critical questions. Notice that two critical questions are redundant. After eliminating them, the only relevant critical question that remains concerns the reliability of the source. In our framework it is expressed as an assumption “a is a reliable source” implemented using relation isReliable() in pkExceptions module in Fig. 9.

Table 5
Position to Know: from Original to Paraconsistent

Original Argumentation Scheme as in [ 56 ]

Scheme a is in the position to know whether A is true

a asserts that A is true

A is true

* Is a in the position to know whether A is true?

Is a a honest (trustworthy, reliable) source?

Did a assert that A is true?

Adapted to Communicative Settings

Scheme a is in the position to know whether A is true

a asserts that A is true

A is true

** a is a reliable source

Paraconsistent Argumentation Scheme

Scheme posKnow(Agent, X)

assert(Agent, X, Value)

is(X)

** isReliable(Agent)

	Original Argumentation Scheme as in [ 56 ]
Scheme	a is in the position to know whether A is true
a asserts that A is true

A is true
*	Is a in the position to know whether A is true?
Is a a honest (trustworthy, reliable) source?
Did a assert that A is true?
	Adapted to Communicative Settings
Scheme	a is in the position to know whether A is true
a asserts that A is true

A is true
**	a is a reliable source
	Paraconsistent Argumentation Scheme
Scheme	posKnow(Agent, X)
assert(Agent, X, Value)

is(X)
**	isReliable(Agent)

– Critical Questions

^**

– Assumptions

For simplicity, instead of expanding the relation isReliable(), in this example we provide the relevant information as a fact (the information that $bob$ is not reliable encodes -isReliable(bob)). However, notice that it could have been given differently, e.g., with use of the following rule: $\begin{matrix} \begin{matrix} isReliable(A):- reliability.high(A) . \end{matrix} \end{matrix}$ Such approach would be suitable to reflect that the information about reliability is obtained via an advanced argumentation or reasoning process encapsulated in module reliability, rather than by a simple hard-coded fact. By adding a relevant rule with an external literal referring a sub-module responsible for, in this case, reasoning about reliability, we can embed various argumentation schemes. We show an example of such embedding for the Argument from Ethos (see Section 7).

Recall, that the original form of the Position to Know scheme does not contain facts. Here, and for the remaining schemes, we equip the modules with some basic facts so that the programs shown in figures can be executed with use of 4QL interpreter. In this example, $is (fire)$ is absent (unknown) from the well-supported model of module tom. Although all the premises are in place, the source of the information ( $bob$ ) is not reliable. Therefore, the conclusion could not be drawn due to the exceptions: $- pkExceptions . is (fire)$ is $true$ .

Fig. 9.

Position to Know Argumentation Scheme in 4QL.

Fig. 10.

Ethos Argumentation Scheme in 4QL.

6.4. Example: Ethotic Argument

The Argument from Ethos is commonly used to adjudicate about truth or falsity of a proposition on the grounds of the qualities of the information source. The original form of the scheme is given in Table 6. The two non-redundant critical questions are: the one about relevancy of the character qualities and the one about the claim being evidence-based.

In the example in Fig. 10, the main premise (goodQualities of an agent) is given with the use of simple facts (see module ePremisses). The two implemented critical questions are: the one about (ir)relevancy of the qualities of character and the one about the statement being evidence-based. With use of this argumentation scheme as an example, we intend to shed more light on the way scheme embedding is done in 4QL. In Section 7 we show how other argumentation schemes can be embedded into this one, to draw conclusions about the goodQualities of an agent in a more sophisticated way.

Table 6
Ethos: from Original to Paraconsistent

Original Argumentation Scheme as in [ 56 ]

Scheme If a is a person of good (bad) moral character, then what a says should be accepted as more plausible (rejected as less plausible)

a is a person of good (bad) moral character

What a says should be accepted as more plausible (rejected as less plausible)

* Is a a person of good (bad) moral character?

Is character relevant in the dialogue?

Is the weight of presumption claimed strongly enough warranted by the evidence given?

Adapted to Communicative Settings

Scheme a is an agent of good combination of qualities

a asserts that A is the case

A is the case

** Agent’s qualities are relevant in the dialogue

The weight of A is strongly enough warranted by the evidence given

Paraconsistent Argumentation Scheme

Scheme goodQualities(Agent)

assert(Agent, X, Value)

is(X)

** qualititesRelevant(X)

evidenceBased(Agent, X, Value)

	Original Argumentation Scheme as in [ 56 ]
Scheme	If a is a person of good (bad) moral character, then what a says should be accepted as more plausible (rejected as less plausible)
a is a person of good (bad) moral character

What a says should be accepted as more plausible (rejected as less plausible)
*	Is a a person of good (bad) moral character?
Is character relevant in the dialogue?
Is the weight of presumption claimed strongly enough warranted by the evidence given?
	Adapted to Communicative Settings
Scheme	a is an agent of good combination of qualities
a asserts that A is the case

A is the case
**	Agent’s qualities are relevant in the dialogue
The weight of A is strongly enough warranted by the evidence given
	Paraconsistent Argumentation Scheme
Scheme	goodQualities(Agent)
assert(Agent, X, Value)

is(X)
**	qualititesRelevant(X)
evidenceBased(Agent, X, Value)

– Critical Questions

^**

– Assumptions

Fig. 11.

Communicative Relations and Reasoning about Trust.

7. Embedding argumentation schemes

Let’s recall the original Ethotic Argument and our paraconsistent version of it (Table 6). As we do not intend to over-antropomorphize our artificial agents, the classical notion of good (bad) moral character should be treated in a way that is more relevant to MAS. One approach can be to focus on qualities such as: veracity, prudence, perception and cognitive skills as proposed in [54]. However, in [54], the problem whether agent’s statements should be considered or disregarded was adjudicated with use of a higher-level concept: the credibility of an agent, which was expressed with the use of the credibility function. The character traits recalled above play a role in judging agent’s credibility and therefore plausibility of his arguments. In addition, “when one of these traits is a relevant basis for an adjustment in a credibility function, there is a shift to a subdialogue in which the argumentation in the case is re-evaluated” [54].

A slightly different approach to the same problem is presented in [36], where the role of credibility, plays trust, which is considered to be “a mechanism for managing the uncertainty about autonomous entities and the information they deal with”. Furthermore “trust should be reason-based, which suggests argumentation as a mechanism for constructing arguments (reasons) for and against adopting beliefs and pursuing actions, and explicitly recording the agents that need to be trusted.”

Finally, in [21], yet another solution to the same problem has been proposed, with the use of communicative relations, which comprise various aspects of communication and “can be viewed as selective lens, through which we can see only these parts of the relations involved, which affect communication”.

The common part of these approaches is the need for assessing plausibility of arguments put forward by agents. In this paper we lean towards the solution that uses the notion of communicative relation, which covers a wide range of relations or concepts that could be relevant for assessing the plausibility of agent’s arguments from the ethotic standpoint.

Figure 11 represents an example of a 4QL module (communicationX) of some application, that encodes the communicative relations (for brevity we write cr for “communicative relation”) for some agent X. By cr(A,high) we mean that agent X has a high communicative relation with agent A. There are three levels of communicative relations required in the application: high, medium and low. Further, the example presents also a module that encodes one of the components of the communicative relation: trust (module trust). As we can see, the agent adjudicates about trust using two argumentation schemes: reputation (module rep) and prudence (module pru).

One advantage of this approach is an easy fine-tuning of applications. It is fairly straightforward to change the communicationX module presented in Fig. 11 such that for different applications, particular concepts (trust, power, veracity, etc.) are taken into consideration with different weights.3

³
Then, through simulations, one could obtain an optimal division of weights for which the system achieves its goal in the best way, e.g., the fastest.

In addition, if the application developers want to add yet another factor that should influence communicative relations between the agents, they need to implement a relevant submodule (like the module trust) and update the body of the rule that computes the level for the communicative relation (in the module communicationX).

Table 7

Selected Argumentation Schemes for Reasoning about Trust

		Original Scheme	Adapted	Paraconsistent
Reputation	Scheme	If B has a reputation for being trustworthy, then A may choose to trust B	B has a reputation for being trustworthy	reputation(Agent,Value) & math.gt(Value,50)

		trust B	trust B	trust(Agent)

	Critical Questions (Assumptions)	Does B have a good reputation?Are we sure that B’s reputation has not been manipulated to make it more positive?	B’s reputation has not been manipulated	¬manipulated(Value)
		Original Scheme	Adapted	Paraconsistent
Prudence	Scheme	A may decide to trust B because it is less risky than not trusting B	Trusting B is less risky than not trusting B	riskOfTrust(Agent,Val1) & riskOfDistrust(Agent,Val2) & math.lt(Val1,Val2)

		trust B	trust B	trust(Agent)

	Critical Questions (Assumptions)	Is it riskier to not trust B than it is to trust B?Is it possible to accurately estimate the risk in trusting and not trusting B?Is there another individual we could trust where the risk would be lower than trusting B?	The risk in trusting and not trusting B was accurately estimatedThere is no other individual we could trust where the risk would be lower than trusting B	accurate(Val1) & accurate(Val2)-other(X,Agent) & riskOfTrust(Agent,Val1) & riskOfTrust(X,Val2) & math.lt(Val2,Val1)

Fig. 12.

Argumentation Scheme for Reasoning about Trust from Reputation.

7.1. Reputation and prudence argumentation schemes

As argued above, the factors which may influence the communicative relation are diverse. Here we intend to present how the trust component can be realized in the paraconsistent setting and embedded in the Ethotic Argumentation scheme. For this purpose, we utilize two argumentation schemes for reasoning about trust, as proposed in [36]: Reputation and Prudence.

Fig. 13.

Argumentation Scheme for Reasoning about Trust from Prudence.

Table 7 summarizes both schemes, giving their original form in the first column, the adapted version with reduced critical questions in the second column, and the paraconsistent version in the third column.

Next, the 4QL modules that encode these schemes are presented in Figs 12 and 13 respectively (notice we omit the standard top-level module rep and pru and present only the modules responsible for computing premisses and exceptions).

Let’s consider the Reputation scheme first. The only critical question that is not redundant is the one regarding the manipulation of reputation score. We make it explicit in the repExceptions module. In case of the Prudence scheme, we need to assess the accuracy of both risk estimations, as well as the assumption that there is no other agent for which the risk of trust is lower. This all is done in the pruExceptions module (see Fig. 13).

7.2. Embedding reputation and prudence in argument from ethos

Now that we have shown the paraconsistent implementation of the Reputation and Prudence Argumentation Schemes for reasoning about trust, let’s look at their embedding in the Argument from Ethos. The embedding of the schemes is realized in the following way. Instead of (or in addition to) drawing conclusions about agent’s qualities from the facts base only, we equip the module e (see Section 6.1), conveying the Ethotic Argument scheme, with the ability to draw conclusion based on yet another argumentation scheme. This can be done by adding a new rule:

goodQualities(X):-communicationX.cr(X,high)

to the module ePremises and removing (or not if we intend to keep this information) all the facts goodQualities(X). In this way, we combine the Ethotic Argument scheme with the whole set of schemes for reasoning about communicative relations (encoded in the communicationX module, see Fig. 11), in particular, for reasoning about trust with the use of the Reputation and Prudence schemes.

8. Discussion and conclusions

The contribution of this paper is a computationally-friendly framework for paraconsistent argumentation schemes, extending agent’s reasoning capabilities. The tetravalent model of argumentation schemes can be used in information-rich environments, naturally obeying incomplete or uncertain information. To this end, we provided templates for implementing an arbitrary argumentation scheme in 4QL, like Position to Know, Ethos, Perception or Expert Opinion [56]. Further, we showed a way of embedding argumentation schemes, on the example of Argument from Reputation and Argument from Prudence to reason about trust. Our solution is both expressive (as 4QL captures all tractable queries) and feasible (as 4QL enjoys polynomial computational complexity of computing queries). Such a choice allows for:

an efficient belief revision upon filling the gaps in knowledge (see also [5]), using light-weight forms of nonmonotonic reasoning [22]),

exploring different disambiguation strategies for dealing with inconsistencies [24]. This aspect will be investigated in detail in the upcoming paper.

Such features distinguish 4QL from other formalisms, e.g., Answer Set Programming (ASP) [25]. ASP is based on the trivalent semantics ( $true$ , $false$ , $unknown$ ), and does not admit inconsistency. Computing a so-called “answer set” (stable model) is NP-complete. The answer sets may contain conclusions that are not grounded in facts, which may be suitable for ASP primary applications (specification and computation of problems from the NP class), however is not appropriate in our case.

Dealing with missing or ambiguous information in argumentation is not a new subject [6]. For example, in [8] the authors propose a formal bi-party inquiry dialogue system where DeLP is used to deal with ignorance and inconsistency. In [47], the authors proposed a logic of multiple-valued argumentation (LMA), in which agents can argue using multi-valued knowledge base in the extended annotated logic programming (EALP) (such an approach was next applied in [32]). However, unlike our approach, the solution was based on Belnap’s logic.

Footnotes

Acknowledgement

The authors would like to thank Professor Andrzej Szałas for his comments which greatly improved this paper.

References

[1]

P.G.C.

Alchourrón and

Makinson, On the logic of theory change: Partial meet functions for contraction and revision, Journal of Symbolic Logic 50 (1985), 510–530.

[2]

A.R.

Anderson,

N.D.

Belnap and

J.M.

Dunn, Entailment: The Logic of Relevance and Necessity, Vol. 2, Princeton University Press, 1992.

[3]

J.L.

Austin, How to Do Things with Words, 2nd edn, Clarendon Press, Oxford, 1975.

[4]

Belnap, A useful four-valued logic, in: Modern Uses of Many Valued Logic, Reidel, 1977, pp. 8–37.

[5]

Bertossi, Database Repairing and Consistent Query Answering, Synthesis Lectures on Data Management, Morgan & Claypool Publishers, 2011.

[6]

Besnard and

Hunter, Elements of Argumentation, Vol. 47, MIT Press, Cambridge, 2008.

[7]

W.C.J.-Y.

Beziau and

Gabbay, Handbook of Paraconsistency, College Publications, 2007.

[8]

Black and

Hunter, An inquiry dialogue system, Autonomous Agents and Multi-Agent Systems 19(2) (2009), 173–209.

[9]

H.A.

Blair and

V.S.

Subrahmanian, Paraconsistent logic programming, Theoretical Computer Science 68(2) (1989), 135–154.

10.

[10]

P.R.

Cohen and

H.J.

Levesque, Intention is choice with commitment, Artificial Intelligence 42(2–3) (1990), 213–261.

11.

[11]

N.C.A.

da Costa, On the theory of inconsistent formal systems, Notre Dame Journal of Formal Logic 15(4) (1974), 497–510, 10.

12.

[12]

C.V.

Damásio and

L.M.

Pereira, A survey of paraconsistent semantics for logic programs, in: Handbook of Defeasible Reasoning and Uncertainty Management Systems, Kluwer Academic Publishers, 1998, pp. 241–320.

13.

[13]

de Amo and

Pais, A paraconsistent logic approach for querying inconsistent databases, International Journal of Approximate Reasoning 46 (2007), 366–386.

14.

[14]

Dignum,

Dunin-Kȩplicz and

Verbrugge, Creating collective intention through dialogue, Logic Journal of the IGPL 9 (2001), 145–158.

15.

[15]

Dignum and

Greaves (eds), Issues in Agent Communication, LNCS, Vol. 1916, Springer, 2000.

16.

[16]

Dubois, On ignorance and contradiction considered as truth-values, Logic Journal of the IGPL 16(2) (2008), 195–216.

17.

[17]

Dunin-Kȩplicz and

Strachocka, Perceiving rules under incomplete and inconsistent information, in: Computational Logic in Multi-Agent Systems, LNCS, Vol. 8143, Springer, 2013, pp. 256–272.

18.

[18]

Dunin-Kȩplicz and

Strachocka, Computationally-friendly argumentation schemes, in: 2014 IEEE/WIC/ACM International Joint Conferences on Web Intelligence (WI) and Intelligent Agent Technologies (IAT), Vol. 3, August 2014, pp. 167–174.

19.

[19]

Dunin-Keplicz and

Strachocka, Paraconsistent multi-party persuasion in talklog, in: Proc. of the PRIMA 2015: Principles and Practice of Multi-Agent Systems – 18th International Conference, Bertinoro, Italy, October 26–30, 2015,

Chen,

Torroni,

Villata,

J.Y.

Hsu and

Omicini, eds, Lecture Notes in Computer Science, Vol. 9387, Springer, 2015, pp. 265–283.

20.

[20]

Dunin-Keplicz and

Strachocka, Tractable inquiry in information-rich environments, in: Proc. of the Twenty-Fourth International Joint Conference on Artificial Intelligence, IJCAI 2015, Buenos Aires, Argentina, July 25–31, 2015,

Yang and

Wooldridge, eds, AAAI Press, 2015, pp. 53–60.

21.

[21]

Dunin-Kȩplicz,

Strachocka,

Szałas and

Verbrugge, Paraconsistent semantics of speech acts, Neurocomputing 151 (2015), 943–952.

22.

[22]

Dunin-Kȩplicz and

Szałas, Distributed paraconsistent belief fusion, in: Intelligent Distributed Computing VI, Studies in Computational Intelligence, Vol. 446, Springer, 2013, pp. 59–69.

23.

[23]

Dunin-Kȩplicz and

Szałas, Taming complex beliefs, in: Transactions on Computational Collective Intelligence XI, LNCS, Vol. 8065, 2013, pp. 1–21.

24.

[24]

Dunin-Kȩplicz,

Szałas and

Verbrugge, Tractable reasoning about group beliefs, in: Engineering Multi-Agent Systems, LNCS, Vol. 8758, Springer International Publishing, 2014, pp. 328–350.

25.

[25]

Gelfond and

Kahl, Knowledge Representation, Reasoning, and the Design of Intelligent Agents – the Answer-Set Programming Approach, Cambridge University Press, 2014.

26.

[26]

M.P.

Georgeff,

Pell,

M.E.

Pollack,

Tambe and

Wooldridge, The belief-desire-intention model of agency, in: Proc. of the 5th International Workshop on Intelligent Agents V, Agent Theories, Architectures, and Languages, ATAL ’98, Springer-Verlag, London, UK, 1999, pp. 1–10.

27.

[27]

Jaśkowski, Propositional calculus for contradictory deductive systems, Studia Logica 24(1) (1969), 143–157.

28.

[28]

Kraus,

Lehmann and

Magidor, Nonmonotonic reasoning, preferential models and cumulative logics, Artificial Intelligence 44(1–2) (July 1990), 167–207.

29.

[29]

Małuszyński and

Szałas, Living with inconsistency and taming nonmonotonicity, in: Datalog Reloaded, LNCS, Vol. 6702, Springer-Verlag, 2011, pp. 384–398.

30.

[30]

Małuszyński and

Szałas, Logical foundations and complexity of 4QL, a query language with unrestricted negation, Journal of Applied Non-Classical Logics 21(2) (2011), 211–232.

31.

[31]

Małuszyński and

Szałas, Partiality and inconsistency in agents’ belief bases, in: KES-AMSTA, Frontiers in Artificial Intelligence and Applications, Vol. 252, IOS Press, 2013, pp. 3–17.

32.

[32]

Matsunaga and

Sawamura, Aaslma: An automated argument system based on logic of multiple-valued argumentation, in: Knowledge-Based Intelligent Information and Engineering Systems, LNCS, Vol. 3684, Springer, 2005, pp. 830–838.

33.

[33]

McCarthy, Circumscription – a form of non-monotonic reasoning, Artificial Intelligence 13(1–2) (1980), 27–39.

34.

[34]

Moore, Possible-world semantics for autoepistemic logic, in: Readings in Nonmonotonic Reasoning, Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 1987, pp. 137–142.

35.

[35]

Nute, Defeasible logic, in: Handbook of Logic in Artificial Intelligence and Logic Programming (Vol. 3), Oxford University Press, Inc., New York, NY, USA, 1994, pp. 353–395.

36.

[36]

Parsons,

Atkinson,

K.Z.

Haigh,

K.N.

Levitt,

McBurney,

Rowe,

M.P.

Singh and

Sklar, Argument schemes for reasoning about trust, in: COMMA,

Verheij,

Szeider and

Woltran, eds, Frontiers in Artificial Intelligence and Applications, Vol. 245, IOS Press, 2012, pp. 430–441.

37.

[37]

Prakken, On the nature of argument schemes, in: Dialectics, Dialogue and Argumentation. An Examination of Douglas Walton’s Theories of Reasoning, College Publications, 2010, pp. 167–185.

38.

[38]

Priest, The logic of paradox, Journal of Philosophical Logic 8(1) (1979), 219–241.

39.

[39]

Priest, Paraconsistent belief revision, Theoria 67(3) (2001), 214–228.

40.

[40]

Priest,

Tanaka and

Weber, Paraconsistent logic, in: The Stanford Encyclopedia of Philosophy, Spring 2015 edn, 2015.

41.

[41]

Reiter, A logic for default reasoning, in: Readings in Nonmonotonic Reasoning, Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 1987, pp. 68–93.

42.

[42]

Reiter, On closed world data bases, in: Readings in Nonmonotonic Reasoning, Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 1987, pp. 300–310.

43.

[43]

P.K.

Schotch and

R.E.

Jennings, Inference and necessity, Journal of Philosophical Logic 9(3) (1980), 327–340.

44.

[44]

Searle and

Vanderveken, Foundations of Illocutionary Logic, Cambridge University Press, Cambridge, 1985.

45.

[45]

M.P.

Singh, Agent communication languages: Rethinking the principles, Computer 31(12) (Dec. 1998), 40–47.

46.

[46]

Szałas, How an agent might think, Logic Journal of the IGPL 21(3) (2013), 515–535.

47.

[47]

Takahashi and

Sawamura, A logic of multiple-valued argumentation, in: Proc. of the 3rd International Joint Conference on Autonomous Agents and Multiagent Systems-Volume 2, IEEE Computer Society, 2004, pp. 800–807.

48.

[48]

Tanaka, The AGM theory and inconsistent belief change, Logique Et Analyse 48(189–192) (2005), 113–150.

49.

[49]

van Ditmarsch,

van der Hoek and

Kooi, Dynamic Epistemic Logic, 1st edn, Springer Publishing Company, Incorporated, 2007.

50.

[50]

van Harmelen,

Lifschitz and

B.W.

Porter (eds), Handbook of Knowledge Representation, Foundations of Artificial Intelligence, Vol. 3, Elsevier, 2008.

51.

[51]

van Linder,

van der Hoek and

J.-J.

Meyer, Actions that make you change your mind, in: KI-95: Advances in Artificial Intelligence,

Wachsmuth,

C.-R.

Rollinger and

Brauer, eds, Lecture Notes in Computer Science, Vol. 981, Springer, Berlin, Heidelberg, 1995, pp. 185–196.

52.

[52]

van Linder,

van der Hoek and

J.-C.

Meyer, Formalizing abilities and opportunities of agents, Fundamenta Informaticae 34(1–2) (1998), 53–101.

53.

[53]

Vitória,

Małuszyński and

Szałas, Modeling and reasoning with paraconsistent rough sets, Fundamenta Informaticae 97(4) (2009), 405–438.

54.

[54]

Walton, Ethotic arguments and fallacies: The credibility function in multi-agent dialogue systems, Pragmatics and Cognition 7(1) (1999), 177–203.

55.

[55]

Walton and

Krabbe, Commitment in Dialogue: Basic Concepts of Interpersonal Reasoning, State University of New York Press, Albany (NY), 1995.

56.

[56]

Walton,

Reed and

Macagno, Argumentation Schemes, Cambridge University Press, 2008.

Paraconsistent argumentation schemes 1

Abstract

Keywords

1. Modeling assumptions

1.1. Paraconsistency in multi-agent settings

1.3. Looking for tractability

2. Computational perspective on paraconsistent argumentation schemes

4.1. Paraconsistent argumentation schemes: Intuition

4.2. Paraconsistent argumentation schemes: Definition

3 Then, through simulations, one could obtain an optimal division of weights for which the system achieves its goal in the best way, e.g., the fastest.

8. Discussion and conclusions

Footnotes

Acknowledgement

References

³
Then, through simulations, one could obtain an optimal division of weights for which the system achieves its goal in the best way, e.g., the fastest.