A Logic for Specifying Metric Temporal Constraints for Golog Programs

(1)

A Logic for Specifying Metric Temporal Constraints for Golog Programs

Till Hofmann

[email protected]

Gerhard Lakemeyer [email protected]

Knowledge-Based Systems Group RWTH Aachen University, Germany

Abstract

Executing a Golog program on an actual robot typically requires additional platform constraints to be satisfied. Such constraints are often temporal, refer to metric time, and require modifications to the abstract Golog program. Based on ES andESG, modal variants of the Situation Calculus, we propose the logict-ESG, a logic which allows the specification of metric temporal constraints forGolog programs. We provide a comparison to ESG and show that Metric Temporal Logic (MTL) can be embedded into t-ESG. We show how to formulate constraints using a model of the robot platform, and we sketch a procedure that solves those constraints using Simple Temporal Networks (STNs).

1 Introduction

While Golog[14], an agent programming language based on the Situation Calculus [15, 20], allows a clear and abstract specification of an agent’s behavior, executing aGologprogram on a real robot often creates additional issues. Typically, the robot’s platform requires additional constraints that are ignored when designing aGologprogram. As an example, a robot needs to calibrate its arm before it can use it, and it needs to enable its perception module before it inter- acts with its environment. Developers typically face two options: First, they can directly model all the platform details in the basic action theory (BAT) and

Copyright c by the paper’s authors. Copying permitted for private and academic purposes.

In: G. Steinbauer, A. Ferrein (eds.): Proceedings of the 11th International Workshop on Cognitive Robotics, Tempe, AZ, USA, 27-Oct-2018, published at http://ceur-ws.org

add respective actions to their programs, e.g., they can enable the perception before a pick action and disable it afterwards again. However, this makes the behavior specification much more complex and error- prone. If the program involves some form of planning or search, the platform details may cause performance degradation, as the search space’s size is increased by the additional actions. Additionally, most of these platform details are not specific to one particular program, but to the platform. Any change to the platform needs to be reflected in the behavior specification. As an alternative, the developers may decide to useGolog for an abstract behavior specification and deal with the platform details on the lower levels. However, this is often not possible, as platform constraints require changes to the high-level program, and thus the program cannot be clearly separated from the platform it is running on.

In this paper, we propose a different approach: As before, the agent’s behavior is specified with an abstract program. However, based on platform models as shown in Figure 1, we construct a maintenance BAT that allows to specify a set of additional constraints on the platform. The abstract plan from the original Golog program is then transformed into an executable action sequence that satisfies the platform constraints.

The main ideas of this approach were sketched in [10]. In the following, we focus on the logical foundations that allow the specification of metric temporal constraints. Our starting point is the logicESG [6], a temporal variant ofES [13], which in turn is a modal variant of the Situation Calculus. We extendESG by metric time, quantitative temporal operators similar to Metric Temporal Logic (MTL) [12], and additional temporal operatorsprevious andsince, which refer to past states in the same way asnext anduntil refer to future states. We show the relationship betweenESG andt-ESG and we provide an embedding of MTL into t-ESG. Next, we show how to describe a BAT and an

(2)

Off

Uncalibrated

Error

Calibrating Calibrated Parked

Busy start calibrate()

5s park()

move()

[0,10]s

move() Figure 1: A finite state machine as a platform model for the arm. The edges are annotated with their action and time bounds. Adapted from [10].

abstractGologprogram int-ESG and how to formulate metric temporal platform constraints witht-ESG.

Finally, we sketch how to resolve those constraints with a Simple Temporal Network (STN) to transform the abstract program into an executable action sequence.

2 Foundations & Related Work

The Situation Calculus [15, 20] is a first-order logic for representing and reasoning about actions. Action preconditions and effects are axiomatized with basic action theories and situations are histories of actions, e.g., the situation term do(pick(o1), S₀) refers to the situation after doing actionpick(o1) in the initial situation. The programming languageGolog[14] is based on the Situation Calculus and offers imperative programming constructs such as sequences of actions and iteration as well as non-deterministic branching and non-deterministic choice. The semantics of Golog and its on-line variantIndiGologcan be specified in terms of transitions [7].

The logic ES [13] is a modal variant of the Situa- tion Calculus which gets rid of explicit action terms and uses modal operators instead. As an example, [pick(o1)]Holding(o1) is satisfied iffHolding(o1) is true after doingpick(o1). The logicESG [6, 5] is a temporal extension ofESfor the verification ofGologprograms.

It specifies program transition semantics similar to the transition semantics of IndiGolog and extends ES with the temporal operatorsX (next) and U (until).

The Situation Calculus has also been extended by a notion of time. Reiter requires each actionAto have an explicit time argument, i.e., each action is of the form A(~x, t) [19]. Durative actions are modeled with start andstopactions, and the time of the last occurrence of an action can be referred bytime(A(~x, t)). Reiter also extends the Situation Calculus with concurrency, e.g., do({end pick(o1),start goto(kitchen)}, s) refers to the situation after ending the action pick(o1) and at the same time start moving to the kitchen. A similar approach is described by [18], which also allows temporal reasoning about situations. In particular, they differ- entiate betweenpossible andactual evolvements of the

current situation by adding axioms for a distinct predicate actual, where actual(s) is true iff sis an actual evolvement of the world. This differentiation is impor- tant, because otherwise, we could not express much about the future; as long as there is a possible action that causes a formula αto be false, we cannot state thatαis true in the next situation, even if the agent has no intention (e.g., it is not the next action in the Gologprogram) to execute the action. As we will see, this problem does not occur in ESG ort-ESG.

MTL [12] is an extension of Linear Time Logic (LTL) with metric time, which allows expressions such asF_≤c, meaningeventually within timec. In MTL, formulas are interpreted over timed words or timed state sequences, where each state specifies which propositions are true, and each state has an associated time value.

