Representing Actions in Logic-based Languages

Transcription

1 TPLP 13 (4-5): Online Supplement, July c 2013 [FANGKAI YANG] 1 Representing Actions in Logic-based Languages FANGKAI YANG Department of Computer Science, The University of Texas at Austin ( fkyang@cs.utexas.edu) submitted 12 May 2013; accepted 5 June 2013 Abstract We investigate using logic programming, causal theories and action languages to describe effects of actions and reason about dynamic domains. This includes characterizing first-order causal theory by functional completion, characterizing first-order stable models by Lloyd-Topor completion, representing causal theories in logic programming and describing dynamic domains in the new action language BC. KEYWORDS: reasoning about actions, causal theories, action languages 1 Introduction Knowledge about actions is an important part of commonsense knowledge studied in Artificial Intelligence. For decades, researchers have been developing methods for describing how actions affect the states of the world and for the automation of reasoning about actions. Following the groundbreaking paper (McCarthy and Hayes 1969), we describe a state of the world with values of fluents that can be affected by performing actions. For instance, a light switch can be either on or off, so that its state can be described by the Boolean (that is, truth-valued) fluent On. The location of a block B can be described by the non-boolean fluent loc(b). Possible values of this fluent are Table and other blocks. Performing the action Toggle changes the value of On from true to false and vice versa, and performing the action Move(B, Table) makes the value of loc(b) equal to Table. In a dynamic domain, performing an action changes the state of the world. Reasoning about dynamic domains typically deals with three kinds of computational problems: temporal projection (also known as prediction): given the values of fluents in the initial state and a sequence of actions to be performed, what can we say about the values of fluents in the resulting state? postdiction: given the values of fluents after performing a sequence of actions, what can we say about the initial state? planning: find a sequence of actions that leads from a given initial state to a given goal state. An intelligent agent should be able to answer queries of these kinds in order to behave intelligently in the world. Developing methodologies for describing action domains in logic-based formalisms and for solving the computational problems described above are major topics of research in this area.

2 2 Fangkai Yang After the publication of (McCarthy and Hayes 1969), solving the frame problem (concisely expressing a dynamic domain without explicitly specifying which conditions are not affected by an action) remained one of the key research challenges, leading to the invention of default theories (Reiter 1980), autoepistemic logic (Moore 1985), and circumscription (McCarthy 1980; McCarthy 1986). One of the solutions to the frame problem available today uses the answer set semantics of logic programs (Gelfond and Lifschitz 1988; Gelfond and Lifschitz 1991). Another approach to the frame problem is based on the theories of causality developed in (Geffner 1990; Lin 1995; McCain and Turner 1997; Lifschitz 1997; Giunchiglia et al. 2004). Action description languages are high level languages that allow us to represent knowledge about actions more concisely than the situation calculus. Many action description languages have been described in the literature, from the well-known STRIPS (Fikes and Nilsson 1971), to more expressive ADL (Pednault 1994), to action languages invented more recently such as B (Gelfond and Lifschitz 1998, Section 5), C (Giunchiglia and Lifschitz 1998; Gelfond and Lifschitz 1998, Section 6), and C + (Giunchiglia et al. 2004). The last three allow us to describe actions with indirect effects ( ramifications ). The semantics of B is closely related to the answer set semantics of logic programs. The languages C and C + are closely related to the causal logic proposed in (McCain and Turner 1997). Theoretical work on developing logic-based formalisms and action languages has led to the implementation of systems that can efficiently automate reasoning about actions. The definite fragment of C + is implemented in the Causal Calculator (CCALC) 1, which translates a causal theory into a set of propositional clauses and calls a SAT solver to answer queries. On the other hand, definite causal theories can be represented by logic programs under the answer set semantics (McCain 1997), so that they can be also implemented using computational methods of answer set programming (ASP). Systems of this kind are COALA (Gebser et al. 2010) and CPLUS2ASP (Casolary and Lee 2011). They transform an action description and a query into a logic program and call an answer set solver, such as CLINGO with its grounder GRINGO 2, or SMODELS with its grounder LPARSE 3 to compute its stable models. Some types of commonsense reasoning require the use of non-definite causal theories. As pointed out in (Erdoğan and Lifschitz 2006), humans often define actions as special cases of more general actions. For instance, the dictionary defines action push as synonymous with move by steady pressure. To talk about synonyms in causal logic, we need non-definite rules. Both stable models and causal theories were originally defined in the propositional setting; variables have to be eliminated by grounding. These concepts were lifted to the first-order case in (Lifschitz 1997) and (Ferraris 2007; Ferraris et al. 2011). The first-order versions of these nonmonotonic formalisms are similar to circumscription: each of them employs a syntactic transformation that turns a first-order sentence into a stronger sentence, which may involve second-order quantifiers. This additional generality is important for many applications to the theory of commonsense reasoning. The research outlined in this note addresses problems of two kinds. First, we study some not yet well-understood mathematical properties of features of expressive action languages based on nonmonotonic causal logic. This includes causal rules expressing synonymy, nondefinite causal rules, and nonpropositional causal rules. In particular, we generalize existing translations from

