Towards deriving conclusions from cause-effect relations Jorge Fandinno Department of Computer Science University of Corunna, Spain [email protected]

Abstract. In this work we propose an extension of logic programming, under the stable model semantics, and the action language BC where rule bodies and causal laws may contain a new kind of causal literal that allows us to inspect the causal justifications of standard atoms. To this aim, we rely on a recently proposed semantics where each atom belonging to a stable model is associated with a justification in the form of an algebraic expression (which corresponds to a logical proof built with rule labels). In particular, we use causal literals for evaluating and deriving new conclusions from statements like “A has been sufficient to cause B.” We also use the proposed semantics to extend the action language BC with causal literals and, by a running example, show how this action language is useful for representing some typical Knowledge Representation examples involving causal knowledge.

1

Introduction

Causality is a concept widely studied in Philosophy and Artificial Intelligence (AI), and a central aim of the special sciences. Work in Philosophy and in AI that follows Pearl [1] has been mostly focused on defining what cause means and deriving statements of the form “A has caused B.” In its turn, work in the area of Reasoning about Actions and Change [2–4] has been focused on using causal reasoning for solving some problems of elaboration tolerance [5] (mostly, the frame, ramification and qualification problems). However, the representation of some daily scenarios requires the combination of both approaches: using the concept of cause and, at the same time, satisfying elaboration tolerance. In particular, some natural examples require deriving new conclusions from the fact that some agent had caused some event. For instance, consider the following elaboration of the Yale Shooting Scenario [6]. Example 1. There is a turkey called Fred and shooting a loaded gun will kill it. Suzy loads the gun and then shoots. In our country, whoever kills an animal will be punished with imprisonment.  The last sentence of Example 1, which implies deriving new conclusions from a causeeffect relation, does not specify the possible ways in which a person may cause the death of an animal. Depending on the representation of the domain, the chain of events from the agent’s action(s) to the final effect may be simple (a direct effect) or involve a complex set of indirect effects and defaults like inertia. If we look for an elaboration

tolerant representation of this law, its formalisation should not vary if a new way of causing dead is included in the theory. In this work, we will focus on the practical issue of representing elaboration tolerant descriptions of the world in a way that allows deriving new conclusions from statements like “the actions performed by agent ag have been sufficient to cause event B.”

(1)

To this aim, we rely on a recently proposed multivalued extension [7] of the stable model semantics [8] where each atom A belonging to a stable model is associated with a justification in the form of an algebraic expression. This expression corresponds to a set of pairwise incomparable graphs, each one representing an alternative cause of A. In its turn, each graph or cause reflects a logical proof formed by rule labels. In this way, it is possible to conclude when a cause has been sufficient/necessary for some derived event [9]. In this paper, we extend the syntax of logic programs with a new kind of causal literal that allows inspecting the causes of some atom and deriving new conclusions from that. In particular, we study the case of representing statements like (1) and we also extend the syntax of action descriptions under the language BC [10] for an elegant representation of dynamic domains. More specifically, we summarise our contributions as follows. 1. We extend the causal semantics proposed in [7] in two ways. First, we allow rule bodies to contain nested expressions in the sense of [11]. We show that our semantics is a conservative extension of the stable model semantics with nested expressions when programs do not contain disjunctions in the head. Second, and more novel, we also allow formulas in rule bodies to contain causal literals that inspect the causal justifications of atoms. (Section 2). 2. We show how to use causal literals to represent statements like (1) and we apply them to the particular case of Example 1 (Section 3). 3. For dealing with dynamic domains, we extend the action language BC allowing expressions of the form “A has caused B,” and provide the semantics of the language by translating action descriptions into causal logic programs. We show that our translation is equivalent to the one given in [10] when causal information is ignored (Section 4).

2

Causal Stable Model Semantics

We start from identifying program rules as causal laws so that, for instance, (H ← B) can be read as “event B causes effect H.” Using this convention, we may represent the usual Yale Shooting Scenario (if we ignore time by now) with the following program P1 . r1 : dead ← shoot, loaded suzyl : load r2 : loaded ← load

suzys : shoot

where symbols on the left of ‘:’ are just rule labels. This positive program has a unique stable model, in which dead is true. Causal stable models are in one-to-one correspondence with standard stable models, but additionally incorporate causal justifications for

true atoms. In this case, the unique causal stable model I1 associates the causal justification (suzyl·r2 ∗ suzys ) · r1 to dead. This algebraic expression can be depicted1 as the graph G1 in Figure 1. The real innovation of Example 1, with respect to the Yale Shooting Scenario, is its last sentence. We will represent this last sentence with the following new syntax r3 : prison ← (suzy :: dead)

(2)

where (suzy :: dead) is a new kind of causal literal that allows inspecting the causal justifications of dead (in our running example, graph G1 in Figure 1) and it is satisfied when the actions performed by Suzy (suzyl and suzys ) are sufficient to cause dead. suzys

suzyl



r2

+ r1 u G1