Depending on the choice of the state and time theory, the satisfiability problem for MTL becomes undecid- able [2]. However, for finite words, it has been shown to be decidable [16]. MTL has been restricted to Metric Interval Temporal Logic (MITL) [3], which prohibits singular intervals and is interpreted over time intervals instead of time points, which makes the satisfiability problem for MITL decidable. MTL^P[4] is an extension of MTL with temporal operators referring to the past, e.g.,V (preVious) and S (Since).

Simple Temporal Networks (STNs) [8] provide an efficient procedure to solve a constraint problem given by a set of time-points{ti}and a set of binary temporal constraints of the formt_j−t_i≤δ. Disjunctive Linear Relations (DLRs) [11] allow more expressive temporal constraints; the restricted Horn DLRs can be solved in polynomial time and still subsume STNs.

Similar to the proposed approach, Schiffer, Wort- mann, and Lakemeyer extend Golog for self- maintenance [21] by allowing temporal constraints using Allen’s Interval Algebra [1]. Those constraints are resolved on-line by interleaving the original program with maintenance actions. Closely related is also the work by [9], who propose a hybrid approach of temporal constraint reasoning and reasoning about actions based on the Situation Calculus. Similar to [21], they allow constraints based on Allen’s Interval Algebra, which are translated into a temporal constraint network.

3 Timed ESG

In this section, we present the syntax and semantics of t-ESG. As t-ESG is based on ESG, its syntax and semantics are also based onESG andES. We refer to [13, 6, 5] for more details on the original syntax and semantics.

(3)

3.1 Syntax

Definition 1(Language oft-ESG). The language consists of formulas over symbols from the following vo- cabulary:

1. object variablesx1, x2, x3, . . . , y1, . . . 2. action variablesa, a₁, a₂, a₃, . . . 3. number variablest₁, t₂, t₃, . . .

4. object standard namesNO={o1, o2, o3, . . .}

5. action standard namesNA={p1, p2, p3, . . .}

6. number standard names N_N = {0,1,2,¹₂, . . .};

here, we assumeN_N =Q

7. fluent predicates of arity k: F^k : {f₁^k, f₂^k, . . .}, e.g., Holding; we assume this list contains the distinguished predicatesPoss and<

8. rigid functions of arityk: G^k={g^k₁, g^k₂, . . .}, e.g., goto; including distinguished functions +,· ∈G²

9. fluent object functions of arity k: H^k = {h^k₁, h^k₂, . . .}, e.g.,parent

10. fluent number functions of arity k: I^k = {i^k₁, i^k₂, . . .}, e.g.,battery; including distinguished functions time∈ I¹and now∈ I⁰

11. open, closed, and half-closed intervals, e.g., [1,2], with constants of sortnumberas interval endpoints 12. connectives and other symbols: =, ∧, ∨, ¬, ∀,

XI,VI, UI, SI (with intervalI),, [·],J·K We also write F for the setS

k∈N0F^k, similarly for G,H,I. We also denote the set of standard names as N = NO ∪ NA∪ NN. Furthermore, we call a term primitive if it is of the form f(n1, . . . , nk), with f, ni

being standard names. We denote the set of primitive terms asPO(objects),PA(actions), andPN (numbers), andP =PO∪ PA∪ PN.

We read XI as next (within interval I), VI as previously (within interval I), UI as until (within interval I), and SI as since (within interval I).

Definition 2 (Terms of t-ESG). The set of terms of t-ESG is the least set such that

• every variable is a term of the corresponding sort,

• every standard name is a term of the corresponding sort,

• if t₁, . . . , t_k are terms and f is a k-ary function symbol, then f(t₁, . . . , t_k) is a term of the same sort asf.

Definition 3 (Programs).

δ::=t | α? | δ1;δ2 | δ1|δ2 | πx. δ | δ1kδ2 | δ^∗ wheret is an action term and αis a static situation formula. A program consists of primitive actionst, tests α?, sequencesδ₁;δ₂, nondeterministic branchingδ₁|δ₂, nondeterministic choice of argument πx. δ, interleaved concurrencyδ1kδ2, and nondeterministic iterationδ^∗. Definition 4 (Situation Formulas). Thesituation formulas are the least set such that

1. ift₁, . . . , t_k are terms andP is ak-ary predicate symbol, thenP(t₁, . . . , t_k) is a situation formula, 2. ift1andt2 are terms, then (t1=t2) is a situation

formula,

3. ifαand β are situation formulas,xis a variable, P is a predicate symbol,δ is a program, andφis a trace formula, thenα∧β,¬α,∀x. α,α, [δ]α, andJδKφare situation formulas.

We call a situation formula of the formP(n₁, . . . , n_k) withn_i∈ N aprimitive formula and denote the set of primitive formulas asPF.

Definition 5 (Trace Formulas). The trace formulas are the least set such that

1. ifαis a situation formula, then it is also a trace formula,

2. ifφandψ are trace formulas,xis a variable, and Iis an interval, thenφ∧ψ,¬φ,∀x. φ,XIφ,VIφ, φSIψ, andφUIψare also trace formulas.

We also write< c, ≤c, =c, > c, and ≥c for the respective intervals [0, c), [0, c], [c, c], (c,∞), and [c,∞).

We use the short-hand notation FIφ ^def= (>UIφ) (future) and GIφ ^def= ¬FI¬φ (globally), as well as PIφ ^def= (>UIφ) (past) and HIφ ^def= ¬PI¬φ (his- torically). For intervals,c+ [s, e] denotes the interval [s+c, e+c], similarly forc+(s, e),c+[s, e), andc+(s, e].

We also omit the intervalI ifI= [0,∞), e.g.,φUψis short forφU_[0,∞)ψ.

Definition 6 (Static Formulas). A situation formula αisstatic if it contains no [·],, orJ·Koperators.

Definition 7 (Bounded Formulas). A situation formula αis bounded if it contains noorJ·Koperators, and [t] operators only in case the argument is an atomic actiont.

Definition 8 (Fluent Formulas). A situation formula αisfluent if it is static and contains no predicatePoss.

(4)

3.1.1 Comparison toESG

The language of t-ESG extends the language of ESG by the constrained temporal operators XI and UI. Also,ESG has no operators referring to the past; i.e., noV or S (or their constrained variantsVI and SI).