3 Theory and Practice of Logic Programming 3 nonmonotonic causal theories to logic programming under the answer set semantics, so that it is possible to automate reasoning with a wider class of causal theories by calling answer set solvers. Second, we design and study new action languages, more expressive in some ways than the languages proposed in the past. We develope a framework that combines the most useful expressive possibilities of the languages B and C, and use program completion to characterize the effects of actions described in these languages. The new action language, called BC has been implemented in CPLUS2ASP version 2 (Babb and Lee 2013). 2 Functional Completion Functional completion (Lifschitz and Yang 2013) generalizes the important concept of literal completion (Lifschitz 1997) of a first-order causal theory. As pointed out above, the semantics of causal theories involves second-order formulas. Literal completion is a process that allows us, in some cases, to turn these second-order formulas into equivalent first-order formulas. It is, however, applicable to a causal theory only if each of its explainable symbols is a predicate constant; function constants are allowed in the signature, but they cannot be explainable. Explainable function symbols are often useful: they are needed, for instance, to talk about non-boolean fluents such as loc(b) in the blocks world example above. In (Lifschitz and Yang 2013) we show how to extend the definition of literal completion and the theorem on literal completion from (Lifschitz 1997) to causal theories with explainable function symbols. This can be illustrated by the following causal theory that describes the domain of moving objects: 0 = 1, 0 = none, 1 = none, obj(x) place(y) move(x, y), loc(x,0) = y loc(x,0) = y obj(x) place(y), loc(x,1) = y move(x,y), loc(x,1) = y loc(x,0) = y loc(x,1) = y obj(x) place(y), loc(x, t) = none obj(x), loc(x,t) = none t 0 t 1, where loc is an explainable function symbol. We established the equivalence between a causal theory and its functional completion under the assumption that x 1 x 2 (x 1 x 2 ) is true, that is, there are at least two distinct elements in the universe. In (Lifschitz 1997, Completion Theorem), the equivalence between a definite causal theory and its literal completion does not require this condition. For instance, using our theorem on functional completion we can show that (1) is equivalent to the conjunction of the sentences 0 1, 0 none, 1 none, xy(move(x, y) obj(x) place(y)), x(obj(x) place(loc(x, 0))), xt(( obj(x) (t 0 t 1)) loc(x,t) = none), xy(obj(x) loc(x,1) = y (move(x,y) (loc(x,0) = y w move(x,w)))). (1) 3 Representing Causal Theories with Logic Programs The development of the systems COALA and CPLUS2ASP relies on the translation from causal theories into logic programs described in (McCain 1997). In (Lifschitz and Yang 2010; Ferraris

4 4 Fangkai Yang et al. 2012), we generalize earlier work on translating causal theories into logic programs. First, we discard the requirement that the bodies of the given causal rules be conjunctions of literals. Second, instead of requiring that the head of each causal rule be a literal, we allow the heads to be disjunctions of literals. In this more general setting, the logic program corresponding to the given causal theory becomes disjunctive. Third, we study causal rules with heads of the form L 1 L 2, where L 1 and L 2 are literals. Such a rule says that there is a cause for L 1 and L 2 to be equivalent ( synonymous ) under some condition, expressed by the body of the rule. A synonymy rule L 1 L 2 G (2) can be translated into logic programming by rewriting it as the pair of rules L 1 L 2 G L 1 L 2 G (L stands for the literal complementary to L) and then using our extension of McCain s translation for rules with disjunctive heads. It turns out, however, that there is no need to use disjunctive logic programs in the case of synonymy rules. If, for instance, G in (2) is a literal then the following group of nondisjunctive rules will do: L 1 L 2,not G L 2 L 1,not G L 1 L 2,not G L 2 L 1,not G. Finally, we extend the translation from propositional causal rules to first-order causal rules in the sense of (Lifschitz 1997). This version of causal logic is useful for defining the semantics of variables in action descriptions (Lifschitz and Ren 2007). In (Lifschitz and Yang 2011), we propose a way to eliminate explainable function symbols in causal theories in favor of explainable predicate symbols. This is important because the translation proposed in (Lifschitz and Yang 2010; Ferraris et al. 2012) is not directly applicable to fluents with non-boolean values, represented by function symbols. In classical logic, this process is well understood, but extending it to nonmonotonic causal logic is not straightforward, especially if we want to arrive eventually at an executable ASP program. We describe two procedures for eliminating function constants from a causal theory in favor of predicate constants: general and definite. Then we show how definite elimination can help us turn a causal theory into executable ASP code, and how it can be extended to rules that express the synonymy of function symbols. The results of those papers allow us, for instance, to transform (1) into a logic program. First,