Fig. 1: Sufficient cause of the dead in the Yale Shooting scenario. Causal justifications will be represented as algebraic expressions (causal terms) that we formalise as follows. Definition 1 (Term). Given a set of Q labels P Lb, a term, t is recursively defined as one of the following expressions t ::= l | S| S | t1 · t2 where l ∈ Lb is a label, t1 , t2 are in their turn terms and S is a (possibly empty and possible infinite) set of terms.  We assume that application ‘·’ has higher priority than ‘∗’P and, in its turn, ‘∗’ has higher Q priority than ‘+’. When S = ∅, we denote S by 1 and S by 0, as usual, and these will be the identities of the product ‘∗’ and the addition ‘+’, respectively. Associativity t · (u·w) = (t·u) · w Indempotence l·l=l

Absorption t =t+u·t·w u·t·w =t ∗ u·t·w

Addition distributivity t · (u+w) = (t·u) + (t·w) (t + u) · w = (t·w) + (u·w)

Identity t=1·t t= t·1

Annihilator 0= t·0 0=0·t

Product distributivity c · d · e = (c · d) ∗ (d · e) with d 6= 1 c · (d ∗ e) = (c · d) ∗ (c · e) (c ∗ d) · e = (c · e) ∗ (d · e)

Fig. 2: Properties of the ‘·’operators (c, d, e are terms without ‘+’ and l is a label). Definition 2 (Value). (Causal) values are the equivalence classes of terms under axioms for a completely distributive (complete) lattice with meet ‘∗’ and join ‘+’ plus the axioms of Figures 2. The set of values is denoted by VLb . Furthermore, by CLb we denote the subset of causal values with some representative term without sums ‘+’.  1

Although we do not show it, this graph is assumed to be reflexively and transitively closed. For further details on the relation between algebraics expressions and graphs see [12].

All three operations, ‘∗’, ‘+’ and ‘·’ are associative. Product ‘∗’ and addition ‘+’ are also commutative, and they satisfy the usual absorption and distributive laws with respect to infinite sums and products of a completely distributive lattice. The lattice order relation is defined in the usual way: t≤u

iff

(t ∗ u = t)

iff

(t + u = u)

Consequently 1 and 0 are respectively the top and bottom elements with respect to the ≤ order relation. Note that 1 ∈ CLb , but 0 ∈ / CLb . A causal term is said to be in (minimal) disjunctive normal form iff sums are not in the scope of any other operation and addends are pairwise incomparable. By the distributive equations of application ‘·’ and product ‘∗’ over sums ‘+’, every causal term can be rewritten in disjunctive normal form. We will assume that every causal term is in this normal form. Furthermore, we say that a causal term is in graph normal form iff, besides being in disjunctive normal form, no operation is in the scope of application and each addend cannot be equivalently expressed as the product of more (different) subterms. It is worth to mention that ‘∗’ will be used to separate join causes while ‘+’ will be used to separate alternative causes. In its turn, ‘·’ represents the application of causal laws. Syntax. The causal literal (suzy :: dead), in the body of (2), holds when Suzy actions (suzyl and suzys ) have been sufficient to cause dead. In general, a causal literal (ψ :: A) is an expression in which ψ represents any query about the causes of A. For instance, ψ may capture the fact that some set of actions is necessary to cause A or more complicated queries like every action which has caused A by means of a particular causal law. In this work, we restrict to monotonic queries. Formally, a query function is a monotonic function ψ : CLb −→ {0, 1}. A signature, of a causal logic program, is a triple hAt, Lb, Ψ i where At, Lb and Ψ respectively represent sets of atoms (or propositions), labels and query functions. Definition 3 (Causal literal). A (causal) literal is an expression (ψ :: A) where A ∈ At is an atom and ψ ∈ Ψ is a monotonic query function.  We assume that the signature of every program contains a query function ψ 1 ∈ Ψ such that ψ 1 (G) = 1 for all G ∈ CLb . A causal atom (ψ 1 :: A) is said to be regular and, by abuse of notation we will use atom A as shorthand for regular causal literals of the form (ψ 1 :: A). We will see below the justification for this notation. Definition 4. A formula F is recursively defined as one of the following expressions F ::= t | C | E, H | E; H | not E where t is a term, C is a causal literal and both, E and H are formulas in their turn.  A formula F is said to be elementary iff it is a term t or a causal literal C. It is said to be regular iff every causal literal occurring in it is regular and is said to be positive iff the operator not does not occur in it. In formulas, we will write > and ⊥ instead of 1 and 0, respectively.

Definition 5 (Causal logic program). Given a signature hAt, Lb, Ψ i, a (causal logic) program P is a set of rules of the form: ri : H ← F

(3)