Finally, as we understandXφ(φUψ) as short-hand notation forX_[0,∞)φ(φU_[0,∞)ψ), the language ofESG is a subset of t-ESG.

3.2 Semantics

Definition 9 (Timed Traces). Atimed trace is a pos- sibly infinite timed sequence of action standard names with monotonically non-decreasing time. Formally, a trace πis a mappingπ:N→ PA× NN, and for any i, j ∈Nwithπ(i) = (σi, ti),π(j) = (σj, tj) : If i < j, thenti ≤tj. Also, we require the sequence (ti)_i∈N to be non-Zeno, i.e., it is either finite or unbounded.

For a finite timed tracez =h(a1, t₁)·(a₂, t₂)·. . .· (ak, tk)i, we definetime(z)^def= tk, i.e.,time(z) is the time value of the last action inz. We denote the set of finite timed traces asZ, the set of infinite timed traces as Π, and the set of all traces asT =Z ∪Π.

Definition 10 (World). Intuitively, a worldwdeter- mines the truth of fluent predicates as well as the value of fluent functions, not just initially, but after any (timed) sequence of actions. Formally, a world is a mapping w that maps (1) PF × Z → {0,1}, (2) PO× Z → NO, and (3)PN× Z → NN.

Similar to ES and ESG, the truth of a fluent after any sequence of actions is determined by a world w.

