Representing Hybrid Automata by Action Language Modulo Theories

07/20/2017 ∙ by Joohyung Lee, et al. ∙ Arizona State University 0

Both hybrid automata and action languages are formalisms for describing the evolution of dynamic systems. This paper establishes a formal relationship between them. We show how to succinctly represent hybrid automata in an action language which in turn is defined as a high-level notation for answer set programming modulo theories (ASPMT) --- an extension of answer set programs to the first-order level similar to the way satisfiability modulo theories (SMT) extends propositional satisfiability (SAT). We first show how to represent linear hybrid automata with convex invariants by an action language modulo theories. A further translation into SMT allows for computing them using SMT solvers that support arithmetic over reals. Next, we extend the representation to the general class of non-linear hybrid automata allowing even non-convex invariants. We represent them by an action language modulo ODE (Ordinary Differential Equations), which can be compiled into satisfiability modulo ODE. We developed a prototype system cplus2aspmt based on these translations, which allows for a succinct representation of hybrid transition systems that can be computed effectively by the state-of-the-art SMT solver dReal.



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

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

1 Introduction

Both hybrid automata [Henzinger (1996)] and action languages [Gelfond and Lifschitz (1998)] are formal models for describing the evolution of dynamic systems. The focus of hybrid automata is to model continuous transitions as well as discrete changes, but, unlike action languages, their discrete components are too simple to represent complex relations among fluents and various properties of actions. On the other hand, transitions described by most action languages are limited to discrete changes only, which hinders action languages from modeling real-time physical systems. One of the exceptions is an enhancement of action language + [Lee and Meng (2013)], which extends the original, propositional language in the paper by giu04 to the first-order level. The main idea there is to extend the propositional + to the first-order level by defining it in terms of Answer Set Programming Modulo Theories (ASPMT) — a tight integration of answer set programs and satisfiability modulo theories (SMT) to allow SMT-like effective first-order reasoning in ASP.

This paper establishes a formal relationship between hybrid automata and action language +. We first show how to represent linear hybrid automata with convex invariants by the first-order +. A further translation into SMT allows for computing them using state-of-the-art SMT solvers that support arithmetic over reals. However, many practical domains of hybrid systems involve non-linear polynomials, trigonometric functions, and differential equations that cannot be represented by linear hybrid automata. Although solving the formulas with these functions is undecidable in general, gao13satisfiability presented a novel approach called a “-complete decision procedure” for computing such SMT formulas, which led to the concept of “satisfiability modulo ODE.” 111A -complete decision procedure for an SMT formula returns false if is unsatisfiable, and returns true if its syntactic “numerical perturbation” of by bound is satisfiable, where is number provided by the user to bound on numerical errors. The method is practically useful since it is not possible to sample exact values of physical parameters in reality. The procedure is implemented in the SMT solver [Gao et al. (2013b)], which is shown to be useful for formalizing the general class of hybrid automata. We embrace the concept into action language + by introducing two new abbreviations of causal laws, one for representing the evolution of continuous variables as specified by ODEs and another for describing invariants that the continuous variables must satisfy when they progress. The extension is rather straightforward thanks to the close relationship between ASPMT and SMT: ASPMT allows for quantified formulas as in SMT, which is essential for expressing non-convex invariants; algorithmic improvements in SMT can be carried over to the ASPMT setting. We show that the general class of hybrid automata containing non-convex invariants can be expressed in the extended + modulo ODEs.

The extended + allows us to achieve the advantages of both hybrid automata and action languages, where the former provides an effective way to represent continuous changes, and the latter provides an elaboration tolerant way to represent (discrete) transition systems. In other words, the formalism gives us an elaboration tolerant way to represent hybrid transition systems. Unlike hybrid automata, the structured representation of states allows for expressing complex relations between fluents, such as recursive definitions of fluents and indirect effects of actions, and unlike propositional +, the transitions described by the extended + are no longer limited to discrete ones only; the advanced modeling capacity of action languages, such as additive fluents, statically defined fluents, and action attributes, can be achieved in the context of hybrid reasoning.

