## 2 Preliminaries  
ASP is a declarative programming paradigm based on logic programming under the answer set semantics. An ASP program \(\Pi\) is a set of rules of the following form:  
\[c\gets a_{1},\ldots,a_{m},\ not\ b_{1},\ldots,\ not\ b_{n} \tag{1}\]  
where \(c\), \(a_{i}\)'s, and \(b_{i}\)'s are first-order literals and do \(not\) represent (default) negation.Intuitively, a rule states that if \(a_{i}\)s are believed to be true and none of the \(b_{i}\)s are believed to be true, then \(c\) must be true. \(c\) is called the _head_ of the rule and \(a_{1},\ldots,a_{m}\), \(not\ b_{1},\ldots,\ not\ b_{n}\) is its body. Additionally, given a rule \(r\), \(r^{+}\) and \(r^{-}\), respectively, called the _positive_ and _negative_ body, denote the sets \(\{a_{1},\ldots,a_{m}\}\) and \(\{b_{1},\ldots,b_{n}\}\). If the body of a rule is absent, the rule is called _fact_, its head is always true, and the \(\leftarrow\) symbol is omitted. If the head of a rule is absent, then the rule is called _constraint_ (or denial), and its body is never allowed to be satisfied. A rule that contains first-order variables is called _non-ground_ and it is considered to be a shortcut for the set of its ground instances, i.e., the _ground rules_ that can be obtained by replacing the variables by all possible ground terms of the language. The semantics of ASP programs, discussed next, is thus given in terms of ground programs, i.e., sets of ground rules. Let \(\Pi\) be a ground program. An interpretation \(I\) of \(\Pi\) is a set of ground literals occurring in \(\Pi\). The body of a rule \(r\) is satisfied by \(I\) if \(r^{+}\subseteq I\) and \(r^{-}\cap I=\emptyset\). A rule \(r\) is satisfied by \(I\) if the body of \(r\) is satisfied by \(I\) implies \(I\models c\). When \(c\) is absent, \(r\) is a constraint and is satisfied by \(I\) if its body is not satisfied by \(I\). \(I\) is a model of \(\Pi\) if it satisfies all rules in \(\Pi\). For an interpretation \(I\) and a program \(\Pi\), the _reduct_ of \(\Pi\) with regard to \(I\) (denoted by \(\Pi^{I}\)) is the program obtained from \(\Pi\) by deleting (i) each rule \(r\) such that \(r^{-}\cap I\
eq\emptyset\), and (ii) all expressions of the form \(not\ a\) in the bodies of the remaining rules. Given an interpretation \(I\), observe that the program \(\Pi^{I}\) is a program with no occurrence of \(not\ a\). An interpretation \(I\) is an _answer set_ of \(\Pi\) if \(I\) is the least model (with regard to \(\subseteq\)) of \(\Pi^{I}\). Several extensions have been introduced to simplify the use of ASP. In this paper, we make use of a restricted form of the aggregate \(\#min\) of clingo, where an expression \(v=\#min\{X:p(X),q(X),\ldots\}\) is true if \(v\) is equal to the minimum (numerical) value of \(X\) such that \(p(X)\), \(q(X),\ldots\) are true. We also use the shorthand \(p(x;y)\leftarrow\Gamma\) to denote the set of rules \(p(x)\leftarrow\Gamma\) and \(p(y)\leftarrow\Gamma\). While for our application we rely on action languages [11] for a compact and high-level representation of policies, for simplicity of presentation in this paper we represent the behavior of the domain directly using ASP rules. We follow the typical approach for such a representation--see, e.g., [4]. Let \(\mathcal{A}\) be a set of actions and \(\mathcal{F}\) be a set of _fluents_, where a fluent is a (Boolean) property of the domain whose truth value may change over time. Let \(\mathcal{T}\) be a set of integers intuitively corresponding to discrete _time steps_ in the evolution of the state of the domain. A fluent literal is a fluent \(f\) or its (classical) negation \(\
eg f\). A state is a complete and consistent set of fluent literals from \(\mathcal{F}\). (Without loss of generality, for sake of simplicity we adopt a simpler definition than that of [2]). A literal of the form \(h(f,t)\) (resp., \(\
eg h(f,t)\)) indicates that fluent \(f\) is true (or false) at time step \(t\). A literal \(o(a,t)\) indicates that action \(a\) occurs at time step \(t\).