Different toES andESG, we require all traces referred by a world to contain time values for each action. This also means that in the same world, a fluent predicate F(~n) may have a different value after the same sequence of actions if the actions were executed at different times, i.e.,w[F(~n,h(a1,1)i] may have a different value than w[F(~n,h(a₁,2)i].

Definition 11(Denotation of terms). Given a ground termt, a world w, and a timed tracez∈ Z, we define

|t|^z_w by:

1. ift∈ N, then|t|^z_w=t,

2. ift=now, then|t|^z_w=time(z),

3. if t = time(a(t1, . . . , tk)), then |t|^z_w = max{ta | (a(n1, . . . , nk), ta)∈z} ∪ {0}, where ni=|ti|^z_w, 4. ift=f(t₁, . . . , t_k) then|t|^z_w=w[f(n₁, . . . , n_k), z],

wheren_i=|ti|^z_w

Note the special denotation for the function symbols now ∈ I₀ andtime∈ I₁. The termnow always refers

to the current time, whiletime(A(~x)) refers to the time of the last occurrence of A(~x), or 0 if the action has never occurred.

Definition 12 (Program Transition Semantics). The transition relation →^w among configurations, given a worldw, is the least set satisfying

1. hz, ai→ hz^w ·(p, t),nili, if p=|a|^z_w, t ≥time(z), andw, z·(nil, t)|=Poss(p)

2. hz, δ1;δ₂i→ hz^w ·p, γ;δ₂i, ifhz, δ1i→ hz^w ·p, γi, 3. hz, δ1;δ2i→ hz^w ·p, δ⁰iifhz, δ1i ∈ F^wandhz, δ2i→^w

hz·p, δ⁰i

4. hz, δ1|δ2i → hz^w ·p, δ⁰i if hz, δ1i → hz^w ·p, δ⁰i or hz, δ2i→ hz^w ·p, δ⁰i

5. hz, πx. δi → hz^w ·p, δ⁰i, if hz, δ^x_ni → hz^w ·p, δ⁰i for some n∈ Nx

6. hz, δ^∗i→ hz^w ·p, γ;δ^∗iifhz, δi→ hz^w ·p, γi 7. hz, δ₁kδ₂i→ hz^w ·p, δ⁰kδ₂iifz, δ₁→ hz^w ·p, δ⁰i 8. hz, δ1kδ2i→ hz^w ·p, δ1kδ⁰iifz, δ2

→ hzw ·p, δ⁰i

The set of final configurationsF^w is the smallest set such that

1. hz, α?i ∈ F^w ifw, z|=α,

2. hz, δ1;δ2i ∈ F^wifhz, δ1i ∈ F^wand hz, δ2i ∈ F^w 3. hz, δ1|δ2i ∈ F^w ifhz, δ1i ∈ F^w, orhz, δ2i ∈ F^w 4. hz, πx. δi ∈ F^w ifhz, δ_n^xi ∈ F^w for somen∈ Nx

5. hz, δ^∗i ∈ F^w

6. hz, δ1kδ2i ∈ F^wifhz, δ1i ∈ F^wandhz, δ2i ∈ F^w The program transition semantics is very similar to the semantics ofESG. The only difference is in Rule 1, which has an additional constraint on the time, and which requires the action to be executable.

Definition 13 (Program Traces). Given a world w and a finite sequence of action standard names z, the set kδk^z_wof(timed) traces of a programδis

kδk^z_w=

{z⁰ ∈ Z | hz, δi→^w^∗hz·z⁰, δ⁰iandhz·z⁰, δ⁰i ∈ F^w}∪

{π∈Π| hz, δi→ hz^w ·π⁽¹⁾, δ₁i→ hz^w ·π⁽²⁾, δ₂i→^w . . . where for alli≤0,hz·π⁽ⁱ⁾, δii∈ F/ ^w}

Definition 14 (Truth of Situation and Trace Formu- las). Given a worldw∈ W and a situation formula α, we definew|=αasw,hi |=α, where for anyz∈ Z:

(5)

1. w, z |= F(t1, . . . , tk) iff w[F(n1, . . . , nk), z] = 1, whereni=|ti|^z_w,

2. w, z|= (t₁=t₂) iffn₁ andn₂ are identical, where n_i=|t_i|^z_w,

3. w, z|=α∧β iffw, z|=αandw, z|=β 4. w, z|=¬αiffw, z6|=α

5. w, z|=∀x. αiffw, z|=α_n^x for alln∈ Nx

6. w, z|=αiffw, z·z⁰|=αfor allz⁰ ∈ Z

7. w, z|= [δ]αiff for all finitez⁰∈ kδk^z_w,w, z·z⁰|=α 8. w, z|=JδKφiff for allτ∈ kδk^z_w,w, z, τ|=φ Intuitively, [δ]αmeans thatafter every execution ofδ, the situation formulaαis true. JδKφmeans thatduring every execution ofδ, the trace formulaφis true.

The truth of trace formulasφis defined as follows forw∈ W, z∈ Z, and τ∈ T:

1. w, z, τ |= α iff w, z |= α and α is a situation formula,

4. w, z, τ|=∀x. φiffw, z, τ|=φ^x_n for alln∈ Nx, 5. w, z, τ |=XIφiff there isp∈ PA withτ =p·τ⁰,

w, z·p, τ⁰|=φ, andtime(p)∈time(z) +I, 6. w, z, τ |= V_Iφ iff z = z⁰ ·p for some p ∈ PA,

w, z⁰, p·τ|=φ, andtime(z)∈time(z⁰) +I, 7. w, z, τ|=φU_Iψiff there is az₁such that

(a) τ=z1·τ⁰,

(b) time(z1)∈time(z) +I, (c) w, z·z₁, τ⁰|=ψ,

(d) for allz₂6=z₁ withz₁=z₂·z₃: w, z·z₂, z₃· τ⁰ |=φ

8. w, z, τ|=φSIψiff there is az1 such that (a) z=z1·z2,

(b) time(z)∈time(z₁) +I, (c) w, z₁, z₂·τ |=ψ,

(d) for allz36=hiwithz2=z3·z4: w, z1·z3, z4· τ|=φ

We shortly explain the intuitive meaning of the temporal operators:

• X_Iφis true iffφholds at the next state (i.e., after the next action), which must be within intervalI.

• VIφis true iffφholds at the previous state (i.e., before the last action), which must be within in- tervalI.

• φUIψ is true iff there is a state in the future within intervalI whereψis true, and in all states before that,φmust be true.

• φSIψis true iff there is a state in the past within intervalIwhereψis true, and in all states between that state and the current state,φmust be true.

Note that trace formulas are only interpreted over actual traces of the programδ. Thus, a formulaXαis true even if there is a possible actionathat renders α to be false, as long asadoes not occur inδ. Therefore, there is no need for a distinct predicate actual(s) as used by [18].

Definition 15 (Satisfiability). A situation formula α issatisfiable iff there is a worldwsuch that

w|=α

Definition 16 (Validity). A situation formula α is valid iff for any worldw: w|=α. We also write|=α for a valid situation formula α. A trace formula φis valid iff for any worldwand any traceτ: w,hi, τ |=φ.

We also write|=φfor a valid trace formulaφ.

4 t -ESG and ESG

In the following, we compare the first-order fragment of ESG tot-ESG. To distinguish the semantics ofESG andt-ESG, we denote the respective semantics with a subscript whenever necessary, e.g.,Zt-ESG denotes the finite traces of t-ESG. We assume a slightly different program transition semantics for ESG: For an action terma, we only allow the transitionhz, ai→ hz^w ·p,nili ifw, z|=Poss(p); the program can only transition from action ato nil if action a is currently possible. For- mally, we replace Rule 1 of theESG program transition semantics by the following rule:

1. hz, ai→ hz^w ·p,niliifp=|a|^z_w andw, z|=Poss(p) This is similar to replacing each primitive actionain a programδ byPoss(a)?;aas done by [6]. Additionally, as timeand now have a special meaning int-ESG, we assume wlog thatαdoes not mention either of them.

Apart from that, syntax and semantics of ESG are similar to t-ESG, but without constrained temporal operators (e.g., no X_I, only the unconstrained variant X), and without any past temporal operators (V and S). We refer to [6, 5] for the full ESG syntax and semantics.

Theorem 1. Let α be a first-order sentence of ESG that does not mention time or now . If|=_t_-ESGα, then also |=_ESGα.

(6)

Proof. We show that if there is an ESG world w and an ESG trace z ∈ ZESG with w, z 6|= α, then there is a t-ESG worldwt and a t-ESG trace zt ∈ Zt-ESG with w_t, z_t6|=α.

Letwbe anESG world andz=ha1, . . . , a_ki ∈ ZESG

such that w, z 6|= α. We construct w_t and z_t with w_t, z_t |= α iff w, z |= α as follows: Let w_t be a t-ESG world such that for every ρ ∈ P and every z_t⁰ =h(a⁰₁, t⁰₁),(a⁰₂, t⁰₂), . . . , a⁰_j, t⁰_j

i:

wt[ρ,h(a⁰₁, t⁰₁),(a⁰₂, t⁰₂), . . . , a⁰_j, t⁰_j i]

=w[ρ,ha⁰₁, a⁰₂, . . . , a⁰_ji]

In other words,wtagrees withwon any primitive fluent after any sequence of actions irrespective of the time.

Additionally, we set z_t = h(a1,1),(a₂,2), . . .(a_k, k)i.

First, we need to show that |p|^z_w=|p|^z_w^t_t for any term poccurring inα. We do this by induction overp:

• Letp∈ N. Then|p|^z_w=|p|^z_w^t_t =t.

• Letp=f(p1, . . . , pl).

Then, by definition of| · |,|p|^z_w=w[f(n1, . . . , nl)z]

with ni = |pi|^z_w. By induction, |pi|^z_w^t_t = |pi|^z_w, and thus |pi|^z_w^t_t = n_i. Also, by definition of w_t,w_t[f(n₁, . . . , n_l), z_t] =w[f(n₁, . . . , n_l), z], and thus|p|^z_w^t

t =|p|^z_w.

Note thatpcannot mentionnow because αdoes not mentionnow.

Now, we show by induction over αthatwt, zt|=α iffw, z|=α.

• Let α = F(p₁, . . . , p_l). As shown:

|p_i|^z_w^t

t = |p_i|^z_w. Therefore, by definition of w_t,w_t[F(p₁, . . . , p_l), z_t] =w[F(p₁, . . . , p_l), z], and thuswt, zt|=αiffw, z|=α.

• Letα= (p1=p2). With|pi|^z_w^t_t =|pi|^z_w, it follows that |p1|^z_w^t_t = |p2|^z_w^t_t iff |p1|^z_w = |p2|^z_w, and thus wt, zt|=αiffw, z|=α.

• Letα=¬β. By induction: wt, zt|=βiffw, z|=β.

• Let α = ∀x. α. By induction, for each n ∈ Nx: wt, zt |= α^x_n iff w, z |= α^x_n. As ESG and t-ESG use the same standard namesNx, it follows that wt, zt|=αiffw, z|=α.

• Let α=β. Assumew, z 6|=α. Then there is a z⁰∈ Z_ESG withw, z·z⁰6|=β. Letz⁰=ha⁰₁, . . . , a⁰_ji.

Then, we setz⁰_t=h(a⁰₁, k+ 1), . . . , a⁰_j, k+j i ∈ Z_t-ESG. By induction,w_t, z_t·z_t⁰ 6|=β.

For the other direction, assume wt, zt 6|= α.

Then there isz⁰_t=h(a⁰₁, k+ 1), . . . , a⁰_j, k+j i ∈ Zt-ESGwithwt, zt·z⁰_t6|=β. By induction, it follows that forz⁰=ha⁰₁, . . . , a⁰_ji: w, z·z⁰ 6|=β.

Therefore,w, z|=β iffw_t, z_t|=β.

• Letα= [δ]β. First, note that

kδk^z_w^t_t ={h(a⁰₁, t⁰₁),(a⁰₂, t⁰₂), . . . , a⁰_j, t⁰_j

i | (1) ha⁰₁, a⁰₂, . . . , a⁰_ji ∈ kδk^z_w,

ti ∈ NN, t1≥time(zt),fori < j:ti≤tj} This follows from the fact that the program transition semanticsk · kdiffers fromESG tot-ESG only in Rule 1, where we add a constraint on time. Asα does not mentionnow ortime, the additional constraint only enforces monotonically non-decreasing time.

Now, assume there isz⁰ =ha⁰₁, . . . , a⁰_li ∈ kδk^z_wwith w, z·z⁰ 6|= β. Then z_t⁰ = h(a⁰₁, t⁰), . . . ,(a⁰_l, t⁰)i ∈ kδk^z_w^t_twitht⁰=time(z). By induction,wt, zt·z⁰_t6|= β.

For the other direction, assume there is z_t⁰ = h(a⁰₁, t⁰₁), . . . ,(a⁰_l, t⁰_l)i ∈ kδk^z_w^t

t withw_t, z_t·z_t⁰ 6|=β.

Thenz⁰ =ha₁, . . . , a_li ∈ kδk^z_w and by induction:

w, z·z⁰6|=β. Thus,w, z|= [δ]β iffw_t, z_t|= [δ]β.

• Let α = JδKβ. First, note that Equation 1 also holds for infinite traces.

Let τ ∈ kδk^z_w be an arbitrary trace with τ = ha⁰₁, a⁰₂, . . .i, then τt = h(a⁰₁, t⁰₁),(a⁰₂, t⁰₂), . . .i ∈ kδk^z_w^t_t for arbitrary ti with the constraints from Equation 1. We show by sub-induction over φ:

w, z, τ|=φiffwt, zt, τt|=φ.

– Let φ=β be a situation formula. Then by induction: w, z|=β iffwt, zt|=β.

– Letφ=φ1∧φ2. As in the case for the situation formula, the semantics of the connective

∧do not differ betweenESG andt-ESG.

– Letφ=¬ψ. By sub-induction: w, z, τ |=ψ iffwt, zt, τt|=ψ.

– Let φ = ∀x. ψ. Again, as ESG and t-ESG use the same standard names, we can fol- low by sub-induction: N_x, w, z, τ |= ψ^x_n iff w_t, z_t, τ_t|=ψ^x_n for everyn∈ N_x.

– Let φ = Xψ. Assume w, z, τ |= Xψ.

There is p ∈ PA with τ = p · τ⁰ such that w, z · p, τ⁰ |= ψ. Then there is a t_p ≥time(z_t) such that τ_t= (p, t_p)·τ_t⁰. By induction, w_t, z_t·(p, t_p), τ⁰ |= ψ. Further- more, int-ESG, X is short-hand forX_[0,∞). As t_p ∈ time(z_t) + [0,∞), it follows that w_t, z_t, τ_t|=Xψ.

(7)

Now, assume wt, zt, τt |= Xψ. There is p ∈ NA with τt = (p, tp)· τ_t⁰ such that tp ≥time(zt) andwt, zt·(p, tp), τ_t⁰ |=ψ. By Equation 1, there is aτ⁰ =ha⁰₁, . . .isuch that τ =p·τ⁰ and τ_t⁰ =h(a⁰₁, t⁰₁), . . .i. Then, by induction: w, z·p, τ⁰|=ψ.

– Let φ=ψ₁Uψ₂. First, note that int-ESG, U stands for U_[0,∞), thus there are no constraints on the time. Similar to the previous case, we can construct pairs (zi, zt,i), such that w, z·zi, τ⁰ |= ψ iff wt, zt·zt,i, τ_t⁰ |= ψ, same for φ. Thus, by induction, w, z, τ |= φUψiffwt, zt, τt|=φUψ.

Note that the other direction of the theorem is not true; a valid sentence inESG is not necessarily valid in t-ESG. As an example, consider the sentence

α= [A]F∨[A]¬F

InESG,αis valid, because for eachw, eitherw|= [A]F orw|= [A]¬F, asw[F,hAi] is either 0 or 1. However, int-ESG,αis not valid. Consider a worldw_t oft-ESG withw[F,h(A,0)i] = 0 and w[F,h(A,1)i] = 1, i.e., if A is performed at time 0, then F is false, but if it is performed at time 1, thenF is true. Thus,w6|= [A]F, but also w6|= [A]¬F, and thereforew6|=α.

5 t -ESG and MTL

We show that MTL is part of t-ESG. We do this by translating a timed wordρof MTL into ant-ESG world w. First, we summarize MTL and its pointwise semantics following the notation by [17].

Definition 17 (Formulas of MTL). Given a setP of atomic propositions, the formulas of MTL are built as follows:

φ::=p | ¬φ | φ∧φ | φUIφ

Definition 18 (Pointwise semantics of MTL). Given an alphabet of events Σ, a timed wordρis a finite or infinite sequence (σ0, τ0) (σ1, τ1). . .whereσi∈Σ and τi∈R+ such that the sequence (τi) is monotonically non-decreasing¹and non-Zeno.

Theorem 2. Letφbe a sentence of MTL. Then|=_t-ESG φiff |=MTLφ.

1Some variants of MTL require (τi) to be strictly increasing, which can be represented int-ESGby requiring strictly increasing traces.

Proof. We assume wlog that P ⊆ F⁰, i.e., atomic propositions of MTL are 0-ary fluents oft-ESG. Given at-ESG worldwand a traceπ, we construct a timed wordρsuch thatw,hi, π|=_t_-ESGφiffρ|=MTLφ, and vice versa.

⇒: Letwbe at-ESGworld andπa trace. We construct the timed wordρ= (σ, τ) as follows:

1. Setτ0= 0 andσ0[p] =w[p,hi] for everyp∈P.

2. For everyi∈ N: Forπ(i) = (ai, ti), set τi=ti. 3. For every finite prefixzi =h(a1, t1), . . . ,(ai, ti)i

ofπand everyp∈P, set σi[p] =w[p, zi].

We show thatw, z_i, π|=_t-ESGφiffρ, i|=φby induction overφ.

• Let φ = p_i be an atomic formula. The claim follows by definition ofρ.

• Letφ=¬ψ. By induction,w, zi, π|=ψiffρ, i|= ψ, so the claim follows.

• Let φ=φ1∧φ2. By induction, w, zi, π |=φ1 iff ρ, i|=φ1, same forφ2.

• Letφ=φ₁U_Iφ₂.

First, assumew, z_i, π|=φ₁U_Iφ₂. Then there is a z_jwithπ=z_j·π⁰such thattime(z_j)∈time(z_i)+I, w, z_i·z_j, π⁰ |= φ₂, and for all z_k 6=z_j withz_j = zk·zl: w, zi·zk, zl·π⁰|=φ1. Then, by definition of ρ: ρ, i+j |= φ2, τj ∈ I, and for all k with i < i+k < i+j,ρ, i+k|=φ1. Thus, by definition of MTL’s UI: ρ, i|=φ1UIφ2.

Now, assume ρ, i |= φ1UIφ2. Similar to the previous case: There is a j with i < j < |ρ|, ρ, j|=φ2,τj−τi∈I, and for allkwithi < k < j:

ρ, k |= φ1. Then, by definition of ρ, there is a zj with π=zj·π⁰ and: w, zi·zj, π⁰ |= φ1. Fur- thermore,time(z_i·z_j)∈time(z_i) +I, and for all z_k 6= z_j withz_j = z_k·z_l: w, z_i·z_k, z_l·π⁰ |=φ₂. Thus,w, z_i, π|=φ₁U_Iφ₂.

⇐: Given a timed wordρ= (σ, τ), we construct the worldwand traceπas follows:

1. π(i) = (a, τi)

2. w[p,hi] =σ0[p] for everyp∈P

3. w[p,h(a, τ1),(a, τ2), . . . ,(a, τi)i] =σi[p] for every i∈Nand everyp∈P

Analogously to above, we show thatw, z_i, π|=_t-ESGφ iffρ, i|=φby induction overφ.

(8)

6 Basic Action Theories

Similarly to ES andESG, at-ESG BAT is a set of sentences describing the initial situation and the agent’s actions with their preconditions and effects.

Definition 19 (Basic Action Theory). Given a set of fluent predicates F, a set Σ ⊆t-ESG of sentences is called abasic action theory overF iff Σ = Σ0∪Σpre∪ Σpost, where Σ mentions only fluents inF and

1. Σ0 is any set of fluent sentences,

2. Σ_preis a set of fluent formulas with free variable a,

3. Σ_post is a set of sentences, with one sentence of the form[a]f(~x) ≡ γ_f for each fluent predicate f ∈ F, and one sentence of the form [a]f(~x) = v ≡ γ_f for each f ∈ H ∪ I, and where γ_f is a fluent formula.

In a BAT, Σ0 describes the initial situation, Σpost

is a set of successor state axioms, and Σpreis a set of precondition axiom for all actions in the domain that is understood disjunctively, i.e., from Σpre, we construct a single precondition axiom of the form Poss(a)≡ WΣpre. This is slightly different to ES and ESG and allows us to combine multiple basic action theories.

6.1 A Simple Carrier Robot

We present a BAT of a simple robot that can move around and pick up and put down objects. All actions are modeled as durative actions with start andstop actions.

Σ_pre={

∃s, g. a=start goto(s, g) (2)

∧ ¬∃a⁰.Performing(a⁰),

∃s, g. a=end goto(s, g)∧ (3) Performing(goto(s, g))∧

now≥time(goto(s, g)) +d(s, g),

∃o, l. a=start pick(o)∧ (4) RobotAt(l)∧At(o, l),

∃o. a=end pick(o)∧ (5)

Performing(pick(o))∧

now≥time(pick(o)) + 3,

∃o, l. a=start put(o, l)∧ (6) Holding(o)∧RobotAt(l),

∃o, l. a=end put(o, l)∧ (7) Performing(put(o, l))∧

now≥time(put(o, l)) + 2 }

The precondition axiom states that the robot can (2) start goto if it is currently not performing any action, (3) stopgoto (and reach its destination) if it was moving at leastd(s, g) time units, (4) start picking an object if it as the same location as the object, (5) end picking an object if it started picking at least 3 time units ago, (6) start putting an object to a location if it is holding the object and it is at the location, (7) end putting an object if it started putting at least 2 time units ago. Additionally, ending any action is only possible if the robot is currentlyperforming the action.

The robot’s actions have effects on the following predicates:

[a]RobotAt(l) ≡ (8)

∃s. a=end goto(s, l))∨

RobotAt(l)∧ ¬∃s⁰, g⁰. a=start goto(s⁰, g⁰)

[a]At(o, l) ≡ (9)

a=end put(o, l)∨At(o, l)∧a6=start pick(o)

[a]Holding(o) ≡ (10)

a=end pick(o)∨

Holding(o)∧a6=start pick(o)

[a]Performing(a⁰) ≡ (11)

a=a⁰∧

∃s, g[a=start goto(s, g)]∨

∃o[a=start pick(o)]∨

∃o[a=start put(o)]

∨Performing(a⁰)∧

¬∃s, g[a=end goto(s, g)]∧

¬∃o[a=end pick(o)]∧

¬∃o[a=end put(o)]

The successor state axioms state that (8) the robot is at location l if it stops doing agoto withl as goal location, or if it was at that location and did not start moving anywhere else, (9) an object o is at location l if the robot ends putting otol or if the object was there before and is not being picked up, (10) the robot is holding object o if ends picking up o or if it was holding the object before and does not start putting it down, (11) the robot is performing actiona⁰ if it starts a⁰ or it has been performinga⁰ and does not enda⁰.

As usual inGolog, we definewhile andif then elseas macros:

whileφdoδdone ^def= (φ?;δ)^∗;¬φ?

if φthenδ1elseδ2fi^def= [φ?;δ1]|[¬φ?;δ2] if φthenδ1fi^def= if φthenδ1elsenil fi The BAT already allows us to define simpleGolog

(9)

if ¬RobotAt(table)then

πs.start goto(s,table);end goto(s,table) fi

while ∃oAt(o,table)do πo.At(o,table)?;

start pick(o);end pick(o);

start goto(table,shelf);end goto(table,shelf);

start put(o,shelf);end put(o,shelf);

start goto(shelf,table);end goto(shelf,table);

done

Listing 1: An abstract program to clear all objects from the table.

programs. The program shown in Listing 1 picks up all objects from the table and puts them onto the shelf.

Given the following initial situation:

Σ0={RobotAt(shelf), At(obj1,table), At(obj3,shelf),

d(shelf,table) = 20, d(table,shelf) = 20,

∀o.(o6=obj1∧o6=obj3)⊃ ¬∃l.At(o, l)}

We can infer that:

Σ|= [δ]¬∃o.At(o,table) Σ|= [δ]RobotAt(table)

Following the program transition semantics, one possible successful trace ofδis:

z=h(start goto(table),0),(end goto(table),20), (start pick(obj1),20),(end pick(obj1),23), (start goto(shelf),23),(end goto(shelf),43), (start put(obj1),43),(end put(obj1),45)i

7 Timed Temporal Constraints

Listing 1 already shows an abstract program that clears the table. However, to execute the program on a real robot, additional constraints must be satisfied, e.g., the robot’s perception module needs to be enabled before an object is picked up or put down. Instead of encoding this in the abstract BAT, we provide an additional maintenance BAT which takes care of these kinds of constraints. Such a maintenance BAT may be generated from platform models as shown in Figure 1,

a simplified version may look as follows:

Σ^M_pre={

a=start calibration∧ (12) state(arm)6=calibrating∧

state(arm)6=calibrated,

a=end calibration∧ (13) time(start calibration)≥5∧ state(arm) =calibrating,

a=start perception∧ (14) state(perception)6=running

a=stop perception∧ (15) state(perception) =running}

[a]state(arm) =s ≡ (16)

a=start calib∧s=calibrating∨ a=end calib∧s=calibrated∨ s=state(arm)∧

a6=start calib∧a6=end calib

[a]state(perception) =s ≡ (17)

a=start perception∧s=running ∨ a=stop perception∧s=paused ∨ s=state(perception)∧

a6=start perception∧a6=stop perception

Σ^M₀ ={state(arm) =uncalibrated state(perception) =paused}

Using the maintenance BAT, we can formulate a set of additional constraints that must be satisfied during the execution of any programδ:

JδKG

∃o.Performing(pick(o)) (18)

⊃state(arm) =calibrated

JδKG

∃o, l.Performing(put(o, l)) (19)

⊃state(arm) =calibrated

JδKG

∃o.Performing(pick(o)) (20)

⊃H≤1state(perception) =running

JδKG

¬F≤1∃o, l.(Performing(pick(o)) (21)

∨Performing(put(o, l)))

⊃state(perception) =paused)