We implemented a prototype system cplus2aspmt based on these translations, which allows for a succinct representation of hybrid transition systems in language + that can be compiled into the input language of . We show that the system can be used for reasoning about hybrid transition systems, whereas other action language implementations, such as the Causal Calculator [Giunchiglia et al. (2004)], cplus2asp [Babb and Lee (2013)], and coala [Gebser et al. (2010)] cannot.

The paper is organized as follows. In Section 2, we give a review of hybrid automata to set up the terminologies used for the translations. Section 3 presents how to represent the special class of linear hybrid automata with convex invariants by + modulo theory of reals. Section 4 introduces two new abbreviations of causal laws that can be used for modeling invariant and flow conditions. Section 5 uses these new constructs to represent the general class of non-linear hybrid automata and shows how to reduce them to the input language of leading to the implementation of system cplus2aspmt, a variant of the system cplus2asp.

The proofs of the theorems and the examples of hybrid automata in the input language of cplus2aspmt can be found in the online appendix accompanying the paper at the TPLP archive [Lee et al. (2017)].

2 Preliminaries

2.1 Review: Hybrid Automata

We review the definition of Hybrid Automata [Henzinger (1996), Alur et al. (2000)], formulated in terms of a logical language by representing arithmetic expressions by many-sorted first-order formulas under background theories, such as QF_NRA (Quantifier-Free Non-linear Real Arithmetic) and QF_NRA_ODE (Quantifier-Free Non-linear Real Arithmetic with Ordinary Differential Equations). By we denote the set of all real numbers and by the set of all non-negative real numbers. Let be a set of real variables. An arithmetic expression over is an atomic formula constructed using functions and predicates from the signature of the background theory and elements from . Let be an arithmetic expression over and let be a tuple of real numbers whose length is the same as the length of . By , we mean the expression obtained from by replacing variables in with the corresponding values in . For an arithmetic expression with no variables, we say that is true if the expression is evaluated to true in the background theory.

A Hybrid Automaton consists of the following components:

  • Variables: A finite list of real-valued variables . The number is called the dimension of . We write for the list of dotted variables, representing first derivatives during a continuous change, and for the set of primed variables, representing the values at the conclusion of the discrete change. is the set of initial states. We use lower case letters to denote the values of these variables.

  • Control Graph: A finite directed graph . The vertices are called control modes, and the edges are called control switches.

  • Initial, Invariant, and Flow Conditions: Three vertex labeling functions, , , and , that assign to each control mode three first-order formulas:

    • is a first-order formula whose free variables are from . The formula constrains the initial condition.

    • is a first-order formula whose free variables are from . The formula constrains the value of the continuous part of the state while the mode is .

    • is a set of first-order formulas whose free variables are from . The formula constrains the continuous variables and their first derivatives.

  • Events: A finite set of symbols called h-events and a function, , that assigns to each edge a unique h-event.

  • Guard: For each control switch , is a first-order formula whose free variables are from .

  • Reset: For each control switch , is a first-order formula whose free variables are from .

Example 1

The figure shows a hybrid automaton for the Water Tank Example from the lecture note by lygeros04lecture, which consists of two variables , two h-events and , and two control modes . For example,

  • is .

  • is .

  • is .

  • is

A labeled transition system consists of the following components:

  • State Space: A set of states and a subset of initial states.

  • Transition Relations: A set of labels. For each label , a binary relation on the state space . Each triple is called a transition.

The Hybrid Transition System of a Hybrid Automaton is the labeled transition system obtained from as follows.

  • The set of states is the set of all such that , , and is true.

  • iff both and are true.

  • The transitions are labeled by members from .

  • , where and is an h-event in , is a transition if there is an edge such that: (1) , (2) the sentence is true, and (3) the sentence is true.

  • , where and is a nonnegative real, is a transition if there is a differentiable function , with the first derivative such that:

    1. and ,

    2. for all real numbers , is true and, for all real numbers , is true. The function is called the witness function for the transition .

2.2 Review: ASPMT and +