5 Theory and Practice of Logic Programming 5 the explainable function symbol loc is eliminated in favor of the predicate symbol at: 0 = 1, 0 = none, 1 = none, obj(x) place(y) move(x,y) at(x,0,y) at(x,0,y) obj(x) place(y), at(x,1,y) move(x,y) at(x,1,y) at(x,0,y) at(x,1,y) obj(x) place(y), at(x, t, none) obj(x), at(x,t,none) t 0 t 1, at(x,t,y) at(x,t,y) (3) The equivalence of (3) and (1) is entailed by Second, we translate (3) into the logic program xty(at(x,t,y) loc(x,t) = y). 0 1, 0 none, 1 none, ât(x,0,y) obj(x) place(y) at(x,0,y), move(x, y) place(y) move(x, y) obj(x) move(x,y) at(x,1,y), ât(x,0,y) ât(x,1,y) obj(x) place(y) at(x,1,y), at(x,t,y) ât(x,t,y), obj(x) at(x, t, none), t 0 t 1 at(x,t,none), ( xt!y)at(x, t, y), (ât(x,t,y) at(x,t,y)). (4) The stable models of the program above are isomorphic to the models of (1). This logic program can be easily rewritten as executable CLINGO code. 4 Action Language BC In (Lee et al. 2013), we define a new action description language, called BC, that combines the attractive features of B and C +. This language, like B, can be implemented using the computational methods of answer set programming. The main difference between B and BC is similar to the difference between inference rules and default rules. Informally speaking, a default rule allows us to derive its conclusion from its premise if its justification can be consistently assumed; default logic (Reiter 1980) makes this idea precise. In the language B, a static law has the form In BC, a static law may include a justification: <conclusion> if <premise>. <conclusion> if <premise> ifcons <justification> (if cons is an acronym for if consistent ). Dynamic laws may include justifications also, of the

