Synthesizing and Executing Plans in Knowledge and Action Bases

(1)

Synthesizing and Executing Plans in Knowledge and Action Bases

^{? ??}

Diego Calvanese¹, Marco Montali¹, Fabio Patrizi¹, and Michele Stawowy²

1 Free University of Bozen-Bolzano, Italy, lastname@inf.unibz.it

2 IMT Lucca, Italy,

michele.stawowy@imtlucca.it

Abstract. We study plan synthesis for a variant of Knowledge and Action Bases (KABs). KABs have been recently introduced as a rich, dynamic framework where states are full-fledged description logic (DL) knowledge bases (KBs) whose extensional part is manipulated by actions that can introduce new objects from an infinite domain. We show that, in general, plan existence over KABs is undecidable even under severe restrictions. We then focus on the class of state- bounded KABs, for which plan existence is decidable, and we provide sound and complete plan synthesis algorithms, through a novel combination of techniques based on standard planning, DL query answering, and finite-state abstractions.

All results hold for any DL with decidable query answering. We finally show that for lightweight DLs, plan synthesis can be compiled into standard ADL planning.

1 Introduction

Recently, there has been an increasing interest in the study of formalisms that integrate static structural knowledge, as expressed, e.g., in description logics (DLs) [2], with action-based mechanisms, to capture a domain’s evolution over time. Combining these two aspects into a single logical system is well-known to be difficult and easily leading to undecidability, even for simple forms of inference about system dynamics, when the logics used to describe the structural properties are rather limited [25, 17]. To overcome these restrictions, a recent line of work by [5] has introduced Knowledge and Action Bases (KABs). Such systems rely on Levesque’s functional approach [21] to operate over a full-fledged DL knowledge base (KB), by means of actions: actions evolve the system by querying the current state using logical inference (ASKoperation), and then using the derived facts to assert new knowledge in the resulting state (TELLoperation).

A prominent feature of KABs is that actions allow one to incorporate into the KB external input provided by fresh objects taken from an infinite domain. This gives rise, in general, to an infinite-state system, in which reasoning is undecidable. Neverthe- less, decidability of verification of first-order temporal properties has been obtained for

?A revised version of this work has been published in the Proceedings of IJCAI 2016.