The constraints state that (18) if the robot is performing apick action, then the arm must be calibrated, (19) if the robot is performing a put action, then the

(10)

arm must be calibrated, (20) if the robot is performing apick action, then the perception must have been running for at least 1 second, (21) if the robot is not performing a pick orput action in the next second, then the perception should bepaused.

start start goto(table)

end goto(table)

start pick(o1)

end pick(o1)

start goto(shelf)

end goto(shelf) [20,∞]

[3,∞]

[20,∞]

Figure 2: The initial STN.

7.1 The Constraint Language

As constraint language, we allow a subset oft-ESG.

Definition 20 (Constraint). Given a BAT Σ and a maintenance BAT Σ^M. Letφbe a fluent trace formula only mentioning terms from Σ. Letψbe a fluent trace formula only mentioning terms from Σ^M. Then the formulaθ=φ⊃ψis a constraint formula.

Intuitively, we interpret a constraintφ⊃ψ as follows: Asφis from the abstract BAT and we can only add actions from Σ^M to our action sequence,φis given.

Therefore, if φ is true, we need to add maintenance actions such that ψ is also satisfied. In other words, we cannot satisfy a constraint by makingφfalse.

Definition 21 (Constraint Satisfaction). Given a program δ and a BAT Σ, we say that a constraint θ is satisfied byδ iff