6 6 Fangkai Yang form <conclusion> after <premise> ifcons <justification>. Static and dynamic laws describe different aspects of a transition system. Static laws describe the relationship between fluents within one state, while dynamic laws describe how one state transitions to another (indicated by after). Consider a container of capacity n that has a leak, such that it loses k units of liquid per unit time unless it is refilled. To describe this dynamic domain in BC, we use the regular fluent constant Amt with domain {0,...,n}, for the amount of liquid in the container, the action constant FillUp, and the dynamic laws Amt=max(a k,0) after Amt=a ifcons Amt=max(a k,0), (a = 0,...,n) Amt=n after FillUp. (5) The semantics of BC is defined by transforming action descriptions into logic programs under the stable model semantics. When static and dynamic laws of the language B are translated into the language of logic programming, as in (Balduccini and Gelfond 2003), the rules that we get do not contain negation as failure. Logic programs corresponding to B-descriptions do contain negation as failure, but this is because inertia rules are automatically included in them. In the case of BC, on the other hand, negation as failure is used for translating justifications in both static and dynamic laws. For instance, the first law in (5) can be translate into the logic programming rule (i+1):(amt=max(a k,0)) i:amt=a (i+1):(amt=max(a k,0)). We define three translations from BC into logic programming. Their target languages use slightly different versions of the stable model semantics, but we show that all three translations give the same meaning to BC -descriptions. The first version uses nested occurrences of negation as failure (Lifschitz et al. 1999); the second involves strong (classical) negation (Gelfond and Lifschitz 1991) but does not require nesting; the third produces multi-valued formulas under the stable model semantics (Bartholomew and Lee 2012). Each of the action languages B, C + has attractive features that are not available in the other language. In particular, B allows us to describe Prolog-style recursive definitions and C + can be used to talk about non-inertial fluents, such as Amt in the leaking container example. The language BC combines attractive features of B, C +. 5 Lloyd-Topor Completion and General Stable Models The paper (Lifschitz and Yang 2012) is about the conditions under which the stable models of a logic program are characterized by the program s completion in the sense of (Clark 1978; Lloyd 1984). This problem has been discussed in many papers, beginning with (Fages 1994). Our enhancement of Fages theorem, based on the concept of a rule dependency graph, is motivated by examples of logic programs describing dynamic domains. Earlier work in this direction is reported in (Ferraris et al. 2011) an. (Lee and Meng 2011). The first paper generalizes the tightness condition introduced by Fages. According to (Ferraris et al. 2011, Theorem 11), the stable models of a tight program are described by its completion. The second paper defines the class of atomic-tight programs. According to (Lee and Meng 2011, Corollary 5), the stable models of an atomic-tight program are described by its completion in

7 Theory and Practice of Logic Programming 7 the presence of the Clark Equality Axioms. However, these theorems are not applicable to the program p(a) p(b), q(c) q(d), a = b, c = d. The result of applying the operator SM to (6) is equivalent to the conjunction of the formulas (6) x(p(x) x = a p(b)), x(q(x) x = c q(d)), a b, c d. (7) This program is not tight in the sense of (Ferraris et al. 2011). It is is atomic-tight in the sense of (Lee and Meng 2011), but it does not contain constraints corresponding to some of the Clark Equality Axioms, for instance a c. So Corollary 5 in that paper is not applicable either. In (Lifschitz and Yang 2012), we define a more general notion of tightness by referring to the new concept of a rule dependency graph and use it to prove the claim about program (6) and formulas (7). In that paper, we discuss also an example illustrating limitations of earlier work that is related to describing dynamic domains in answer set programming. The program in that example is not atomic-tight because of rules expressing the commonsense law of inertia. We show nevertheless that the process of completion can be used to characterize its stable models using a first-order formula. 6 Future Work 6.1 First-order Action Language BC Action language BC proposed in (Lee et al. 2013) is more expressive than B and C, and in many ways it is more expressive than the earlier language ADL. However, in one sense ADL is more expressive than BC : the former is based on first-order logic, and the latter is only propositional. In (Pednault 1994), state-transition models for a first-order language are defined (Definition 2.3); their states are semantic structures, or interpretations, in the sense of first-order logic. In BC, on the other hand, a state is an interpretation of a propositional structure. There are no variables in BC, strictly speaking. Expressions with variables, which are frequently used when action domains are described in BC, are merely schemas describing finite sets of static and dynamic laws that are formed according to the same pattern. In (Lifschitz and Ren 2007), the semantics of variables in C + was generalized on the basis of first-order causal logic. In the same spirit, BC will be generalized on the basis of the first-order theory of stable models proposed in (Ferraris et al. 2011). 6.2 Composite action description in BC In traditional action languages, actions are defined in terms of their preconditions and effects. But some actions can be more naturally described as sequences of primitive actions. For instance, humans think of the action fetch as to go and bring back. There are a few formalisms where