ASPMT [Bartholomew and Lee (2013)] is a special case of many-sorted first-order (functional) stable model semantics from the papers by ferraris11stable and by bartholomew13functional by restricting the background signature to be interpreted in the standard way, in the same way SMT restricts first-order logic.

The syntax of ASPMT is the same as that of SMT. Let be the (many-sorted) signature of the background theory . An interpretation of is called a background interpretation if it satisfies the background theory. For instance, in the theory of reals, we assume that contains the set of symbols for all real numbers, the set of arithmetic functions over real numbers, and the set of binary predicates over real numbers. Background interpretations interpret these symbols in the standard way.

Let be a signature that is disjoint from . We say that an interpretation of satisfies a sentence w.r.t. the background theory , denoted by , if there is a background interpretation of that has the same universe as , and satisfies . Interpretation is a stable model of relative to a set of function and predicate constants (w.r.t. the background theory ) if (we refer the reader to the paper by bartholomew13functional for the definition of the SM operator).

In the paper by lee13answer, action language + was reformulated in terms of ASPMT and was shown to be useful for reasoning about hybrid transition systems. Appendix A [Lee et al. (2017)] reviews this version of +.

3 Representing Linear Hybrid Automata with Convex Invariants by + Modulo Theories

3.1 Representation

Linear hybrid automata [Henzinger (1996)] are a special case of hybrid automata where (i) the initial, invariant, flow, guard, and reset conditions are Boolean combinations of linear inequalities, and (ii) the free variables of flow conditions are from only. In this section, we assume that for each from each control mode , the set of values of that makes true forms a convex region. 222A set is convex if for any and any with , we have . For instance, this is the case when is a conjunction of linear inequalities.

We show how a linear hybrid automata can be turned into an action description in , and extend this representation to non-linear hybrid automata in the next section. We first define the signature of the action description as follows.

  • For each real-valued variable in , a simple fluent constant of sort .

  • For each control switch and the corresponding , a Boolean-valued action constant .

  • An action constant Dur of sort nonnegative reals.

  • A Boolean action constant Wait.

  • A fluent constant Mode of sort (control mode).

The + action description consists of the following causal laws. We use lower case letter for denoting a real-valued variable. Let and . By , we denote the conjunction .

  • Exogenous constants:

    Intuitively, these causal laws assert that the values of the fluents can be arbitrary. The action constant Dur is to record the duration that each transition takes (discrete transitions are assumed to have duration ).

  • Discrete transitions: For each control switch :

    • Guard:

      The causal law asserts that an h-event cannot be executed if its guard condition is not satisfied.

    • Reset:

      The causal law asserts that if an h-event is executed, the discrete transition sets the new value of fluent as specified by the reset condition.

    • Mode and Duration:

      The first causal law asserts the commonsense law of inertia on the control mode: the mode does not change when no action affects it. The second causal law asserts an additional constraint for an h-event to be executable (when the state is in the corresponding mode). The third and fourth causal laws set the new control mode and the duration when the h-event occurs.

  • Continuous Transitions:

    • Wait:

      Wait is an auxiliary action constant that is true when no h-event is executed, in which case a continuous transition should occur.

    • Flow: For each control mode and for each ,


      These causal laws assert that when no h-event is executed (i.e., Wait is true), the next values of the continuous variables are determined by the flow condition.

    • Invariant: For each control mode ,


      The causal law asserts that in each state, the invariant condition for the control mode should be true.

It is easy to see from the assumption on the flow condition of linear hybrid automata that the witness function exists and is unique (); obviously it is linear.

Note that (2) checks the invariant condition in each state only, not during the transition between the states. This does not affect the correctness because of the assumption that the invariant condition is convex and the flow condition is linear, from which it follows that


is true, where is the witness function.

Figure 1 shows the translation of the Hybrid Automaton in Example 1 into +.

  ;  , , are variables of sort . are fixed real numbers Simple fluent constants: Sort:     ,          Mode      Action constants: Sort:     , , Wait     Boolean     Dur      % Exogenous constants: % Guard: % Reset: % Mode:                                 % Duration: % Wait: % Flow:    % Invariant  