??The authors acknowledge the support of: Rip. Diritto allo Studio, Universit`a e Ricerca Scien- tifica of Provincia Autonoma di Bolzano–Alto Adige, under project VERISYNCOPATED; the EU project Optique (FP7-IP-318338); and the UNIBZ internal projects KENDO and OnProm.

1

(2)

KABs that arestate-bounded[3, 4], i.e., in which the number of objects in each single state is bounded a-priori, but is unbounded along single runs, and in the whole system.

Here, we study the problem of planning, specifically plan existence and synthesis [18, 14], for knowledge-intensive dynamic systems over infinite domains. For doing so we consider a variation of KABs, termedExplicit-Input KABs(eKABs), more suited for our purposes, in which the input-related information for an action is made explicit in its signature, and not hidden in its conditional effects. In fact, eKABs can be considered as a concrete instantiation of the more abstract framework of Description Logic-based Dy- namic Systems (DLDS) [13], and inherit its possibility of abstracting away the specific DL formalism used to capture the underlying KB.

We show that, in general, plan existence is undecidable even for severely restricted eKABs, in line with previous work on planning in rich settings [16]. We then prove decidability in PSPACE data complexity of such problem, for state-bounded eKABs, by combining techniques based on standard planning, DL query answering, and finite- state abstractions for DLDSs. In spirit, our work is similar to the one by [20], since it combines a rich knowledge-based setting with the possibility of incorporating external input during the system evolution. However, we provide the first setting we are aware of where planning stays decidable without imposing severe restrictions, in particular on how external input is handled. Additionally, we present a sound and complete plan synthesis algorithm. Notably, the plans it returns represent plan templates for the original synthesis problem, which is over an infinite domain. We then concentrate on eKABs based on lightweight DLs of the DL-Lite family [11, 9], and show that, in this case, plan synthesis can also be tackled by compilation into standard ADL, which can then be processed by any off-the-shelf ADL planner [24].

2 Description Logic Knowledge Bases

Let∆be a countably infinite universe of objects, acting as standard names [22]. A (DL) knowledge base(KB)hT, Aiconsists of a TBoxT, capturing the intensional knowledge about the domain of interest, and an ABoxA, capturing the extensional knowledge:T is a finite set of universal, first-order (FO) assertions based on concepts (unary predicates) and roles (binary relations);Ais a finite set ofassertions, orfacts, i.e., atomic formulasN(d)andP(d, d⁰), withNa concept name,Pa role name, andd, d⁰ ∈∆. By

ADOM(A)we denote the set of objects occurring inA. For details on DLs, we refer to [2]. To maintain a clear separation between the intensional and the extensional levels, we disallownominals(concepts interpreted as singletons) inT. We adopt the standard FO semantics for DL KBs. WhenhT, Aiissatisfiable, i.e., admits at least one model, we also say thatAisT-consistent. A KBhT, Ailogically impliesan ABox assertion α, writtenhT, Ai |= α, if every model of hT, Aiis also a model ofα. Two ABoxes A1andA2arelogically equivalent modulo renaming w.r.t. a TBoxT, if they imply the same assertions, up to object renaming. When this holds, we writeA1∼=^h_T A2, whereh denotes the bijection that renames the objects occurring inA1into those inA2.

We use queries to extract information from a KB. A union of conjunctive queries (UCQ)qover a KBhT, Aiis a FO formulaW

1≤i≤n∃yi.conj_i(x,yi), where conj_i(x,yi)is a conjunction of equality assertions and atoms mentioning concept/role

(3)

names ofT, with variables fromx∪y_iand objects as terms. ByANS(q, T, A)we denote the set of(certain) answersof a queryqover a KBhT, Ai, consisting of all the substitutionsθofq’s free variables with objects fromADOM(A), s.t.qθholds in every model ofhT, Ai. We also consider theECQ[10], the extension of UCQs defined as:

Q ::= [q] | ¬Q | Q₁∧Q₂ | ∃x.Q,

whereqis a UCQ. The certain answersANS(Q, T, A)of an ECQQoverhT, Aiare obtained by first computing, for each atomic ECQ [q], the certain answers ofq, and then composing the obtained answers through the FO constructs in Q, with existen- tial variables ranging overADOM(A). Hence[q]acts as aminimal knowledge operator, and negation and quantification applied over UCQs are interpreted epistemically [10].

Under this semantics, ECQs aregeneric, in the classical sense of [1]: a query evaluated over two logically equivalent ABoxes returns the same answer modulo object renaming.

As customary, we consider only DLs for which query answering (and hence the standard reasoning tasks of KB satisfiability and logical implication) is decidable. In our examples, we use the standard DL ALCQIH[2]. We also consider lightweight DLs of the DL-Lite family, in particularDL-LiteA[9], for which both checking KB satisfiability and answering ECQs over a KB areFO-rewritable[10, 9]. The latter means that every ECQQexpressed over aDL-LiteATBoxT can be effectively rewritten into a FO queryrew(Q, T)such that, for every ABoxA, the certain answersANS(Q, T, A) can be computed by directlyevaluatingrew(Q, T)overAseen as a database under the closed-world assumption. Also,T-consistency ofAcan be checked by evaluating over Aan ECQQ^T_unsat(that depends onT only).

3 Explicit-input Knowledge and Action Bases

We define Explicit-input Knowledge and Action Bases (eKABs) parametrically w.r.t. a DLL. AnL-eKABKis a tuplehC,C0, T, A₀, Λ, Γi, where: (i)C ⊆∆is the (possibly infinite)object domainofK;(ii)C₀⊂ Cis afiniteset ofdistinguished objects;(iii)Tis anL-TBox;(iv)A₀is anL-ABox all of whose objects belong toC₀;(v)Λis a finite set ofparametric actions;(vi)Γ is a finite set ofcondition-action rules. When the specific DLLis irrelevant, we omit it. We detail the latter two items below.

Aparametric actionαhas the forma(p) : {e1, . . . , en}, where:ais the action’s name,pare theinput parameters, and{e1, . . . , en}is the finite set ofconditional effects. Eacheffectei has the formQi addF_i⁺,delF_i⁻, where: (i)Qiis theeffect condition, i.e., an ECQ overT, whose terms can be action parametersp(acting as variables), additional free variablesxi, or objects fromC0; (ii)F_i⁺andF_i⁻are two sets of atoms over the vocabulary ofT, with terms fromp∪xi∪ C0. Given an actionαand a substitutionθ, assigning objects ofCtop,αθdenotes theaction instanceofαobtained by assigning values to paccording toθ. We write α(p)to explicitly name the input parameters ofα. The ABox resulting from theapplicationof an action instanceαθon an ABoxA, denotedDO(αθ, A, T), is the ABox(A\A⁻_αθ)∪A⁺_αθ, where: (i)A⁺_αθ = S

i∈{1,...,n}

S

σ∈ANS(Q_iθ,T ,A)F_i⁺σ;(ii)A⁻_αθ =S

i∈{1,...,n}

S

σ∈ANS(Q_iθ,T ,A)F_i⁻σ. Im- portantly,αθisapplicabletoAonly ifDO(αθ, A, T)is consistent withT.

Acondition-action rule (CA rule)γαfor an actionαhas the formQα(x)7→α(p), whereQαis an ECQ mentioning only objects fromC0and whose free variablesxcome

(4)

fromp. We assume that each actionαinΛhas exactly one corresponding condition- action rule γ_α in Γ (multiple rules can be combined into a single disjunctive rule).

The ECQQ_αis used to constrain the set of action instances potentially applicable to a certain Abox A. Specifically, let θ be a parameter substitution for p, and letθ[x]

denote the parameter substitution obtained by projectingθonx. Then,θis aK-legal parameter substitution inAforα, if: (i)θ : p→ C;(ii)θ[x]∈ ANS(Qα, T, A); and (iii)DO(αθ, A, T)isT-consistent. When this is the case,αθis aK-legal action instance inA. Any variable inp\xis also referred to as anexternal input parameterofα. Note that, when present, such parameters are not constrained byQαand can be assigned to any object, including fresh ones not occurring inADOM(A).

Thesemanticsof eKABs is defined in terms of transition systems (TSs) with states and transitions resp. labeled by ABoxes and action instances [13]. A TSΥ is a tuple hC, T, Σ, s0,abox,→i, where: (i) C is the object domain;(ii) T is a TBox;(iii) Σ is a (possibly infinite) set of states; (iv) s₀ ∈ Σ is the initial state; (v) abox is the labeling function, mapping states from Σ into T-consistent ABoxes with terms from C only; (vi) → ⊆ Σ ×L ×Σ is a labeled transition relation, with L the (possibly infinite) set of labels. An eKAB K = hC,C₀, T, A₀, Λ, Γigeneratesa TS Υ_K =hC, T, Σ, s₀,abox,→i, where: (i)abox is the identity function;(ii)s₀ = A₀; (iii)→ ⊆Σ×L_K×Σis a labelled transition relation withL_Kthe set of all possible action instances;(iv)Σand→are defined by mutual induction as the smallest sets s.t. if A∈Σ, then for everyK-legal action instanceαθinA, we have thatDO(αθ, A, T)∈Σ andA−^αθ−→DO(αθ, A, T). In general,Υ_Kis infinite, ifCis so.

Example 1. Consider an eKABK=hC,C0, T, A0, Λ, Γiused to support decision making in a company, where employees work on tasks.Ccontains infinitely many objects. The TBoxTis expressed inALCQIH, and contains the following axioms:Eng vEmpandTechvEmpindi- cate that engineers and technicians are employees.∃hasTask⁻vEmpand∃hasTaskvTask type thehasTaskrole, which links employees to tasks. Similar axioms can be used to express that worksInlinks employees to branches of the company.Emp v(= 1worksIn)states that employees work in one and only one branch.hasResp v(≤1Emp)andhasResp vhasTask⁻ indicate that a task may have at most one responsible, among those employees associated to that task. Finally,∃hasResp⁻v ¬Techstates that technicians cannot be responsible for tasks.

As for the dynamic aspects, to model that a new engineer can be hired in a branch provided that the planning agent does not know whether there already exists an engineer there,Khas rule

Branch(b)∧ ¬[∃x.Eng(x)∧worksIn(x, b)]7→HireEng(x, b),

where: HireEng(e, b) : {true add{Eng(e),worksIn(e, b)}}. A similar action HireTech(t, b)can be used to hire a technician. RuleTask(t)∧Emp(e) 7→ MakeResp(t, e) states that an employee can be made responsible of a task, where

MakeResp(t, e) :

hasResp(t, prev) del{hasResp(t, prev)}

true add{hasResp(t, e)}

removes the previous responsible of the selected task if there existed one, and makes the selected employee the new responsible. Finally, rule Emp(e) 7→ Anon(e)models that an employee can be anonymized, where actionAnon(e) : {worksIn(e, b) del{worksIn(e, b)}}

models anonymization by removing the explicit information on the branch to which the selected employee belongs. Note that there is a complex interplay between the TBox and the dynamic component ofK. E.g., the last TBox axioms forbids to hire a technician and make it responsible for a task. However, notice that this is not explicitly forbidden in the condition-action rule that defines the (potential) applicability of theMakeRespaction.

(5)

4 eKAB planning

LetK be an eKAB andΥ_K its generated TS. Aplan forK is a finite sequence π = α1θ1· · ·αnθnof action instances overL_K. The planπisexecutableonKif there exists a (unique) runρ=A0

α₁θ₁

−−−→A1 α₂θ₂

−−−→ · · ·−−−→^αⁿ^θⁿ AnofK. We callρthe runinduced byπandAnthefinal stateofρ. AeKAB planning problemis a pairhK, Gi, withKan eKAB andG, thegoal, a boolean ECQ mentioning only objects fromC0. A planπfor KachievesG, ifANS(G, An, T) =true, forAnthe final state of the run induced byπ.

Example 2. Given the eKAB in Example 1, a goalGcould express the intention to have an engineer and a technician working for a given taskt, provided that, for privacy reasons, it is not known to the planning agent whether the two work in the same branch. Formally:

∃e1, e2.Tech(e1)∧Eng(e2)∧hasTask(e1,t)∧hasTask(e2,t)

∧ ¬[∃b.worksIn(e1, b)∧worksIn(e2, b)]

where negation is in fact interpreted epistemically, in accordance with the semantics of ECQs.

We first considerplan existence, i.e., the problem of checking whether, for a planning problemhK, Gi, an executable planπforKexists that achievesG.

Theorem 1. LetLbe a DL for which answering ECQs³is inCONPin data complexity.

Then plan existence forL-eKABs with a finite object domain is decidable inPSPACEin the size of the object domain.

Theorem 2. Plan existence for eKABs with an infinite object domain is undecidable, even when the goal is a ground CQ, and the input eKAB has: (i) an empty TBox;

(ii) actions/rules that employ UCQs only.

We observe that the latter result is similar in spirit to an undecidability result by [16]

for the propositional case, but cannot be derived from it, and required a separate proof.

Next, we attack this undecidability result. To do so, we focus on a class of infinite- domain eKABs that enjoy the property ofstate-boundedness[3, 13, 6]. Specifically, an eKABKisb-bounded if its generated TSΥ_K =hT, Σ, s₀,abox,→iis such that for every states∈Σ, we have|ADOM(abox(s))| ≤b, that is, every state (or ABox) ofΥ_K contains at mostbdistinct objects . Note that ab-bounded eKAB still has, in general, infinitely many states. Indeed, from an infiniteC, one can obtain infinitely many distinct ABoxes, each containing a bounded number of objects.

For state-bounded eKABs, by applying [13] we get that checking plan existence is not more difficult than in the standard setting of propositional planning [8].

Theorem 3. Plan existence over stateb-bounded eKABs is decidable inPSPACEinb.

3For a significant class of DLs, UCQ-query answering is known to be inCONP in data complexity [19, 23, 12]. ECQs inherit this result, since they simply combine the certain answers returned by the embedded UCQs with the evaluation of the FO operators present in the query.

(6)

Algorithm 1Forward planning algorithm schema 1: functionFINDPLAN(Prob)

2: input:A planning problemProb

3: output:A plan that solvesProb, orfailif there is no solution

4: V :=∅ .Global set of visited states

5: returnFWSEARCH(Prob,INITIALSTATE(Prob),) 6: functionFWSEARCH(Prob,s, π)

7: input:A planning problemProb, the current states, and the sequenceπof actions that led tos

8: output:A plan that solvesProb, orfailif there is no solution

9: ifs∈V then returnfail .Loop!

10: V :=V ∪ {s}

11: ifHOLDS(GOAL(Prob),s)then returnπ 12: for allha,s⁰i ∈SUCCESSORS(Prob,s)do 13: πn:=FWSEARCH(Prob,s⁰, π·a) 14: ifπn6=failthen returnπn

15: returnfail

5 Plan Synthesis

We now focus on plan synthesis for eKABs. We first introduce a technique based on classical planning [7]. Aclassical planning domainis a tripleD=hS, A, ρi, whereS is a finite set ofstates,Ais a finite set ofactions, andρ: S×A →S is atransition function. Domain states are propositional assignments, and actions are operators that change them, according toρ. Aclassical planning problemis a tripleP =hD, s₀, Gi, whereDis a planning domain,s₀ ∈ Sis theinitial state, andG⊆Sis a set ofgoal states. A solution toPis a finite sequence of actions, calledplan, that takesDfroms₀ to a goal state, as a result of the changes made by the sequence of actions.

A problemP induces a labelled graph G = hN, Ei, where N = S andE contains a (labelled) edge s →^a s⁰ iff s⁰ = ρ(s, a). Essentially, planning algorithms amount to searching (in an effective way) for a path in G from s₀ to a goal state.

Algorithm 1 shows the schema of a basic algorithm that synthesizes a plan through a forward search on the induced graph. The auxiliary functionsINITIALSTATE(Prob),

GOAL(Prob),HOLDS(G, s), andSUCCESSORS(Prob, s)are self-explicative. Note that the schema above abstracts from the specific interpretation of states. In other words, it is applicable independently of the specific form of states and actions, once the functions above are instantiated on the case at hand. For instance, for classical planning problems P =hD, s0, GiwithD=hS, A, ρi, we haveINITIALSTATE(P) =s0,GOAL(P) =G,

HOLDS(G, s) =trueiffs∈G, andSUCCESSORS(P, s) ={ha, s⁰i |s⁰=ρ(s, a)}.

Next, we show how this schema can be used for eKABs plan synthesis. Our proposal results in an algorithm that iscorrect, i.e., that (i)terminates, (ii)preserves plan existence, and (iii)produces proper plans, i.e., if it does not fail, the output corresponds to a proper solution to the input planning problem. We stress that while we present the lifting on Algorithm 1, the same approach applies to any other, possibly optimized, algorithm. Indeed, the lifting strategy is agnostic to the search space traversal fashion.

(7)

Algorithm 2Plan synthesis for state-bounded eKABs.

1: functionFINDPLAN-EKABSB(E, b)

2: input:An eKAB planning problemE = hK, Gi, where K = hC,C0, T, A0, Λ, Γiisb- bounded andCis infinite

3: output:A plan that solvesE, orfailif there is no solution 4: n:=max{k|there isα∈Λwithkparameters}

5: pickCbsuch that

(C0⊆C ⊂ Cb

|C|b =b+n+|C0| .Abstract dom.

6: Kb:=hC,bC0, T, A0, Λ, Γi

7: returnFINDPLAN-EKABFD(hK, Gi)b

5.1 Plan Synthesis for eKABs

We consider the two classes of eKABs for which decidability of plan existence has been established in Section 4.

eKABs with Finite Domain.This case differs from classical planning in that eKABs have ABoxes as states, and they provide an implicit representation of successor states in terms of actions and condition-action rules. The former aspect requires to replace propositional entailment with ECQ query answering when checking whether the goal has been reached. The latter requires to useDOto compute a state’s successors. Specif- ically, given an eKAB planning problemE =hK, Gi, whereK=hC,C0, T, A0, Λ, Γi, with finiteC, Algorithm 1 can be instantiated as follows: (i)INITIALSTATE(E) =A0; (ii) GOAL(E) = G;(iii) HOLDS(E, A) = ANS(G, T, A);(iv)SUCCESSORS(E, A)returns the set of pairs hαθ, A⁰i, where (a) α ∈ Λ,(b) θis a K-legal parameter substitution in A for α, and (c) A⁰ = DO(αθ, A, T). We call the resulting algorithm FINDPLAN-EKABFD. By this instantiation, the search space of FINDPLAN-EKABFD is exactlyΥ_K, which is finite, so being the eKAB domain. Thus, we have:

Theorem 4. FINDPLAN-EKABFDterminates and is sound and complete.

Plan Synthesis for State-Bounded eKABs.We now consider state-bounded eKABs over an infinite object domain. In this case, the search space is potentially infinite. Thus, FINDPLAN-EKABFD is not readily applicable anymore, as termination is not guaranteed. To tackle this problem, instead of visiting the original, infinite, search space, we work on a finite-state abstraction of the eKAB. We first argue that the execution semantics of eKABs has two properties: (i)it is driven by ECQ-query answering, which is generic (cf. Section 2);(ii)all allowed configurations of external input parameters are considered when applying an action. These imply that eKABs aregeneric DLDSs in the sense of [13], which, together with state-boundedness, allows us to apply the same abstraction technique used by [13]. In particular, reachability is preserved if the infinite-state TS induced by the input eKAB is shrunk into a finite-state TS over a finite, but sufficiently large, object domain. We leverage this technique as the core of the FINDPLAN-EKABSB procedure shown in Algorithm 2, which reduces the original planning problem over an infinite search space to a classical planning problem.

It can be checked that all correctness conditions are satisfied: (i)is a consequence of Theorem 4; (ii) holds because the finite-state abstraction preserves reachability;

(8)

(iii)holds because the search space of the finite-state abstraction is contained into that of the original eKAB. Thus, we have:

Theorem 5. FINDPLAN-EKABSBterminates and is sound and complete.

Example 3. Consider again the eKABKin Example 1, together with goalGin Example 2.

Notice thatKis state-bounded, as the only way to increase the number of objects present in the system is by hiring someone, but the number of hirings is in turn bounded by the number of company branches (which is fixed once and for all in the initial state). Now assume that the initial state indicates the known existence of a main and a subsidiary branch for the company, as well as the fact that taskthas an assigned technician from the main branch:A0={Branch(main), Branch(sub),Tech(123),worksIn(123,main),hasTask(123,t)}.

A possible plan leading from A0 to a state where G holds is π1 = HireEng(452,sub) MakeResp(t,452). This plan achieves G by hiring an engineer in a different branch from that of123, with whom the engineer shares taskt. Observe, again, the interplay between the actions and the TBox: while no action explicitly indicates that452has taskt, this is implicitly obtained from the fact that such an engineer is made responsible fort.

Another, quite interesting plan achieving G is: π2 = HireEng(521,main) MakeResp(t,521) Anon(521). In this case, an engineer is hired in the same branch of technician123, and made responsible for taskt. These two actions do not suffice to achieve G, since the planning agent knows that the two employees work in the same branch. This knowledge is somehow “retracted” by anonymizing the hired engineer: after the execution of Anon(521), the planning agent still knows that521must work in some branch (this is enforced by a dedicated TBox axiom), but does not know which one, thus satisfying also the (epistemic) negative part of the goal.

5.2 Plan Templates and Online Instantiation

FINDPLAN-EKABSB returns plans with ground actions mentioning only objects inC,b as objects fromC \Cbare not used inK. Such plans can be regarded as plan templatesb from which we can obtain regular plans forK. This comes as a consequence of gener- icity, which, intuitively, implies that a plan keeps achieving a goal even if the objects mentioned in its actions are consistently renamed.

To formalize this intuition, we recast the notion of equality commitment [13] in this setting. Let B be a set of objects, andI a set of external input parameters. An equality commitment (EC)H over afinitesetS ⊆B∪Iis a partition{H1, . . . , Hn} of S s.t. eachHj contains at mostoneobject fromB. A substitution θ : I → B is compatiblewithHif: (i)for every pair of parametersi1, i2∈I, we have thati1θ=i2θ iffi1andi2 belong to the sameHj; and(ii)wheneverHjcontains an objectd∈ B, theniθ=dfor everyi∈Hj. Intuitively,θis compatible withH if it maps parameters from the same class into the same object, and parameters from different classes into distinct objects. Finally, given a finite setB⁰ ⊂ B and a substitutionθ : I → B, fix an orderingO =hd1, . . . , d_niover the setB_cur =B⁰∪IM(θ)of the objects that are either mentioned inB⁰or assigned toIbyθ. The ECH induced byθoverB⁰ (under O) is the partitionH = {H₁, . . . , H_n}, s.t., forj ∈ {1, . . . , n}: (i)H_j containsd_j iffd_j ∈ B⁰, i.e., objects mentioned byθbut not present inB⁰ are discarded; (ii)H_j containsi∈DOM(θ)iffθ(i) =d_j, i.e., all parameters mapped to the same,j-th object are included in thej-th equivalence class.

We can now state the following key result.

(9)

Algorithm 3Online instantiation of a previously returned plan template.

1: procedureONLINEEXEC(K, π)

2: input:An eKABK=hC,C0, T, A0, Λ, Γi, and a planπ=α1θ1· · ·αmθm

3: Ao:=A0 .old, effective state

4: An:=A0 .current, effective state

5: h:C0→ C0s.t.h(d) =dfor eachd∈ C0 .cur. bijection 6: fork∈ {1, . . . , m}do

7: H :=eq. commitment induced byθioverADOM(A)

8: pickθ⁰_kthat is compatible withh(H) .Agent choice

9: A⁰_o:=DO(αiθk, Ao, T) 10: A⁰n:=DO(αiθ⁰_k, An, T)

11: hn:C0∪ADOM(Ao)→ C0∪ADOM(An)s.t.

12:











hn(d) =d, ford∈ C0

hn(d) =h(d), ford∈ADOM(A⁰o)∩ADOM(Ao) hn(θk(i)) =θ_k⁰(i), foriparam. ofαk

s.t.θk(i)∈/ADOM(Ao) 13: h:=hn,Ao:=A⁰_o,An:=A⁰_n

Lemma 1. LetK =hC,C0, T, A0, Λ, Γibe a eKAB, andA1, A⁰₁two ABoxes overT such thatA1 ∼=^h_T A⁰₁for some object renamingh. Letα(p,i)be an action inΛwith external input parametersi, and θa K-legal substitution in A1 for α. LetH be the equality commitment induced byθoverADOM(A1), andH⁰=h(H)the equality commitment obtained fromH by renaming eachd∈ADOM(A₁)withh(d)∈ ADOM(A₂).

Ifθ⁰is a parameter substitution forpandicompatible withH⁰, then: (i)θ⁰is aK-legal parameter forαinA⁰₁; (ii)DO(αθ, A₁, T)∼=^h_T⁰ DO(αθ⁰, A⁰₁, T), whereh⁰extendshin such a way that for every parameteriofα, ifθ(i)6∈ADOM(A₁), thenh⁰(θ(i)) =θ⁰(i).

Intuitively, Lemma 1 states that, modulo object renaming consistent with a parameter substitution that induces the same equality commitment, the same action can be applied to two logically equivalent ABoxes. Furthermore, such action induces the same update, modulo renaming of the objects mentioned in the two ABoxes and the involved parameters. In Algorithm 3, we exploit this result to build, in an online fashion, a plan for K starting from one for K. This provides the freedom of dynamically choosingb which actual objects to use when actions are executed, provided that the choice induces the same equality commitment induced by the parameter substitution in the original plan. By Lemma 1, we obtain:

Theorem 6. LetE=hK, Gibe an eKAB planning problem. Ifπis a plan that achieves G, thenONLINEEXEC(K, π)is guaranteed to achieveGfor each possible choice.

Example 4. Consider planπ2 of Example 3. This plan can be lifted online by the planning agent as follows: when hiring the engineer, the planning agent can freely inject afreshemployee identifier in place of521, provided that the chosen identifier is then consistently used in the subsequent actions. In other words,π2acts as a blueprint for the infinite family of plans of the formHireEng(Id,main)MakeResp(t, Id)Anon(Id), whereIdis selected on-the-fly when the planning agent executesHireEng, and is such that it is different from all the objects present inA0

(10)

(this reconstructs the same equality commitment as in the case of521). All such infinite plans are guaranteed to achieveG.

6 Plan Synthesis for Lightweight eKABs

We consider plan synthesis for state-bounded eKABs over the lightweight DLDL-Lite_A [9], and devise a technique based on compilation into ADL planning [24, 15]. AnADL planning problemis a tuplehC,C0,F,A, ϕ, ψi, where: (i)Cis afinite object domain;

(ii)C0 ⊆ C is the set ofinitial objects;(iii)F is a finite set offluents, i.e., predicates whose extension can vary over time;(iv)Ais a finite set of ADL operators;(v)ϕis theinitial state, i.e., a conjunction of ground literals using predicates inFand objects inC0; and (vi)ψ is thegoal description, i.e., a closed FO formula using predicates inF and objects inC0. Each ADL operator inAis a tuplehN,x, ρ(x), ε(x)i, where:

(i) Nis thename;(ii) variablesxare the parameters; (iii) ρ(x)is theprecondition, i.e., a FO formula overF, and whose terms are quantified variables, objects inC₀, and parametersx; (iv) ε(x) is theeffect, i.e., the universal closure of a FO conjunction built from admissible components, inductively defined as follows: (a) fluent literals overF whose terms are variables, objects inC0, or parameters inx, are admissible;

(b) ifφ1(y1)andφ2(y2)are admissible, thenφ1(y1)∧φ2(y2)and∀y1.φ1(y1)are also admissible; (c)given a FO formulaφ1(y1) overF, whose terms are quantified variables, objects inC0, variablesy1, or parametersx, ifφ2(y2)is admissible and does not contain any occurrence of→nor∀, thenφ1(y1)→φ2(y2)is also admissible (this is used to tackle so-calledADL conditional effects).

Translation Procedure. We now define a syntactic, modular translation procedure

LEKAB2ADL that takes as input aDL-Lite_A-eKAB planning problem E = hK, Gi withK = hC,C0, T, A0, Λ, Γi, and produces a corresponding ADL planning problem PK=hCK,C0,FK,AK, ϕK, ψGi.

Object domain. As in Section 5, ifCis finite, so isCK. If insteadCis infinite butKis b-bounded, we fixCKto containC0plusn+bobjects fromC.

Fluents. FK is obtained by encoding concept and role names inT into corresponding unary and binary fluents. It also contains two special nullary fluents: ChkCons, distinguishingnormal execution modalityfromcheck consistency modalityofPK, and Error, marking when the consistency check fails.

Operators. AKis obtained by transforming every action inΛ, with its condition-action rule inΓ, into an ADL operator: each action’s effect produces a conditional effect in the ADL operator, and the condition-action rule its precondition. Since in ADL, FO formu- lae are directlyevaluatedover FO structures (without ontological reasoning), we have to suitably consider the contribution ofT. Indeed (cf. Section 3),T is used both during query answering and to check whether the ABox resulting from an action instance is T-consistent. We tackle both problems by relying onDL-LiteA’sFO rewritabilityof both ECQs andT-consistency checks (cf. Section 2). To embed such checks into ADL, we forceA_K to alternate between two phases: thenormal execution modality, where a “normal” ADL operator is applied, mirroring the execution of an action instance of

(11)

K; and thecheck consistency modality, where a special ADL operator checks if the obtained state isT-consistent. Alternation is realized by toggling the fluentChkCons, and activatingErrorwhen the consistency check fails, thus blocking operator application.

Technically, consider an actionα=a(p) :{e1, . . . , en}inΛand its corresponding condition-action ruleQα(x)7→a(p)inΓ. Letz =p\x. We produce a corresponding ADL operatorha,p, ρα(p), εα(p)i. Its preconditionρα(p)corresponds to the FO formularew(Qα(x), T)∧¬ChkCons∧¬Error, which leaves the external input param- eterszunconstrained. The operator effectεα(p)is the FO conjunction of the translation ofe1, . . . , en. Eachei=Qi(p,xi) addF_i⁺,delF_i⁻generates the conjunct:

rew(Q_i(p,x_i), T)→^

Pj(p,xi)∈F_i⁺

P_j(p,x_i)∧^

P_k(p,xi)∈F_i⁻

¬P_k(p,x_i)∧ChkCons

Finally, the special ADL operator used to checkT-consistency ishcheck,∅, ρchk, εchki, whereρ_chk=ChkCons, just checks whether the check flag is on, whileε_chktakes care of toggling the flag, as well as of triggering the error flag if an inconsistency is detected:

εchk=¬ChkCons∧(Q^T_unsat→Error)

Initial state specification. ϕ_Kis by constructing the conjunction of all facts contained inA0:ϕK=V

P_i(o)∈A0Pi(o).

Goal description. The goal descriptionψG is obtained from goalGinE as ψG = rew(G, T)∧ ¬ChkCons∧ ¬Error.

The two-fold contribution ofTis taken care, as in the operators, by rewritingG(via rew(G, T)) and ensuring that the ending state isT-consistent (by requiring the absence of the consistency check and error flags inψ_G).

We close by considering the following algorithm, called FINDPLAN-LEKABADL: (i)take as input aDL-LiteA-eKAB planning problemE;(ii)translateE into an ADL planning problem usingLEKAB2ADL;(iii)invoke an off-the-shelf ADL planner;(iv)if the planner returnsfail, returnfailas well;(v)if the planner returns a planπ, filter away allcheck operators fromπ, and return it as a result.

Theorem 7. FINDPLAN-LEKABADLterminates and is sound and complete.

7 Conclusion

To test the feasibility of our proposal for knowledge-intensive planning, we ran a preliminary empirical evaluation of the framework of Section 6. We considered a DL- Lite_A-eKAB over the domain of Example 1, translated it into ADL, and fed it as input via PDDL to an off-the-shelf planner (we used FastDownward⁴). We varied the diffi- culty by increasing the bound on the object domain, thus affecting the number of ground atoms for the planner. With 9 domain elements, resulting in∼2 000 atoms, a plan was found in under 1s. For 30 elements (∼300 000 atoms) a plan was found in 120s, while for 35 elements (∼1 200 000 atoms) the planner timed out. Although preliminary, we consider these result positive, given the complexity of the setting, and the fact that we did not apply any optimization. Optimizations are left for future work.

4http://www.fast-downward.org/

(12)

References

1. Abiteboul, S., Hull, R., Vianu, V.: Foundations of Databases. Addison Wesley Publ. Co.

(1995)

2. Baader, F., Calvanese, D., McGuinness, D., Nardi, D., Patel-Schneider, P.F. (eds.): The De- scription Logic Handbook: Theory, Implementation and Applications. Cambridge University Press (2003)

3. Bagheri Hariri, B., Calvanese, D., De Giacomo, G., Deutsch, A., Montali, M.: Verification of relational data-centric dynamic systems with external services. In: Proc. of PODS 2013.

pp. 163–174 (2013)

4. Bagheri Hariri, B., Calvanese, D., Deutsch, A., Montali, M.: State-boundedness in data- aware dynamic systems. In: Proc. of KR 2014. AAAI Press (2014)

5. Bagheri Hariri, B., Calvanese, D., Montali, M., De Giacomo, G., De Masellis, R., Felli, P.:

Description logic Knowledge and Action Bases. J. of Artificial Intelligence Research 46, 651–686 (2013)

6. Belardinelli, F., Lomuscio, A., Patrizi, F.: Verification of agent-based artifact systems. J. of Artificial Intelligence Research 51, 333–376 (2014)

7. Brachman, R.J., Levesque, H.J.: Knowledge Representation and Reasoning. Morgan Kauf- mann (2003)

8. Bylander, T.: The computational complexity of propositional STRIPS planning. Artificial Intelligence 69(1–2), 165–204 (1994)

9. Calvanese, D., De Giacomo, G., Lembo, D., Lenzerini, M., Poggi, A., Rodriguez-Muro, M., Rosati, R.: Ontologies and databases: TheDL-Liteapproach. In: Tessaris, S., Franconi, E.

(eds.) RW 2009 Tutorial Lectures, LNCS, vol. 5689, pp. 255–356. Springer (2009) 10. Calvanese, D., De Giacomo, G., Lembo, D., Lenzerini, M., Rosati, R.: EQL-Lite: Effec-

tive first-order query processing in description logics. In: Proc. of IJCAI 2007. pp. 274–279 (2007)

11. Calvanese, D., De Giacomo, G., Lembo, D., Lenzerini, M., Rosati, R.: Tractable reasoning and efficient query answering in description logics: The DL-Litefamily. J. of Automated Reasoning 39(3), 385–429 (2007)

12. Calvanese, D., De Giacomo, G., Lembo, D., Lenzerini, M., Rosati, R.: Data complexity of query answering in description logics. Artificial Intelligence 195, 335–360 (2013)

13. Calvanese, D., De Giacomo, G., Montali, M., Patrizi, F.: Verification and synthesis in description logic based dynamic systems. In: Proc. of RR 2013. LNCS, vol. 7994, pp. 50–64.

Springer (2013)

14. Cimatti, A., Pistore, M., Traverso, P.: Automated planning. In: Handbook of Knowledge Representation, Foundations of Artificial Intelligence, vol. 3, pp. 841–867. Elsevier (2008) 15. Drescher, C., Thielscher, M.: A fluent calculus semantics for ADL with plan constraints. In:

Proc. of JELIA 2008. LNCS, vol. 5293, pp. 140–152. Springer (2008)

16. Erol, K., Nau, D.S., Subrahmanian, V.S.: Complexity, decidability and undecidability results for domain-independent planning. Artificial Intelligence 76(1–2), 75–88 (1995)

17. Gabbay, D., Kurusz, A., Wolter, F., Zakharyaschev, M.: Many-dimensional Modal Logics:

Theory and Applications. Elsevier (2003)

18. Ghallab, M., Nau, D.S., Traverso, P.: Automated planning – Theory and Practice. Elsevier (2004)

19. Glimm, B., Lutz, C., Horrocks, I., Sattler, U.: Conjunctive query answering for the description logicSHIQ. J. of Artificial Intelligence Research 31, 151–198 (2008)

20. Hoffmann, J., Bertoli, P., Helmert, M., Pistore, M.: Message-based web service composi- tion, integrity constraints, and planning under uncertainty: A new connection. J. of Artificial Intelligence Research 35, 49–117 (2009)

(13)

21. Levesque, H.J.: Foundations of a functional approach to knowledge representation. Artificial Intelligence 23, 155–212 (1984)

22. Levesque, H.J., Lakemeyer, G.: The Logic of Knowledge Bases. The MIT Press (2001) 23. Ortiz, M., Calvanese, D., Eiter, T.: Data complexity of query answering in expressive de-

scription logics via tableaux. J. of Automated Reasoning 41(1), 61–98 (2008)

24. Pednault, E.P.D.: ADL and the state-transition model of action. J. of Logic and Computation 4(5), 467–512 (1994)

25. Wolter, F., Zakharyaschev, M.: Temporalizing description logic. In: Gabbay, D., de Rijke, M.

(eds.) Frontiers of Combining Systems, pp. 379–402. Studies Press/Wiley (1999)