8 8 Fangkai Yang complex actions of this kind are described in terms of executing primitive actions. Languages such as GOLOG (Levesque et al. 1997), ABStrips (Sacerdoti 1973) and HTN (Erol et al. 1994) use complex actions as abstractions or aggregates to characterize the hierarchical structure of the domain and improve search efficiency. In (Inclezan and Gelfond 2011), a similar idea is implemented for language A L M. In (Chen et al. 2012a; Chen et al. 2012b), composite actions are defined for a dialect of action language C +. We will show how to incorporate composite action definitions in the language BC. Extending BC in this way will make it more expressive. It will also enable the user to characterize the hierarchical structure of the problem domain and to improve the efficiency of planning. Acknowledgements Many thanks to Vladimir Lifschitz for useful discussion and editing this note, to Amelia Harrison for proofreading, and to the anonymous reviewers who suggested helpful improvements to a draft of this note. References BABB, J. AND LEE, J Cplus2asp: Computing action language + in answer set programming. In Procedings of International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR). to appea. BALDUCCINI, M. AND GELFOND, M Diagnostic reasoning with A-Prolog. Theory and Practice of Logic Programming 3(4-5), BARTHOLOMEW, M. AND LEE, J Stable models of formulas with intensional functions. In Proceedings of International Conference on Principles of Knowledge Representation and Reasoning (KR). CASOLARY, M. AND LEE, J Representing the language of the Causal Calculator in Answer Set Programming. In Technical Communications of the 27th International Conference on Logic Programming (ICLP) CHEN, X., JIN, G., AND YANG, F. 2012a. Extending action language C + by formalizing composite actions. In Correct Reasoning, E. Erdem, J. Lee, Y. Lierler, and D. Pearce, Eds. Lecture Notes in Computer Science, vol Springer, CHEN, X., JIN, G., AND YANG, F. 2012b. Extending C + with composite actions for robotic task planning. In ICLP (Technical Communications), A. Dovier and V. S. Costa, Eds. LIPIcs, vol. 17. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, CLARK, K Negation as failure. In Logic and Data Bases, H. Gallaire and J. Minker, Eds. Plenum Press, New York, ERDOĞAN, S. T. AND LIFSCHITZ, V Actions as special cases. In Proceedings of International Conference on Principles of Knowledge Representation and Reasoning (KR) EROL, K., HENDLER, J. A., AND NAU, D. S HTN planning: Complexity and expressivity. In AAAI FAGES, F Consistency of Clark s completion and existence of stable models. Journal of Methods of Logic in Computer Science 1, FERRARIS, P A logic program characterization of causal theories. In Proceedings of International Joint Conference on Artificial Intelligence (IJCAI) FERRARIS, P., LEE, J., LIERLER, Y., LIFSCHITZ, V., AND YANG, F Representing first-order causal theories by logic programs. Theory and Practice of Logic Programming 12, 3, FERRARIS, P., LEE, J., AND LIFSCHITZ, V Stable models and circumscription. Artificial Intelligence 175,