Figure 1: + Representation of Hybrid Automaton of Water Tank

The following theorem asserts the correctness of the translation. By a path we mean a sequence of transitions. 333For simplicity of the comparison, as with action descriptions, the theorem does not require that the initial state of a path in the labeled transition system satisfy the initial condition. The condition can be easily added.

Theorem 1

There is a 1:1 correspondence between the paths of the transition system of a hybrid automaton  and the paths of the transition system of the action description .

The proof is immediate from the following two lemmas. First, we state that every path in the labeled transition system of is a path in the transition system described by .

Lemma 1

For any path

in the labeled transition system of , let

where each is an interpretation of fluent constants and each is an interpretation of action constants such that, for ,

  • ;

  • ;

  • if , then , , and, for all , iff ;

  • if , then , , and, for all , we have .

Then, is a path in the transition system .

Next, we show that every path in the transition system of is a path in the labeled transition system of .

Lemma 2

For any path

in the transition system of , let


  • and () are such that ;

  • () is

    • if ;

    • otherwise.

Then, is a path in the transition system of .

3.2 Representing Non-Linear Hybrid Automata using Witness Function

Note that formula (3) is not necessarily true in general even when is a Boolean combination of linear (in)equalities (e.g., a disjunction over them may yield a non-convex invariant).

Let us assume is the conjunction of formulas of the form for each , where is a Lipschitz continuous function whose variables are from only.444A function is called Lipschitz continuous if there exists such that for all ,

In this case, it is known that the witness function exists and is unique. This is a common assumption imposed on hybrid automata,

Even when the flow condition is non-linear, as long as we already know the unique witness function satisfies (3), the invariant checking can still be done at each state only. In this case, the representation in the previous section works with a minor modification. We modify the Flow representation as

  • Flow: For each and ,

    where is the witness function for such that (i) and (ii) for all reals , is true, where .

Example 2

Consider a hybrid automaton for the two bouncing balls with different elasticity.

The Flow condition for Ball is represented as

The invariant () is trivial and satisfies equation (3). So, it is sufficient to check the invariant using (2) at each state only.

However, this method does not ensure that a (non-convex) invariant holds during continuous transitions. For example, consider the problem of a car navigating through the pillars as in Figure 2, where the circles represent pillars that the car has to avoid collision with. Checking the invariants at each discrete time point is not sufficient; it could generate an infeasible plan, such as (b), where the initial position and the next position satisfy the invariant , but some positions between them, such as , do not. This is related to the challenge in integrating high-level task planning and low-level motion planning, where plans generated by task planners may often fail in motion planners.

The next section introduces new constructs in + to address this issue.

Figure 2:      (a) feasible plan                 (b) infeasible plan

4 New Abbreviations of Causal Laws for Expressing Continuous Evolutions via ODEs

In this section we introduce two new abbreviations of causal laws to express the continuous evolutions governed by ODEs.

We assume the set of fluent constants contains a set of real valued fluent constants called differentiable fluent constants, and an inertial fluent constant Mode, which ranges over a finite set of control modes. Intuitively, the values of differentiable fluent constants are governed by some ODEs controlled by each value of Mode. We also assume that Dur is an exogenous action constant of sort .

Below are the two new abbreviations related to ODEs. First, a rate declaration is an expression of the form:


where is a differentiable fluent constant, is a control mode, and is a fluent formula over . We assume that an action description has a unique rate declaration (4) for each pair of and . So, by we denote the formula in (4). The set of all rate declarations (4) for each value of Mode introduces the following causal law:


where and are real variables.

Second, an invariant law is an expression of the form


where is a fluent formula of signature .

We expand each invariant law (6) into


Notice that the causal law uses the universal quantification to express that all values of during the continuous transition satisfy the formula .

5 Encoding Hybrid Transition Systems in + Modulo ODE

5.1 Representation

In this section, we represent the general class of hybrid automata, allowing non-linear hybrid automata with non-convex invariants, in the language of + modulo ODE using the new abbreviations introduced in the previous section. As before, we assume derivatives are Lipschitz continuous in order to ensure that the solutions to the ODEs are unique.