Σ|=JδKGθ

7.2 Solving Timed Temporal Constraints Using the example above, we now sketch a procedure that modifies a given action sequence of an abstract program to also satisfy the platform constraints. First, we convert the action sequence into a STN, where each action of the sequence is a node in the STN. Such a STN for the program in Listing 1 is shown in Figure 2.

For each node starting at the start node, we now check whether each constraint is satisfied. As an

start start goto(table)

end goto(table)

start pick(o1)

end pick(o1)

start goto(shelf) end goto(shelf) [20,∞]

[3,∞]

[20,∞]

end calibrate start calibrate

start perception

stop perception [5,∞]

[1,∞]

[0,0]

Figure 3: The STN after all constraints have been checked and respective maintenance actions have been added.

example, in the node start pick(o1), Constraint 18 is not satisfied. From the platform models, we can generate an action sequence that satisfies the constraint. In our example, by searching the state au- tomaton in Figure 1, we can generate the sequence hstart calibrate,end calibratei, which is then added to the STN. Similarly, the perception needs to be running before doing apick. Thus, the actionstart perception is added to the STN. By Constraint 20, the perception must have been running for at least 1 second. Thus, the edge from start perception to start pick(o1) has the time constraint [1,∞]. The resulting STN after checking all STN nodes and all constraints is shown in Figure 3.