9 Theory and Practice of Logic Programming 9 FIKES, R. AND NILSSON, N STRIPS: A new approach to the application of theorem proving to problem solving. Artificial Intelligence 2, 3 4, GEBSER, M., GROTE, T., AND SCHAUB, T Coala: a compiler from action languages to ASP. In Proceedings of European Conference on Logics in Artificial Intelligence (JELIA) GEFFNER, H Causal theories for nonmonotonic reasoning. In Proceedings of National Conference on Artificial Intelligence (AAAI). AAAI Press, GELFOND, M. AND LIFSCHITZ, V The stable model semantics for logic programming. In Proceedings of International Logic Programming Conference and Symposium, R. Kowalski and K. Bowen, Eds. MIT Press, GELFOND, M. AND LIFSCHITZ, V Classical negation in logic programs and disjunctive databases. New Generation Computing 9, GELFOND, M. AND LIFSCHITZ, V Action languages 4. Electronic Transactions on Artificial Intelligence 3, GIUNCHIGLIA, E., LEE, J., LIFSCHITZ, V., MCCAIN, N., AND TURNER, H Nonmonotonic causal theories. Artificial Intelligence 153(1 2), GIUNCHIGLIA, E. AND LIFSCHITZ, V An action language based on causal explanation: Preliminary report. In Proceedings of National Conference on Artificial Intelligence (AAAI). AAAI Press, INCLEZAN, D. AND GELFOND, M Representing Biological Processes in Modular Action Language ALM. In Proceedings of the 2011 AAAI Spring Symposium on Formalizing Commonsense. AAAI Press, LEE, J., LIFSCHITZ, V., AND YANG, F Action language BC : A preliminary report. In Proceedings of International Joint Conference on Artificial Intelligence (IJCAI). LEE, J. AND MENG, Y First-order stable model semantics and first-order loop formulas. Journal of Artificial Inteligence Research (JAIR) 42, LEVESQUE, H. J., REITER, R., LESPÉRANCE, Y., LIN, F., AND SCHERL, R. B Golog: A logic programming language for dynamic domains. J. Log. Program. 31, 1-3, LIFSCHITZ, V On the logic of causal explanation. Artificial Intelligence 96, LIFSCHITZ, V. AND REN, W The semantics of variables in action descriptions. In Proceedings of National Conference on Artificial Intelligence (AAAI) LIFSCHITZ, V., TANG, L. R., AND TURNER, H Nested expressions in logic programs. Annals of Mathematics and Artificial Intelligence 25, LIFSCHITZ, V. AND YANG, F Translating first-order causal theories into answer set programming. In Proceedings of the European Conference on Logics in Artificial Intelligence (JELIA) LIFSCHITZ, V. AND YANG, F Eliminating function symbols from a nonmonotonic causal theory. In Knowing, Reasoning, and Acting: Essays in Honour of Hector J. Levesque, G. Lakemeyer and S. A. McIlraith, Eds. College Publications. LIFSCHITZ, V. AND YANG, F Lloyd-Topor completion and general stable models. In Working Notes of the 5th Workshop of Answer Set Programming and Other Computing Paradigms (ASPOCP 2012). LIFSCHITZ, V. AND YANG, F Functional completion. Journal of Applied Non-Classical Logics 23, 1 2. LIN, F Embracing causality in specifying the indirect effects of actions. In Proceedings of International Joint Conference on Artificial Intelligence (IJCAI) LLOYD, J Foundations of Logic Programming. Springer-Verlag. MCCAIN, N Causality in commonsense reasoning about actions 5. Ph.D. thesis, University of Texas at Austin. MCCAIN, N. AND TURNER, H Causal theories of action and change. In Proceedings of National Conference on Artificial Intelligence (AAAI) ftp://ftp.cs.utexas.edu/pub/techreports/tr97-25.ps.gz

10 10 Fangkai Yang MCCARTHY, J Circumscription a form of non-monotonic reasoning. Artificial Intelligence 13, 27 39, MCCARTHY, J Applications of circumscription to formalizing common sense knowledge. Artificial Intelligence 26, 3, MCCARTHY, J. AND HAYES, P Some philosophical problems from the standpoint of artificial intelligence. In Machine Intelligence, B. Meltzer and D. Michie, Eds. Vol. 4. Edinburgh University Press, Edinburgh, MOORE, R Semantical considerations on nonmonotonic logic. Artificial Intelligence 25, 1, PEDNAULT, E ADL and the state-transition model of action. Journal of Logic and Computation 4, REITER, R A logic for default reasoning. Artificial Intelligence 13, SACERDOTI, E. D Planning in a hierarchy of abstraction spaces. In Proceedings of the 3rd international joint conference on Artificial intelligence. Morgan Kaufmann Publishers Inc.