The translation consists of the same causal laws as those in Section 3 except for those that account for continuous transitions. Each variable in hybrid automata is identified with a differentiable fluent constant. The representations of the flow and the invariant condition are modified as follows.

  • Flow: We assume that flow conditions are written as a set of for each in where is a formula whose free variables are from only, and assume there is only one such formula for each in each mode. For each and each , includes a rate declaration

    which describes the flow of each differentiable fluent constant for the value of Mode.

  • Invariant: For each , includes an invariant law

    The new always_t law ensures the invariant is true even during the continuous transition.

The above representation expresses that operative ODEs and invariants are completely determined by the current value of Mode. In turn, one can set the value of the mode by possibly complex conditions over fluents and actions.

Theorem 1 and Lemmas 1, 2 remain true even when is a non-linear hybrid automaton allowing non-convex invariants if we use this version of instead of the previous one.

5.2 Turning in the Input Language of

Since the new causal laws are abbreviations of basic causal laws, the translation by lee13answer from a + description into ASPMT and a further translation into SMT apply to the extension as well. On the other hand, system [Gao et al. (2013b)] has a non-standard ODE extension to SMT-LIB2 standard, which succinctly represents integral and universal quantification over time variables (using integral and forall_t constructs). In its language, -variables (variables ending with ) have a special meaning. is a -variable between timepoint and that progresses in accordance with ODE specified by some flow condition and is universally quantified to assert that their values during each transition satisfy the invariant condition for that transition (c.f. (7)).

To account for encoding the SMT formula obtained by the translation into the input language of , by we denote the set of formulas obtained from by

  • replacing every occurrence of in with if ;

  • replacing every occurrence of in with if and ;

  • replacing every occurrence of in with if and

for every .

The translations of the causal laws other than (4) and (6) into ASPMT and then into SMT follows the same one in the paper by lee13answer except that we use in place of . Below we explain how the new causal laws are encoded in the language of .

Let be the list for all differentiable fluent constants in . The set of rate declaration laws (4) describes a unique complete set of ODEs for each value of Mode and can be expressed in the language of as

In the language of , the integral construct

   (integral (0.  [, , ] flow_$v$))

where , , are initial values of , represents the list of values