8 Conclusion

We presented t-ESG, a logic for reasoning about actions that allows the specification of metric temporal constraints. t-ESG extendsESG with metric time and temporal operators referring to the past. We showed that Metric Temporal Logic (MTL) can be embedded intot-ESG, whileESG cannot be fully embedded into t-ESG.We presented a constraint language for specifying metric temporal constraints on a platform model, and we sketched a translation of those constraints into Simple Temporal Networks (STNs). Using the solu- tion of the STN, the abstractGologprogram can be transformed into an action sequence that is executable on the robot platform, thereby allowing the separation of the abstract agent behavior specification and the details of the platform, even if they are inter-dependent.

(11)

Acknowledgements

T. Hofmann was supported by the German National Science Foundation (DFG) under grant number GL- 747/23-1.

References

[1] James F Allen. Maintaining Knowledge About Temporal Intervals. Communications of the ACM, 26(11):832–843, 1983.

[2] R. Alur and T.A. Henzinger. Real-Time Logics:

Complexity and Expressiveness. Information and Computation, 104(1):35–77, 1993.

[3] Rajeev Alur, Tom´as Feder, and Thomas A. Hen- zinger. The Benefits of Relaxing Punctuality.Jour- nal of the ACM, 43(1), 1996.

[4] Rajeev Alur and Thomas A. Henzinger. Back to the Future: Towards a Theory of Timed Regular Languages. In Proceedings of the 33rd Annual Symposium on Foundations of Computer Science, pages 177–186, 1992.