where ri ∈ Lb is a label or ri = 1, H (the head of the rule) is an atom or ⊥ and F (the body of the rule) is a formula.  A rule r is said to be regular or positive iff its body is regular or positive, respectively. If F = >, we say that the rule is a fact and omit the body and the symbol ‘←.’ When ri ∈ Lb we say that the rule is labelled; otherwise ri = 1 and we omit both ri and ‘:’. By these conventions, for instance, an unlabelled fact A is actually an abbreviation of (1 : A ←). A program P is positive, regular or unlabelled when all its rules are positive (i.e. it contains no default negation), regular or unlabelled, respectively. A standard program is a regular and unlabelled program. Semantics. A (causal) interpretation is a mapping I : At −→ VLb assigning a value to each atom. For interpretations I and J we say that I ≤ J when I(A) ≤ J(A) for each atom A ∈ At. Hence, there is a ≤-bottom interpretation 0 (resp. a ≤-top interpretation 1) that stands for the interpretation mapping each atom A to 0 (resp. 1). An interpretation I is two-valued when it maps each atom into the set {0, 1}. For any interpretation I, we denote by I cl the two-valued interpretation corresponding to I such that, for every atom A, it assigns I cl (A) = 0 iff I(A) = 0; and I cl (A) = 1 otherwise. Definition 6 (Valuation). The valuation of a causal literal of the form (ψ :: A) with respect to an interpretation I, in symbols I(ψ :: A), is given by X I(ψ :: A) def G ∈ CLb G ≤ I(A) and ψ(G) = 1 = The valuation of a causal term t, in symbols, I(t) = [t] is the class of equivalence of t. Otherwise, the valuation of a formula F is recursively defined as follows ( 1 iff I(E) = 0 I(E, H) = I(E) ∗ I(H) I(not E) = 0 otherwise I(E; H) = I(E) + I(H) We say that I satisfies a formula F , in symbols I |= F , iff I(F ) 6= 0. 1



Note that I(ψ :: A) = I(A) for any atom A, so writing standard atoms like A as a shorthand for causal literals (ψ 1 :: A) does not modify its intended meaning. The reduct of an elementary formula F with respect to an interpretation I is F itself, otherwise the reduct of a formula is defined as follows ( ⊥ if I |= E I (E, H)I = (E I , H I ) I (not E) = > otherwise (E; H)I = (E I ; H I ) Similarly, the reduct of a rule r like (3) w.r.t. I, in symbols rI , is defined as: ri : H ← F I Finally, the reduct of program P w.r.t. I is the program P I def = { rI r ∈ P }.

Definition 7 (Causal stable model). Given a rule r of the form (3), we say that an interpretation I satisfies r if and only if the following condition holds: I(F ) · ri ≤ I(H)

(4)

We say that an interpretation I is a causal stable model of P , in symbols I |= P , iff I is a ≤-minimal interpretation that satisfies all rules in the positive program P I .  In fact, positive causal programs have a least model which can be computed by an extension of the direct consequences operator of Van Emden and Kowalski [13]. For standard programs all labels ri are equal to 1 which is the identity of both product ‘∗’ and application ‘·’, so the two-valued interpretations that are causal stable models of any standard program are exactly the standard stable models of that program in the sense of [11]. Next, we established the correspondence between causal stable models and the standard stable models. Definition 8 (Equivalence). Two programs P and Q are said to be two-valued equivalent iff for every causal stable model I of P there is a unique causal stable model J of Q such that I cl = J cl , and vice-versa.  Theorem 1. Let P be a regular program and Q be its corresponding standard program obtained by removing all labels in P . Then P and Q are two-valued equivalent.  Theorem 1 asserts that, labelling a standard program does not change which atoms are true or false in its stable models, in other words, the causal stable semantics presented here is a conservative extension of the standard stable model semantics with nested expressions when disjunctions in the head are not allowed. Consider, for instance, the regular program P2 consisting in the following rule. r4 : p ← not not p Its standard unlabelled version has two stable models: {} and {p}. Then, there are two causal stable models: I2 (p) = 0 and I20 (p) = r4 , respectively. A further consequence of Theorem 1 is that labelling a standard program in different manners does not change its non-causal meaning. Corollary 1. Any two regular programs that only differ in their labels are two-valued equivalent.  Besides obtaining causal information for each atom, the most interesting feature of our semantics comes from the possibility of deriving new conclusions from them. For instance, consider the program P3 consisting in the rule r4 plus the fact (r5 : p). By looking to its unique causal stable model I3 we can easily conclude that both r4 and r5 are alternative causes of p. We may want to assert that q must hold whenever rule r4 has caused p. Let ψr4 be a query function such that ψr4 (G) def = 1 iff r4 ≤ G; ψr4 (G) def = 0 otherwise. Consider also the program P4 obtained by adding the following rule to program P3 . r6 : q ← (ψr4 :: p) (5) Rule r6 just means that q is caused by the fact that r4 has caused p. This program P4 also has a unique causal stable model satiafing I4 (p) = r4 + r5 . Note that ψr4 (r4 ) = 1

and so I2 |= (ψr4 :: p). Consequently, I40 must also satisfy q. In addition, we may be interested in the causes explaining why q holds, so causal literals should provide causal justifications themselves. In this case, I4 (ψr4 :: p) = r4 and, thus, I4 (q) = r4 · r6 . That is, q holds in the second causal stable model because of rule r6 which, in its turn, depends on the fact that rule r4 has caused p. Although r5 is also a cause of p, this does not produce any cause for q. In fact, if we consider a program P5 obtained by removing rule r4 from P4 , it also has a unique causal stable model satisfying I5 (p) = r5 and I5 (q) = 0. That is, q is now false because r4 has not caused p. In general, the causes of (ψ :: A) are the causes of A that satisfy the query ψ, which, in its turn, correspond2 with the logical proofs of A that satisfy the query function ψ. The programs representing most of the natural examples that involve causal literals are splittable. A splitting of a program P is a partition hPb , Pt i of P such that no literal occurring in a body in Pb (the bottom part) is a head atom in Pt (the top) [14]. We say that a program P is splittable with respect to a an atom A if there exists a splitting hPb , Pt i such that A does not occur in the body of any rule in Pb and A does not occur in the head of any rule in Pt . For splittable programs (as it is the case of programs P4 aand P5 ) we may understand causal literals in the top part of the program as a query over its bottom part. Next, we formalise this idea. For any interpretation I, by I we also denote the set of rules I def = { A ← t A ∈ At and t = I(A) } Note the convenience of this abuse of notation: the least model of program I is the interpretation I. For any set S, by I|S we denote an interpretation such that I|S (A) = I(A) for all A ∈ S and I|S (A) = 0 for all A ∈ / S. Theorem 2 (Splitting). Let P be a program, hPb , Pt i a splitting of P and let S be a set of atoms containing all atoms of Pb but no head atoms of Pt . An interpretation I is a causal stable model of P iff I|S is causal stable model of Pb and I is a causal stable model of I|S ∪ Pt . 

3

Representing cause-effect relation by Causal Literals

We may now go back to Example 1 and formalize the precise meaning of causal literal (suzy :: dead) in the body of (2). Given two sets of labels S ⊆ T ⊆ Lb we define ( Q 1 if { l l ∈ A } ≤ ϕT (G) def ψS,T (G) = (6) 0 otherwise where ϕT (G) is the result of removing all labels not in T from the graph normal form of G. Informally ψS,T holds when labels in S are sufficient for causing the same effect than G when only the labels from T are considered. We also define a partition hLbA , LbR i of Lb. Sets LbA and LbR respectively represent the set of labels corresponding to actions and causal laws. Then, each agent ag is represented by the set of 2

The formalization of this correspondence for causal literals is similar to the one for standard literals addressed in [7] and it can be found in [12].

actions ag ⊆ LbA it performs. For instance, let P6 the result of adding rule (2) to program P1 . Program P6 has action labels LbA = suzy = {suzyl , suzys } and rule labels LbR = {r1 , r2 , r3 }. Then,
ϕLbA (suzyl ·r2 ∗ suzys )·r1 = suzyl ∗ suzys
and, thus, ψsuzy,LbA (suzyl ·r2 ∗ suzys )·r1 = 1. Consequently, I6 (ψsuzy,LbA :: dead) = I6 (dead) Since the set of action is fixed for a program, in the sake of readability, we just write (suzy :: dead) instead of (ψsuzy,LbA :: dead). As in the above example, the least model I6 of program P6 satisfies I6 |= (suzy :: dead) and, thus, we may conclude that the least model I6 must also satisfy prison. In addition, we obtain that its causal justification is I6 (suzy :: dead) = I6 (dead) and, thus I6 (prison) = (suzyl ·r2 ∗ suzys )·r1 ·r3 That is, Suzy is in prison because she has killed Fred and because rule r3 has been applied.

4

Extending the Action Language BC

Although we have represented a static variation of Yale Shooting Scenario, this is a traditional example of the area of reasoning about actions and change. The dynamic domain of this example can be elegantly represented in the action language BC by the following pair of dynamic laws load causes loaded

(7)

shoot causes dead if loaded

(8)

plus a default law stating that both fluents, loaded and dead, are inertial. For dealing with the last sentence of Example 1 we extend the language BC with a static law of the form prisonsuzy if suzy has caused dead (9) where (suzy has caused dead) is an expression that corresponds to the above idea of causal literal. Syntax. An action description includes a finite set of symbols of three kinds, fluent constants F, action constants Act and agent constants Ag. A finite set of cardinality at least 2, called the domain, is assigned to every fluent constant. A BC-atom is an expression of the form F = v where F is a fluent constant and v is an element of its domain. A BC-literal is either a BC-atom or an expression of the form (ag has caused B) where B is a BC-atom and ag is an agent in Ag. If the domain of F is {t, f } then we say that F is Boolean. Sometimes, if a fluent is Boolean, we will write just F and ¬F instead of F = t and F = f , respectively.

A static law is an expression of the form: H if B1 , . . . , Bm ifcons Bm+1 , . . . , Bn

(10)

(0 ≤ m ≤ n) where H is a BC-atom and each Bi are BC-literals. Informally speaking, it means that every state satisfies H if it satisfies B1 , . . . , Bm and Bm+1 , . . . , Bn can be consistently assumed. If m = 0 (resp. m = n) then we will drop if (resp. ifcons). A dynamic law is an expression of the form: H after B1 , . . . , Bm ifcons Bm+1 , . . . , Bn

(11)

(0 ≤ m ≤ n) where H is a BC-atom, each Bj with m < j ≤ n is a BC-literal and each Bi with 1 ≤ i ≤ m is either an action constant or a BC-literal. As with static laws, if m = 0 then we will drop after; if m = n then we will drop ifcons. If exactly one of the Bi ’s with 1 ≤ i ≤ m is an action (assume B1 ), we write B1 causes H if B2 , . . . , Bm ifcons Bm+1 , . . . , Bn

(12)

instead of (11). This writing emphasises the casual meaning of laws. A default law is an expression of the form default B0 after B1 , . . . , Bm

(13)

If m = 0 then we will drop after. We will denote by inertial F1 , F2 , . . . , Fm

(14)

default Fj = v after Fj = v

(15)

the set of default laws for every fluent Fj with 1 ≤ j ≤ m and for every value v in the domain of Fj . Note that we consider default laws (13) as proper constructions of the language instead of abbreviations. We will see below the importance of this distinction when obtaining causal information. Definition 9 (Action description). An action description D in the language BC is a finite set consisting of static, dynamic and default laws. A regular action description is one that does not contain expressions of the form (ag has caused B).  Semantics. For every action description D, we define a sequence of causal programs CP0 (D), CP1 (D), . . . as in [10]. The signature σD,l = hAt, Lb, Ψ i of program CPl (D) consists of a set of atoms At containing an atom F i = v for each BC-atom F = v and nonnegative integer 0 ≤ i ≤ l; plus an atom Ai for each action A and nonnegative integer 0 ≤ i < l, plus a new auxiliary atom def aultiB for every BC-atom B of the form F = v and 0 < i ≤ l. Intuitively, an atom def aultiB means that the fluent F takes value v in situation i by default, and it will allow defaults to take causal preference over static and dynamic laws when they allow deriving the same conclusion. The set Lb consists of a different label ri for each static and dynamic law and nonnegative integer i 0 ≤ i ≤ l (0 < i ≤ l for dynamic laws), plus a label agA for each agent ag in Ag and action A in Act. The set Ψ will contain the query function ψ 1 plus a query function ψag,LbA , as defined in (6), for each agent ag in Ag.

For each situation i, by B i we denote an atom of the form F i = v if B is a BC-atom of the form F = v; an atom Ai if B is an action A; and a causal literal (ψag,LbA :: C i ) if B is a BC-causal literal (ag has caused C). Then, program CPl (D) consists of the following rules: A rule i ri : H i ← B1i , . . . , Bm , not not B1i , . . . , not not Bni , not def aultiH

(16)

for every static law (10) from D and 0 ≤ i ≤ l. A rule i ri+1 : H i+1 ← B1i , . . . ,Bm , not not B1i+1, . . . , not not Bni+1, not def aulti+1 H

(17)

for every dynamic law (12) from D and 0 ≤ i < l. A pair of rules H i+1

i ← B1i , . . . , Bm , not not H i+1

def aulti+1 H

←

i B1i , . . . , Bm ,

not not H

i+1

(18) (19)

for every default law of the form of (13) from D and 0 ≤ i < l. An unlabelled rule (B 0 ← not not B 0 )

(20)

for every BC-atom B. Existence of value is stated by a constraint of the form ← not (F i = v1 ), . . . , not (F i = vk )

(21)

for every fluent F and every 0 ≤ i ≤ l, where v1 , . . . vk are the elements of the domain of F . Uniqueness of value is stated by a constraint of the form ← (F i = v), (F i = w)

(22)

for every fluent F , every 0 ≤ i ≤ l and every pair of distinct elements v and w of the domain of F . On the one hand, rules corresponding to static and dynamic laws are labelled, so they will be traced in the causal justifications associated with each fluent. On the other hand, rules corresponding to default laws are unlabelled, so they will not be traced. Furthermore, our translation of static laws (16) adds a literal not def aultiH in the body of each rule with respect to the original translation defined in [10]. As commented before, atom def aultiH intuitively means that atom H holds by default at situation i. Thus, disabling the rule, when the atom def aultiH holds, will not change the truth value assigned to the fluent associated with H (atom H i will hold anyway by means of another rule corresponding to a default law). However, disabling the rule does affect its causal justifications: H i will only inherit the causal justifications from the default law that concludes H i , ignoring those that, otherwise, would follow from the static law. The same also applies to dynamic laws, that is, default laws take causal preference over both, static and dynamic laws3. It is easy to see now the purpose of rules (19) in 3

In fact, the auxiliary atom def aultiH is capturing the application of a rule (representing a default law). Therefore, in principle, it could be possible to replace the literal not def aultiH in the body of (16) and (17) by a causal literal (ψdef aulti :: H i ) that captures the same H meaning. Unfortunately, function ψdef aulti is nonmonotonic, and the study of nonmonotonic H causal literals is left for future work.

the translation of default laws for representing this preference. We will see below the importance of this feature for KR by an elaboration of our running example. For establishing a formal relation between programs CPl (D) and P Nl (D) defined in [10], note that program CPl (D) does not contain choice rules for actions. Therefore, we define CPNl (D) as the result of adding a labelled choice rule i agA : Ai ← not not Ai

(23)

to program CPl (D), for all action A, agent ag and 0 ≤ i < l. Two interpretations I and J are equivalent modulo S iff I|S (A) = J|S (A) for every atom A and two-valued equivalent modulo S iff I cl and J cl are equivalent modulo S. Definition 10 (Equivalence). Given a signature σ = hAt, Lb, Ψ i, programs P and Q are two-valued equivalent modulo σ iff for every causal stable model of P there is a unique, two-valued equivalent modulo At, causal stable model of Q, and vice-versa.  Theorem 3. For every regular action description D and non-negative integer 0 ≤ l, let P Nl (D) be the standard logic program with nested expressions as defined in [10]. Then, the causal program CPNl (D) and P Nl (D) are two-valued equivalent modulo the signature of P Nl (D).  Theorem 3 shows that the BC semantics we define here agrees with the semantics defined in [10] in the truth values assigned to every fluent. An immediate consequence is that we can define the transition system T (D) just the same as in [10]. However, a causal model contains, in addition to the information contained in some state of T (D), the causal information explaining why each fluent possesses its current value in that state. Query Language. We introduce now a variation of the query language Q [15] for representing particular stories. A fluent axiom is an expression of the form holds B at i

(24)

where B is a BC-atom and 0 ≤ i ≤ l is a nonnegative integer. An action axiom is of the form ag does A at i (25) where ag is an agent in Ag, A is an action and 0 ≤ i < l is a nonnegative integer. Given an action description D plus a set of axioms ∆, the program CPl (D, ∆) is obtained from program CPl (D) by adding a constraint ⊥ ← not B i

(26)

for each fluent axiom (24), and a labelled fact i agA : Ai (27) for each action fluent (25). A query is either a fluent axiom (24) or an expression like

ag has caused B at i with agent ∈ Ag, B a BC-atom and 0 ≤ i ≤ l.

(28)

Definition 11. An interpretation I satisfies a query of the form (24) iff I |= B i and a query of the form (28) iff I |= (ψag,LbA :: B i ). A query Q is a consequence of a set of axioms ∆ with respect to an action description D iff every causal stable model I of CPl (D, ∆) satisfies Q.  As an example, consider the action description D consisting of causal laws (7) and (8) plus default laws stating that both fluents, loaded and dead, are inertial. Let ∆ a set of axioms capturing the story of Example 1 as follows holds ¬dead

at 0

suzy does load at 0

holds ¬loaded at 0

suzy does shoot at 2

Then, the queries (holds dead at 3) and (suzy has caused dead at 3) are consequences of ∆ with respect to an action description D. Example 2 (Ex. 1 continued). After Suzy shot, Billy loads his gun and then shoots. Who killed Fred?  This variation of Example 1 is inspired by the Rock Throwers Scenario introduced in [16]. It is clear that Suzy killed Fred, while Billy just shot to a dead turkey. The interesting feature of this example relies on recognising the asymmetry produced by time in the causal relation. On the one hand, the scenario of this example can be captured by an action description D consisting of loadA causes loadedA

(29)

shootA causes dead if loadedA

(30)

inertial loadedA , dead

(31)

with A ∈ {suzy, billy}. On the other hand, the particular story of Example 2 can be represented by a set of axioms ∆ consisting of holds ¬dead

at 0

suzy does loadsuzy at 0

holds ¬loadedsuzy at 0

suzy does shootsuzy at 2

holds ¬loadedbilly at 0

billy does loadbilly at 3 billy does shootbilly at 4

Then, queries (holds dead at i) and (suzy has caused dead at i) are consequences of ∆ for 3 ≤ i. However, as expected, (billy has caused dead at i) is not a consequence for any i. Note here the importance of disabling the dynamic laws (30) by means of the atom def ault5dead , so dead at 5 only inherits the causal justifications from 4 by inertia. Consider now the variation introduced by Example 1 by adding laws prisonA if A has caused dead

(32)

inertial prisonA

(33)

plus axioms holds ¬prisonA at 0

(34)

with A ∈ {suzy, billy}. Then, query (holds prisonsuzy at i) is a consequence for 6 ≤ i, whereas (holds prisonbilly at i) is not for any i. Note also that prisonsuzy (as any other true BC-atom) is associated with a causal graph justification capturing that Suzy is in prison because she has caused Fred’s death and, thus, law (32) has been applied to her. This example shows that our extension of the BC-language not only allows deriving causal justifications and relation between events, but also using these relations for reasoning and deriving new conclusions from them.

5

Related Work

[17] already introduced the main motivations of our work, but used ad hoc operations on proof trees. A further elaboration was carried on [7] which substitutes those ad hoc operations by a free complete distributive lattice generated by causal graphs, an algebraic structure which is isomorphic to the one formed by our causal values and their three operations. However, this elaboration still has two limitations compared to the one proposed here. First, nested expressions in the body were not allowed. Double negation in the body is necessary for defining the semantics of the BC language. Second, and more important, although [7] allows obtaining causal explanations as in our current approach, it does not allow deriving new conclusions from them. As mentioned in the introduction, there exists a vast literature on causality in Philosophy. In this sense, our general understanding of causality is similar to the quasiNewtonian principle introduced by [18]: we assume the world is governed by causal laws, and that causes play a similar role to forces in the Newtonian mechanics while defaults play the role of objects’ inertial behaviour. In AI, perhaps the most established approach for causality is based on Pearl’s work on causal networks [1] (See [19] for an updated overview). There are two major differences between our work and this approach. First, our overall goal focuses on defining precise semantics of different causal relations that allow an elaboration tolerant representation of knowledge, and leave open the choice of which concept corresponds to a particular scenario. Work that follows Pearl’s approach is mostly focused on revealing a unique everyday-concept of causation (actual causation). Second, in this work, we particularly focus on representing sufficient causes whereas Pearl’s approach is mostly necessity-based: “A has been an actual cause of B” is derived from the behaviour of structural equations by applying, under some contingency, the counterfactual dependence “had A not happened, B would not have happened.” Focusing on LP, Pearl’s approach has also been followed by [20] and [21]. Furthermore, our work obviously relates to explanations as provided by approaches to debugging and justifications in ASP by [22–25]. [23] allows a Prolog system to reason about justifications of an ASP program, but justifications cannot be inspected inside the ASP program. A formal relation between the justifications provided by our approach and [25] can be found in [26].

6

Conclusions and Open Issues

The main contribution of this work is the introduction of causal literals that allows deriving new conclusions by inspecting the causal justifications of atoms without falling

in problems of elaboration tolerance. In general, causal literals allow any monotonic function as query: defining precise literals that capture meaningful causal relations is a major open issue. In particular, we have defined a causal literal that allows queries of the form “the actions performed by agent A have been sufficient to cause event B.” Similarly, the complexity of computing causal stable models depends on the complexity of the queries included in the program, in particular, for the queries discussed through the paper the complexity does not increase with respect to standard normal programs (NP-complete). Besides, the action language BC provides an elegant way for representing causal knowledge by a combination of causal and default laws. We defined a causal semantics for this language and by a running example, which combines issues from the area of reasoning about actions and change and the actual causation literature, we showed how to represent causal knowledge by action descriptions, and derive conclusions that imply reasoning with causal relations. As commented above, an interesting issue for future study is defining new kinds of meaningful causal literals. Also, allowing causal literals to rely on nonmonotonic functions would be worth for representing necessary causation, contributory causation and other possible causal relations. Natural next steps are also allowing nested expressions in rule heads, which will be useful for representing non-deterministic causal laws, and replacing the syntactic definition in favour of a logical treatment of default negation, as done for instance with the Equilibrium Logic [27] characterisation of stable models. Acknowledgements I am thankful to Pedro Cabalar for his suggestions and comments on earlier versions of this work. I also thank the anonymous reviewers for their help to improve the paper. This research was partially supported by Spanish Project TIN201342149-P.

References 1. Pearl, J.: Causality: models, reasoning, and inference. Cambridge University Press, New York, NY, USA (2000) 2. Lin, F.: Embracing causality in specifying the indirect effects of actions. In: Proceedings of the Fourteenth International Joint Conference on Artificial Intelligence, IJCAI 95, Montr´eal Qu´ebec, Canada, August 20-25 1995, 2 Volumes, Morgan Kaufmann (1995) 1985–1993 3. McCain, N., Turner, H.: Causal theories of action and change. In Kuipers, B., Webber, B.L., eds.: Proceedings of the Fourteenth National Conference on Artificial Intelligence and Ninth Innovative Applications of Artificial Intelligence Conference, AAAI 97, IAAI 97, July 27-31, 1997, Providence, Rhode Island., AAAI Press / The MIT Press (1997) 460–465 4. Thielscher, M.: Ramification and causality. Artificial Intelligence 89(1-2) (1997) 317–364 5. McCarthy, J.: Elaboration tolerance. In: Proceedings of the Fourth Symposium on Logical Formalizations of Commonsense Reasoning, Common Sense, London, UK (1998) 198–217 6. Hanks, S., McDermott, D.V.: Nonmonotonic logic and temporal projection. Artificial Intelligence 33(3) (1987) 379–412 7. Cabalar, P., Fandinno, J., Fink, M.: Causal graph justifications of logic programs. Theory and Practice of Logic Programming TPLP 14(4-5) (2014) 603–618 8. Gelfond, M., Lifschitz, V.: The stable model semantics for logic programming. In Kowalski, R.A., Bowen, K.A., eds.: Logic Programming, Proceedings of the Fifth International Conference and Symposium, Seattle, Washington, August 15-19, MIT Press (1988) 1070–1080

9. Cabalar, P., Fandinno, J., Fink, M.: A complexity assessment for queries involving sufficient and necessary causes. In Ferm´e, E., Leite, J., eds.: Logics in Artificial Intelligence - 14th European Conference, JELIA 2014, Funchal, Madeira, Portugal, September 24-26, 2014. Proceedings. Volume 8761 of Lecture Notes in Computer Science., Springer (2014) 297– 310 10. Lee, J., Lifschitz, V., Yang, F.: Action language BC: preliminary report. In Rossi, F., ed.: IJCAI 2013, Proceedings of the 23rd International Joint Conference on Artificial Intelligence, Beijing, China, August 3-9, 2013, IJCAI/AAAI (2013) 11. Lifschitz, V., Tang, L.R., Turner, H.: Nested expressions in logic programs. Ann. Math. Artif. Intell. 25(3-4) (1999) 369–389 12. Fandinno, J.: A Causal Semantics for Logic Programming (draft). PhD thesis, University of Corunna (September 2015) 13. van Emden, M.H., Kowalski, R.A.: The semantics of predicate logic as a programming language. Journal of the ACM (JACM) 23(4) (1976) 733–742 14. Lifschitz, V., Turner, H.: Splitting a logic program. In Hentenryck, P.V., ed.: Logic Programming, Proceedings of the Eleventh International Conference on Logic Programming, Santa Marherita Ligure, Italy, June 13-18, 1994, MIT Press (1994) 23–37 15. Gelfond, M., Lifschitz, V.: Representing action and change by logic programs. J. Log. Program. 17(2/3&4) (1993) 301–321 16. Lewis, D.K.: Causation as influence. The Journal of Philosophy 97(4) (2000) 182–197 17. Cabalar, P.: Logic programs and causal proofs. In: Logical Formalizations of Commonsense Reasoning, Papers from the 2011 AAAI Spring Symposium, Technical Report SS-11-06, Stanford, California, USA, March 21-23, 2011, AAAI (2011) 18. Maudlin, T.: Causation, counterfactuals, and the third factor. In Collins, J., Hall, E.J., Paul, L.A., eds.: Causation and Counterfactuals. MIT Press (2004) 19. Halpern, J.Y., Hitchcock, C.: Actual causation and the art of modeling. CoRR abs/1106.2652 (2011) 20. Meliou, A., Gatterbauer, W., Halpern, J.Y., Koch, C., Moore, K.F., Suciu, D.: Causality in databases. IEEE Data Eng. Bull. 33(EPFL-ARTICLE-165841) (2010) 59–67 21. Vennekens, J.: Actual causation in CP-logic. Theory and Practice of Logic Programming TPLP 11(4-5) (2011) 647–662 22. Gebser, M., P¨uhrer, J., Schaub, T., Tompits, H.: A meta-programming technique for debugging answer-set programs. In Fox, D., Gomes, C.P., eds.: Proceedings of the Twenty-Third AAAI Conference on Artificial Intelligence, AAAI 2008, Chicago, Illinois, USA, July 13-17, 2008, AAAI Press (2008) 448–453 23. Pontelli, E., Son, T.C., El-Khatib, O.: Justifications for logic programs under answer set semantics. Theory and Practice of Logic Programming TPLP 9(1) (2009) 1–56 24. Schulz, C., Toni, F.: Justifying answer sets using argumentation. CoRR abs/1411.5635 (2014) 25. Dam´asio, C.V., Analyti, A., Antoniou, G.: Justifications for logic programming. In Cabalar, P., Son, T.C., eds.: Logic Programming and Nonmonotonic Reasoning, Twelfth International Conference, LPNMR 2013, Corunna, Spain, September 15-19, 2013. Proceedings. Volume 8148 of Lecture Notes in Computer Science., Springer (2013) 530–542 26. Cabalar, P., Fandinno, J.: Enablers and inhibitors in causal justifications of logic programs. In Francesco Calimeri, Giovambattista Ianni, M.T., ed.: Logic Programming and Non-monotonic Reasoning, 13th International Conference, LPNMR 2015 Lexington, KY, USA September 27-30, 2015. Proceedigns (to appear). (2015) 27. Pearce, D.: A new logical characterisation of stable models and answer sets. In Dix, J., Pereira, L.M., Przymusinski, T.C., eds.: Non-Monotonic Extensions of Logic Programming, NMELP 1996, Bad Honnef, Germany, September 5-6, 1996, Selected Papers. Volume 1216 of Lecture Notes in Computer Science., Springer (1996) 57–70