Using the integral construct, causal law (5) is turned into the input language of as

  • if ,

    (assert (=> (and ((= mode_0 ) (= wait_0 true)))
                (= [_0_t, , _0_t]
                   (integral (0. dur_0 [_0_0,  , _0_0] flow_$v$))))
  • if ,

    (assert (=> (and ((= mode_$i$_$v$) (= wait_$i$ true)))
         (= [_$i$_t, , _$i$_t]
            (integral (0. dur_$i$ [_$(i\!-\!1)\dots$ , _$(i\!-\!1)v$))))

The causal law (7), which stands for invariant law (6), can be succinctly represented in the language of using forall_t construct as

     (assert (forall_t  [0 dur_$i$] )).

5.3 Implementation and Example

Figure 3: Architecture of system cplus2ASPMT

We implemented a prototype system cplus2aspmt, which allows us for representing hybrid transition systems in the action language +. The system supports an extension of + by adding constructs for ODE support, then translating into an equivalent ASPMT program and finally translating it into the input language of . The architecture of the system is shown in Figure 3. The system cplus2aspmt is available at

Example 3

Let us revisit the car example introduced earlier. The car is initially at the origin where and and . Additionally, there are pillars defined by the equations , , . The goal is to find a plan such that the car ends up at and without hitting the pillars. The dynamics of the car is as described by corke11robotics.

We show some part of the hybrid automaton representation in the input language of cplus2aspmt.555The complete formalization is given in Appendix C [Lee et al. (2017)]. First, fluent constants and action constants are declared as follows:

  :- constants
  x            :: differentiableFluent(real[0..40]);
  y            :: differentiableFluent(real[-50..50]);
  theta        :: differentiableFluent(real[-50..50]);
  straighten, turnLeft, turnRight   :: exogenousAction.

(In the ODE support mode, mode, wait, and duration are implicitly declared by the system.)

The derivative of the differentiable fluent constants for mode=2 (movingLeft) is declared as follows:

  derivative of x is cos(theta) if mode=2.
  derivative of y is sin(theta) if mode=2.
  derivative of theta is tan(pi/18) if mode=2.

The invariants for avoiding the collision with the bottom pillar are represented as follows:

  constraint x=X & y=Y ->> ((X-9)*(X-9) + Y*Y > 9).
  always_t (x=X & y=Y ->> ((X-9)*(X-9) + Y*Y > 9)) if mode=V.

The precondition and effects of turnLeft action are represented as follows:

  nonexecutable turnLeft if mode=2.
  turnLeft causes mode=2.
  turnLeft causes dur=

Figure 4 (a) illustrates the trajectory returned by the system when we instruct it to find a plan of length to reach the goal position. For the path of length , the system returned the trajectory in Figure 4 (b). The system could not find a plan of length because of the always_t proposition asserting the invariant during the continuous transition. If we remove the proposition, the system returns the physically unrealizable plan in Figure 2 (b).

Figure 4: Output of Car Example           (a) top: maxstep=5          (b) bottom: maxstep=3

6 Related Work

Due to space restriction, we list only some of the related work. PDDL+ [Fox and Long (2006)] is a planning description language to model mixed discrete and continuous changes. The semantics is defined by mapping primitives of PDDL+ to hybrid automata. Most PDDL+ planners assume that the continuous change is linear, while a recent paper by bryce15smt, closely related to our work, presents an SMT encoding of a PDDL+ description that is able to perform reasoning about non-linear hybrid automata. However, no dedicated translator from PDDL+ to SMT is provided. The fact that both PDDL+ and + can be turned into SMT may tell us how the two high-level languages are related to each other, which we leave for future work. In the paper by bryce15smt, the encoding was in the language of with the emphasis on extending

with planning-specific heuristics to find a valid and possibly optimized mode path. The heuristic search has not been considered in the work of

cplus2aspmt, which makes the system less scalable (see Appendix D [Lee et al. (2017)] for some experimental result).

SMT solvers have been actively used in formal verification of hybrid systems (e.g., the papers by cimatti12smt; and by alur11formal), but mostly focused on linear differential equations. is an exception.

Instead of SMT solvers, constraint ASP solvers may also be used for hybrid automata reasoning. balduccini16pddl+ shows PDDL+ primitives can be encoded in the language of constraint ASP solvers, and compared its performance with other PDDL+ computing approaches including . On the other hand, unlike our work, the encoding checks continuous invariants at discretized timepoints and no proof of the soundness of the translation is given. Constraint ASP solvers do not support -satisfiability checking. Thus, the general method of invariant checking during continuous transitions as in is not yet available there.

Action language  [Chintabathina et al. (2005), Chintabathina and Watson (2012)] is another action language that can model hybrid transitions, but its semantics does not describe the hybrid transition systems of the same kind as hybrid automata. Instead of using SMT solvers, an implementation of is by a translation into the language [Mellarkod et al. (2008)], which extends ASP with constraints. Language does not provide support for continuous evolution via ODEs and invariant checking during the continuous transition.

ASPMT is also related to HEX programs, which are an extension of answer set programs with external computation sources. HEX programs with numerical external computation have been used for hybrid reasoning in games and robotics [Calimeri et al. (2016), Erdem et al. (2016)].

7 Conclusion

We represented hybrid automata in action language modulo theories. As our action language is based on ASPMT, which in turn is founded on the basis of ASP and SMT, it enjoys the development in SMT solving techniques as well as the expressivity of ASP language. We presented an action language modulo ODE, which lifts the concept of SMT modulo ODE to the action language level.

One strong assumption we imposed is that an action description has to specify complete ODEs. This is because existing SMT solving techniques are not yet mature enough to handle composition of partial ODEs. In the paper by gao13dreal, such extension is left for the future work using new commands pintegral and connect. We expect that it is possible to extend the action language to express partial ODEs in accordance with this extension.

In our representation of hybrid automata in action language +, we use only a fragment of the action language, which does not use other features, such as additive fluents, statically determined fluents, action attributes, defeasible causal laws. One may write a more elaboration tolerant high-level action description for hybrid domains using these features.

SMT solvers are becoming a key enabling technology in formal verification in hybrid systems. Nonetheless, modeling in the low-level language of SMT is non-trivial. We expect the high-level action languages may facilitate encoding efforts.

Acknowledgements: We are grateful to Sicun Gao and Soonho Kong for their help on running and systems, to Daniel Bryce for his help with benchmark problems, and the anonymous referees for their useful comments. This work was partially supported by the National Science Foundation under Grants IIS-1319794 and IIS-1526301.


  • Alur (2011) Alur, R. 2011. Formal verification of hybrid systems. In Embedded Software (EMSOFT), 2011 Proceedings of the International Conference on. IEEE, 273–278.
  • Alur et al. (2000) Alur, R., Henzinger, T. A., Lafferriere, G., George, and Pappas, J. 2000. Discrete abstractions of hybrid systems. In Proceedings of the IEEE. 971–984.
  • Babb and Lee (2013) Babb, J. and Lee, J. 2013. Cplus2ASP: Computing action language + in answer set programming. In

    Proceedings of International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR)

    . 122–134.
  • Balduccini et al. (2016) Balduccini, M., Magazzeni, D., and Maratea, M. 2016. PDDL+ planning via constraint answer set programming. In Working Notes of the 7th Workshop on Answer Set Programming and Other Computing Paradigms (ASPOCP).
  • Bartholomew and Lee (2013) Bartholomew, M. and Lee, J. 2013. Functional stable model semantics and answer set programming modulo theories. In

    Proceedings of International Joint Conference on Artificial Intelligence (IJCAI)

  • Bryce et al. (2015) Bryce, D., Gao, S., Musliner, D., and Goldman, R. 2015. SMT-based nonlinear PDDL+ planning. In Twenty-Ninth AAAI Conference on Artificial Intelligence.
  • Calimeri et al. (2016) Calimeri, F., Fink, M., Germano, S., Humenberger, A., Ianni, G., Redl, C., Stepanova, D., Tucci, A., and Wimmer, A. 2016. Angry-HEX: an artificial player for angry birds based on declarative knowledge bases. IEEE Transactions on Computational Intelligence and AI in Games 8, 2, 128–139.
  • Chintabathina et al. (2005) Chintabathina, S., Gelfond, M., and Watson, R. 2005. Modeling hybrid domains using process description language666 In Proceedings of Workshop on Answer Set Programming: Advances in Theory and Implementation (ASP’05).
  • Chintabathina and Watson (2012) Chintabathina, S. and Watson, R. 2012. A new incarnation of action language . In Correct Reasoning, E. Erdem, J. Lee, Y. Lierler, and D. Pearce, Eds. Lecture Notes in Computer Science, vol. 7265. Springer, 560–575.
  • Cimatti et al. (2012) Cimatti, A., Mover, S., and Tonetta, S. 2012. SMT-based verification of hybrid systems. In AAAI.
  • Corke (2011) Corke, P. 2011. Robotics, vision and control: fundamental algorithms in MATLAB. Vol. 73. Springer.
  • Erdem et al. (2016) Erdem, E., Patoglu, V., and Schüller, P. 2016. A systematic analysis of levels of integration between high-level task planning and low-level feasibility checks. AI Communications 29, 2, 319–349.
  • Ferraris et al. (2011) Ferraris, P., Lee, J., and Lifschitz, V. 2011. Stable models and circumscription. Artificial Intelligence 175, 236–263.
  • Fox and Long (2006) Fox, M. and Long, D. 2006. Modelling mixed discrete-continuous domains for planning. J. Artif. Intell. Res. (JAIR) 27, 235–297.
  • Gao et al. (2013a) Gao, S., Kong, S., and Clarke, E. 2013a. Satisfiability modulo ODEs. arXiv preprint arXiv:1310.8278.
  • Gao et al. (2013b) Gao, S., Kong, S., and Clarke, E. M. 2013b. dReal: An SMT solver for nonlinear theories over the reals. In International Conference on Automated Deduction. Springer Berlin Heidelberg, 208–214.
  • Gebser et al. (2010) Gebser, M., Grote, T., and Schaub, T. 2010. Coala: A compiler from action languages to ASP. In Proceedings of European Conference on Logics in Artificial Intelligence (JELIA). 360–364.
  • Gelfond and Lifschitz (1998) Gelfond, M. and Lifschitz, V. 1998. Action languages777 Electronic Transactions on Artificial Intelligence 3, 195–210.
  • Giunchiglia et al. (2004) Giunchiglia, E., Lee, J., Lifschitz, V., McCain, N., and Turner, H. 2004. Nonmonotonic causal theories. Artificial Intelligence 153(1–2), 49–104.
  • Henzinger (1996) Henzinger, T. A. 1996. The theory of hybrid automata. In Proceedings, 11th Annual IEEE Symposium on Logic in Computer Science. 278–292.
  • Lee et al. (2017) Lee, J., Loney, N., and Meng, Y. 2017. Online appendix for the paper ”representing hybrid automata by action language modulo theories”. TPLP Archive.
  • Lee and Meng (2013) Lee, J. and Meng, Y. 2013. Answer set programming modulo theories and reasoning about continuous changes. In Proceedings of International Joint Conference on Artificial Intelligence (IJCAI).
  • Lygeros (2004) Lygeros, J. 2004. Lecture notes on hybrid systems. Tech. rep.
  • Mellarkod et al. (2008) Mellarkod, V. S., Gelfond, M., and Zhang, Y. 2008. Integrating answer set programming and constraint logic programming. Annals of Mathematics and Artificial Intelligence 53, 1-4, 251–287.

Appendix A Review: +

a.1 Syntax of +

+ was originally defined as a propositional language [Giunchiglia et al. (2004)]. In this section we review its reformulation in terms of ASPMT [Lee and Meng (2013)].

We consider a many-sorted first-order signature that is partitioned into three sub-signatures: the set of object constants called fluent constants, the set of object constants called action constants, and the background signature . The signature is further partitioned into the set of simple fluent constants and the set of statically determined fluent constants.

A fluent formula is a formula of signature . An action formula is a formula of  that contains at least one action constant and no fluent constants.

A static law is an expression of the form


where and are fluent formulas.

An action dynamic law is an expression of the form (8) in which is an action formula and is a formula.

A fluent dynamic law is an expression of the form


where  and  are fluent formulas and is a formula, provided that  does not contain statically determined constants.

A causal law is a static law, an action dynamic law, or a fluent dynamic law. An action description is a finite set of causal laws.

The formula  in causal laws (8) and (9) is called the head.

We call an action description definite if the head of every causal law (8) and (9) is an atomic formula that is -plain. 888 For any function constant , we say that a first-order formula is -plain if each atomic formula in it does not contain , or is of the form where is a list of terms not containing , and is a term not containing . For any list of predicate and function constants, we say that is -plain if is -plain for each function constant in .

a.2 Semantics of +

For a signature and a nonnegative integer , expression is the signature consisting of the pairs such that , and the value sort of is the same as the value sort of . Similarly, if is an interpretation of , expression is an interpretation of such that .

For any action description of signature and any nonnegative integer , the ASPMT program is defined as follows. The signature of is . By we denote the result of inserting in front of every occurrence of every fluent and action constant in a formula .

ASPMT program is the conjunction of

for every static law (8) in and every , and for every action dynamic law (8) in and every ;

for every fluent dynamic law (9) in and every .

The transition system represented by an action description  consists of states (vertices) and transitions (edges). A state is an interpretation of such that . A transition is a triple , where and are interpretations of and is an interpretation of , such that

The definition of the transition system above implicitly relies on the following property of transitions:

Theorem 2

[Lee and Meng (2013), Theorem 3] For every transition , and are states.

The following theorem states the correspondence between the stable models of and the paths in the transition system represented by :

Theorem 3

[Lee and Meng (2013), Theorem 4]