[5] Jens Claßen. Planning and Verification in the Agent Language Golog. PhD thesis, RWTH Aachen University, 2013.

[6] Jens Claßen and Gerhard Lakemeyer. A Logic for Non-Terminating Golog Programs. InProceedings of the 11th International Conference on Principles of Knowledge Representation and Reasoning (KR), pages 589–599, 2008.

[7] Giuseppe De Giacomo, Yves Lesp´erance, Hector J Levesque, and Sebastian Sardina. IndiGolog: A High-Level Programming Language for Embedded Reasoning Agents. InMulti-Agent Programming.

Springer, 2009.

[8] Rina Dechter, Itay Meiri, and Judea Pearl. Tem- poral Constraint Networks. Artificial Intelligence, 49(1-3):61–95, 1991.

[9] Alberto Finzi and Fiora Pirri. Representing Flexi- ble Temporal Behaviors in the Situation Calculus.

InProceedings of the 19th International Joint Con- ference on Artificial Intelligence (IJCAI), pages 436–441, 2005.

[10] Till Hofmann, Victor Matar´e, Stefan Schif- fer, Alexander Ferrein, and Gerhard Lakemeyer.

Constraint-Based Online Transformation of Ab- stract Plans into Executable Robot Actions. In AAAI Spring Symposium: Integrating Representa- tion, Reasoning, Learning, and Execution for Goal Directed Autonomy, 2018.

[11] Peter Jonsson and Christer B¨ackstr¨om. A Unify- ing Approach to Temporal Constraint Reasoning.

Artificial Intelligence, 102(1):143–155, 1998.

[12] Ron Koymans. Specifying Real-Time Properties with Metric Temporal Logic. Real-Time Systems, 2(4):255–299, 1990.

[13] Gerhard Lakemeyer and Hector J Levesque. Situ- ations, Si! Situation Terms, No! InProceedings of the 9th International Conference on Principles of Knowledge Representation and Reasoning (KR), pages 516–526, 2004.

[14] Hector J. Levesque, Raymond Reiter, Yves Les- perance, Fangzhen Lin, and Richard B. Scherl.

GOLOG: A Logic Programming Language for Dy- namic Domains. Journal of Logic Programming, 31(1-3), 1997.

[15] John McCarthy. Situations, Actions, and Causal Laws. Technical report, Stanford University, 1963.

[16] J. Ouaknine and J. Worrell. On the Decidability of Metric Temporal Logic. 20th Annual IEEE Symposium on Logic in Computer Science (LICS’

05), pages 188–197, 2005.

[17] Jo¨el Ouaknine and James Worrell. Some Recent Results in Metric Temporal Logic. Lecture Notes in Computer Science, 5215 LNCS:1–13, 2008.

[18] Javier Pinto and Raymond Reiter. Reasoning About Time in the Situation Calculus. Annals of Mathematics and Artificial Intelligence, 14(2- 4):251–268, 1995.

[19] Raymond Reiter. Natural Actions, Concurrency and Continuous Time in the Situation Calculus.

InProceedings of the 5th International Conference on Principles of Knowledge Representation and Reasoning (KR), pages 2–13, 1996.

[20] Raymond Reiter. Knowledge in Action: Logical Foundations for Specifying and Implementing Dy- namical Systems. MIT Press, 2001.

[21] Stefan Schiffer, Andreas Wortmann, and Gerhard Lakemeyer. Self-Maintenance for Autonomous Robots controlled by ReadyLog. InProceedings of the 7th IARP Workshop on Technical Challenges for Dependable Robots, 2010.