{'fraction_non_alphanumeric': 0.03161345226463265, 'fraction_numerical': 0.0090144041352791, 'mean_word_length': 4.343213203098687, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 2, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 9, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Why Couldn't You do that? Explaining Unsolvability of Classical Planning Problems in the Presence of Plan Advice

Explainable planning is widely accepted as a prerequisite for autonomous agents to successfully work with humans. While there has been a lot of research on generating explanations of solutions to planning problems, explaining the absence of solutions remains an open and under-studied problem, even though such situations can be the hardest to understand or debug. In this paper, we show that hierarchical abstractions can be used to efficiently generate reasons for unsolvability of planning problems. In contrast to related work on computing certificates of unsolvability, we show that these methods can generate compact, human-understandable reasons for unsolvability. Empirical analysis and user studies show the validity of our methods as well as their computational efficacy on a number of benchmark planning domains.


Introduction
The ability to explain the rationale behind a decision is widely seen as one of the basic skills needed by an autonomous agent to truly collaborate with humans. At the very least we would want our autonomous teammates to be capable of explaining why a particular action/plan was chosen to achieve some objective and be able to explain why they consider some objectives to be unachievable. For example, consider an automated taxi scheduling system. A user asks for a taxi to pick up her and three of her friends and the service comes back by saying that it is not possible, and recommends instead using two different taxis. In this scenario, the user would want to know why a single taxi can't pick up all four of them.
Most earlier works in explanation generation for planning problems have focused on the problem of explaining why a given plan or action was chosen, but do not address the problem of explaining the unsolvability of a given planning problem. While works like [Eriksson, Röger, and Helmert, 2018;Eriksson, Röger, and Helmert, 2017] have looked at the problem of generating certificates or proofs of unsolvability, these certificates are geared towards automatic verification rather than human understandability.
In this paper, we present a new approach for explaining unsolvability of planning problems that builds on the well known psychological insight that humans tend to decompose sequential planning problems in terms of the subgoals they need to achieve [Donnarumma, Maisto, and Pezzulo, 2016;Cooper and Shallice, 2006;Simon and Newell, 1971]. We will thus help the user understand the infeasibility of a given planning problem by pointing out unreachable but necessary subgoals. For example, in the earlier case, "Holding three passengers" is a subgoal that is required to reach the goal, but one that can no longer be achieved due to new city regulations. Thus the system could explain that the taxi can't hold more than two passenger at a time (and also notify the user about the new city ordinance).
Unfortunately, this is not so straightforward, since by the very nature of the problem, there exist no solutions and hence no direct way of extracting meaningful subgoals for the problem. We can find a way around this issue by noting the fact that the user is asking for an explanation for unsolvability either due to a lack of understanding of the task or because of limitations in their inferential capabilities. Therefore, we can try to capture the user's expectations by considering abstractions of the given problem. In particular, we use state abstractions to generate potential solutions and subgoals at higher levels of abstractions. Such an approach was used by [Sreedharan, Srivastava, and Kambhampati, 2018] to compute explanations for user queries attuned to the level of expertise of the user.
In section 3, we present our basic framework and discuss how we can identify the appropriate level of abstraction and unachievable subgoals for an unsolvable classical planning problem. In the real world, a more challenging version of this problem arises when the user provides plan advice (which may include temporal preferences) on the type of solutions expected. In section 4, we will see how explaining unsolvability of planning problems with plan advice (c.f [Myers, 1996]) could be seen as establishing unsolvability of planning problems with additional plan constraints. This is a capability that is necessary to capture the fact that these explanations are being provided within the context of a conversation. The presence of these additional plan advice could either reflect cases (1) where the original problem was solvable, but users requirements (i.e. expressed in the advice) renders it unsolvable and (2) where the original problem was unsolvable and the user presents an outline for a solution in the form of advice. Even in the second case, by taking into account the hu- Figure 1: A sample abstraction lattice. The lattice consists of models generated by projecting out rocks or soil samples. The problem is unsolvable (the goal is marked in green) in the most concrete model but solvable in models where the rocks are projected out. man's expected solution, we can provide a more targeted explanation. For evaluating our approach, we will look at a user study we ran to validate the usefulness of such explanations for unsolvable problems (with plan advice) and also note the computational efficiency of our method for some standard planning benchmarks.

Background
We will assume that the autonomous agent uses a STRIPS planning model [Fikes and Nilsson, 1971] that can be represented as a tuple of the form M = F, A, I, G , where F is a set of propositional fluents that define the state space S M for the model, A gives the set of actions the robot has access to, I defines the initial state and G the goal. A state S ∈ S M corresponds to a unique value assignment for each state fluent and can be represented by the set of fluents that are true in that state. Each action a ∈ A is further defined by a tuple a = prec a , adds a , dels a and a plan is defined as an action sequence of the form π = a 1 , ..., a n . A plan is said to be valid for M, if the result of executing a plan from the initial state satisfies the goal (denoted as π(I) |= M G). For the model M, we will represent the set of all valid plans as Π M . Each planning model M also corresponds to a transition sys- Each valid plan has a corresponding path in the transition system from I to some state in S G .
In this work, we will be focusing on state and action abstractions induced by projecting out fluents. Thus a model M 2 is said to be an abstraction of M 1 (denoted by M 1 M 2 ) if model M 2 can be formed from M 1 by projecting out a set of fluents. Formally, M 1 M 2 if there exists some P ⊆ F , such that the transition system of M 2 is defined as T 2 = S M2 , I 2 , S G2 , A, T 2 . Where, for every S ∈ S M1 , there exist a state S \ P ∈ S M2 , I 2 = I \ P , S G2 is the subset of S M2 that satisfy G = G \ P and for every transition S, a, S ∈ T 1 , there exist S \ P, a, S \ P ∈ T 2 . We will denote an abstraction formed by projecting out P from the model M as f P (M). An abstraction f P (M) is considered logically complete if for every π such that π(I) |= M G, we have π(I f P (M) ) |= f P (M) G f P (M) . In this work, we will only be looking at logically complete abstractions. For classical planning models, logically complete abstractions can be formed by simply removing the abstracted out fluents from the domain model and problem.
Sreedharan, Srivastava, and Kambhampati (2018) notes that given a model M and a set of propositions P we can define an abstraction lattice, denoted as L = M, E, , where each model in M is an abstraction of M. There exist an edge For convenience, we will treat the abstraction function f for a given lattice as invertible and use f −1 P (M) to represent the unique concrete node in the lattice that could have been abstracted (by projecting out P ) to generate M. We will refer to f −1 P (M) as the concretization of M for P . Figure 1 presents a simple conceptualization of an abstraction lattice for the rover domain. The edges in the lattice correspond to projecting out the presence of rocks or soil samples.
These earlier work uses such abstraction lattices to estimate the user's level of understanding of the given task, by searching for the level of abstraction where an incorrect alternative raised by the user (or foil) could be supported. In the following section, we will layout our framework and discuss how we leverage the abstraction lattice for our purposes.

Our Approach
The input to our approach includes an unsolvable problem M R = F R , A R , I R , G R (i.e |Π M R | = 0) and an abstraction lattice L = M, E, , where M represents the space of possible models that could be used to capture the human's understanding of the task. Given this setting, our method for identifying explanations, includes the following steps • Identify the level of abstraction at which the explanation should be provided (Section 3.1) • Identify a sequence of necessary subgoals for the given problem that can be reasoned about at the identified level of abstraction (Section 3.2) • Identify the first unachievable subgoal in that sequence (Section 3.3) Intuitively, one could understand the three steps mentioned above as follows. First, identify the level of detail at which unsolvability of the problem needs to be discussed. The higher the level of abstraction, the easier the user would find it to understand and reason about the task, but the level of abstraction should be detailed enough that the problem is actually unsolvable there. In most cases, this would mean finding the highest level of abstraction where the problem is still unsolvable. Now even if the system was to present the problem at this desired level of abstraction, the user may be unable to grasp the reason for unsolvability. Again, our method involves helping the human in this process by pointing out a necessary subgoal (i.e., any valid solution to that problem must achieve the subgoal) that can't be achieved at the current abstraction level. Thus the second point relates to the challenge of finding a sequence of subgoals (defined by state fluents present at the explanatory level) for a given problem. In the third step, we try to identify the first subgoal in the sequence that is actually unsolvable in the given level.
Given our approach, the final explanatory message provided to the user would include model information that brings their understanding of the task to the required level and information on the specific subgoals (and previous ones that need to be achieved first) that can no longer be achieved. In cases where the unachievable subgoals are hard to understand formulas or large disjunctions, we can also use these subgoals to produce exemplar plans and illustrate their failures alongside the unachievable subgoals.

Identifying the Minimal Level of Abstraction Required for Explanation
Let's assume that the human's understanding of the task could be approximated by a model M H = F H , A H , I H , G H , such that, the model is part of the abstraction lattice (M R M H and M H ∈ M) and since the user expected the problem to be solvable, We now need to this human model to an abstraction level where the problem is unsolvable (i.e the explanation level) by providing information about a certain subset of fluents previously missing from the human model (i.e information on their truth values in the initial and goal state, and how they affect various actions etc...).
For example, in the case of Figure 1, let us assume that the human model is M 2 , then the information that needs to be provided to the user involves the position of the rocks and how they restrict certain robot motions. We will refer to the set of fluents that the human needs to be informed about as explanatory fluents (E) and for Figure 1, it will be E = {has rocks(?x, ?y)}.
Unfortunately, this is not an operational definition as we do not have access to M H . Instead, we know that M H must be part of the lattice, and thus there exists a subset of the maximal elements of the lattice (denoted as M abs ) 1 that is more abstract than M H . In this section, we will show how the explanatory fluents for models in this subset of M abs would satisfy M H as well.
The first useful property to keep in mind is that if M 1 is more concrete than M 2 then the models obtained by concretizing each model with the same set of fluents would maintain this relation (although they may get concretized to the same model), i.e., Proposition 1. Given models M 1 , M 2 and a set of fluents Next, it can be shown that any given set of explanatory fluents for an abstract model will be a valid explanatory fluent set for a more concrete model Proposition 2. Given models M 1 , M 2 , if M 1 M 2 , then any explanation E for M 2 must also be an explanation for M 1 .
To see why this proposition is true, let's start from the . From the definition of explanation we know that the concretization with respect to explanatory fluents would render the problem unsolvable (i.e |Π f −1 E (M2) | = 0) and thus |Π f −1 E (M1)) | must also be empty and hence E is an explanation for M 1 . Definition 2. Given an abstraction lattice L, let M abs be its maximal elements. Then the minimum abstraction set is de- Note that for any model M 1 ∈ M min , M H M 1 , this means by Proposition 2, any explanation that is valid for models in M min , should lead M H to a node where the problem is unsolvable. Now we can generate the explanation (even the optimal one) by searching for a set of fluents that when introduced to the models M ∈ M min will render resulting f −1 E (M) unsolvable.

Generating Subgoals of a Given Problem
Note that we can't identify possible subgoals for the given problem in the node at which the problem was found to be unsolvable (i.e f −1 E (M min )). There exist no valid plans in that model and thus there are no subgoals to point to. Fortunately, we can use models more abstract than f −1 E (M min ) to generate such subgoals. We will use planning landmarks [Hoffmann, Porteous, and Sebastia, 2004] extracted from M, where |Π M | > 0, as subgoals. Intuitively, state landmarks (denoted as Λ = Φ, ≺ ) for a model M can be thought of as a partially ordered set of formulas, where the formulas and the ordering needs to be satisfied by every plan that is valid in M. We will only be considering sound orderings (c.f [Richter, Helmert, and Westphal, 2008]) between landmarks, namely, (1) natural orderings (≺ nat ) -φ ≺ nat φ , then φ must be true before φ is made true in every plan, (2) necessary orderings (≺ nec ) -if φ ≺ nec φ then φ must be true in the step before φ is made true every time and (3) greedy necessary orderings (≺ gnec ) -if φ ≺ gnec φ then φ must be true in the step before φ is made true the first time. The landmark formulas may be disjunctive, conjunctive or atomic landmarks.
Our use of landmarks as the way to identify subgoals is further justified by the fact that logically complete abstractions conserve landmarks. Formally Proposition 3. Given two models M 1 and M 2 , such that M 1 M 2 , let Λ 1 = Φ 1 , ≺ 1 and Λ 2 = Φ 2 , ≺ 2 be the landmarks of M 1 and M 2 respectively. Then for all φ j . This is true because φ 2 i ≺ 1 φ 2 j hold over all the plans that are valid in M 2 , thus must also hold over all plans in M 1 .
Though in M 1 these landmark instances may be captured by more constrained formulas and additionally M 1 may also contain landmarks that were absent from M 2 . Now if we can show that in a particular model, a landmark generated from a more abstract model is unachievable (or the ordering from the previous level is unachievable) then φ 1 * becomes ⊥ (thereby meeting the above requirement). Thereafter for any model more concrete than M 2 , the formula corresponding to that landmark must be ⊥. In other words, if for any model a landmark is unachievable, then that landmark can't be achieved in any models more concrete than the current one.
So given the explanatory level, we can move one level up in the lattice and make use of any of the well established landmark extraction methods developed for classical planning problem to generate a sequence of potential subgoals for M R .

Identifying Unachievable Sub-Goals
Now we need to find the first subgoal from the sequence that can no longer be achieved in the models obtained by applying the explanatory fluents ( f −1 E (M min )) which will then be presented to the user. For example, in the case of Figure  1, the unachievable subgoal would correspond to satisfying at rover(5, 4) (marked in red in M 4 ).
It is important to note that finding the first unachievable subgoal is not as simple as testing the achievability of each subgoal at the abstraction level identified by methods discussed in section 3.1. Instead, we need to make sure that each subgoal is achievable while preserving the order of all the previous subgoals. To test this we will introduce a new compilation that allows us to express the problem of testing achievement of a landmark formula as a planning problem. Consider a planning model M and the landmarks Λ = Φ, ≺ extracted from some model M , where M M . We will assume that the formulas in Φ are propositional logic formulas over the state fluents and are expressed in DNF. Each φ ∈ Φ can be represented as a set of sets of fluents (i.e, φ = {c 1 , ..., c k } and each c i set takes the form c i = {p 1 , ..p m }), where each set of fluents represent a conjunction over those fluents. For testing the achievability of any landmark φ ∈ Φ, we make an augmented model M φ = F φ , A φ , I φ , G φ , such that the landmark is achievable iff |Π M φ | > 0. The model M φ can be defined as follows: F φ = F ∪ F meta , where F meta contains new meta fluents for each possible landmark φ ∈ Φ of the form • achieved(φ ) keeps track of a landmark being achieved and never gets removed • unset(φ ) Says that the landmark has not been achieved yet, usually set true in the initial state unless the landmark is true in the initial state • f irst time achieved(φ ) Says that the landmark has been achieved for the first time. This fluent is set true in the initial state if the landmark is already true there The new action set A φ , will contain a copy of each action in A. For each new action corresponding to a ∈ A, we add the following new effects to track the achievement of each landmark • for each φ ∈ Φ if the action has existing add effects for a subset of predicatesĉ j for a c j ∈ φ , then we add the conditional effects cond 1 (φ ) → {achieved(φ )} and We add a conditional delete effect to every action of the form f irst time achieved(φ ) → (not(f irst time achieved(φ ))) The new goal would be defined as G φ = {f irst time achieved(φ)}.
This formulation allows us to test each landmark in the given sequence and find the first one that can no longer be achieved. To ensure completeness, we will return the final goal if all the previously extracted landmarks are still achievable in f −1 E (M min ). Since the above formulation is designed for DNF, we can generate compilation for cases where the landmarks use either un-normalized formulas or CNF by converting them first into DNF formulas. Readers can find sample explanations generated using our methods in the supplementary file hosted at https://goo.gl/nc2NP3.

Planning Problem with Plan Advice
Let us now discuss how we could extend the methods presented in earlier sections to cases where the user provides plan advice. In such cases,the user imposes certain restrictions on the kind of solution they expect, either as an alternative to the solution the system may come up with on its own or as a guide to help the system come up with solutions when it claims unsolvability.
As pointed out in [Myers, 1996], such advice can be compiled into plan constraints in the original problem. A number of approaches have been proposed to capture and represent plan constraints [Bacchus and Kabanza, 2000;Nau et al., 2001;Kambhampati, Knoblock, and Yang, 1995;Baier and McIlraith, 2006], and each of these representational choices has its unique strengths and weaknesses. In general, we can see that these plan constraints specify a partitioning of the space of all valid plans to either acceptable (i.e it satisfies the constraints) or unacceptable. So we can define, constraints as follows Definition 3. A constraint σ for a planning model M, specifies a function that maps a set of valid plans on M to a subset, If we can assume some upper bound on the possible length of plans in σ(Π M ) (which is guaranteed when we restrict our attention to non-redundant plans in any function free fragment of classical planning), then we can assert that there always exists a finite state machine that captures the space of acceptable plans Proposition 4. Given a constraint σ, there exists a finite state automaton F σ = Σ, S F σ , S 0 , δ, E , where Σ is the input alphabet, S F σ defines the FSA states, S 0 is the initial state, δ is the transition function and E is the set of accepting states, such that σ(Π M ) = L(F σ ) ∩ Π M , where L(F σ ) is the set of strings accepted by F σ .
The existence of F σ can be trivially shown by considering an FSA that has a path for each unique plan in F σ . We believe that this formulation is general enough to capture almost all of the plan constraint specifications discussed in the planning literature, including LTL based specifications, since for classical planning problems these formulas are better understood in terms of LT L f [De Giacomo and Vardi, 2015] which can be compiled into a finite state automaton.
We can use F σ to build a new model σ(M) such that a plan is valid in σ(M) if and only if the plan is valid for M and satisfies the given specification σ, i.e., ∀π, π ∈ Π σ(M) iff π ∈ σ(ΠM) For M = F, A, I, G , we can define the new model σ(M) = F σ , A σ , I σ , G σ as follows A δ are the new meta actions responsible for simulating the transitions defined by δ : where a corresponds to an action in A, then we will have two new actions a 1 S1,a = prec a ∪ {in-state-{S 1 }}, adds a ∪ {in-state-{S 2 }}, dels a ∪ {in-state-{S 1 }} and a 2 S1,a = prec a ∪ {in-state-{S 1 }}, adds a , dels a } . In cases like LTL, the FSA state transitions may be induced by the satisfaction of some formula, so the new meta action may have preconditions corresponding to that formula, with no other effects but changing the fluent corresponding to the state transition.
The above formulation merely points out that there always exists a way of generating σ(M) from the given specification σ and M. For many constraint types, there may exist more efficient ways of generating models that satisfy the requirements of σ(M).
Once we have access to σ(M), we should be able to use the methods discussed in earlier sections, provided we can show that these new models could be used to build an abstraction lattice. In particular, we want to know if the abstraction relations are preserved. Fortunately this is true. Formally, Proposition 5. Given models M 1 , M 2 and a constraint specification σ, if M 1 M 2 , then σ(M 1 ) σ(M 2 ).

User Studies
Our first topic for evaluation is whether explanations based on landmarks do, in fact, constitute meaningful explanations, at least for naive users. As a simple alternative, we enumerated over a set of solutions (generated from a higher level of abstraction) and pointed out their individual failures. For the study, we recruited around 120 master turkers from Amazon's Mechanical Turk and tested the following hypotheses • H1 -Users prefer explanations concise explanations over ones that enumerate a set of possible candidates for a given piece of plan advice • H2 -Users prefer concise explanations that contain information about unachievable landmarks over ones that only show the failure of a single exemplary plan For the hypotheses, we presented the study participants with a sample dialogue between two people over a logistics plan to move a package from one location to another. The dialogue included a person (named Bob) presenting a plan to another (named Alice), and Alice asks for an alternative possibility (i.e specifies a constraint on the solution). Now the challenge for Bob is to explain why the constrained problem is unsolvable. For H1, the potential explanations included (a) just information on the unachievable landmark, (b) landmark information with the failure details of a specific exemplary plan and (c) a set of three plans that satisfy the constraints and their corresponding failures. For this study, we used 45 participants and each participant was assigned one of three possible maps for each hypothesis and was paid $1.25 for 10 mins. We used a control question to filter participant responses, so as to ensure their quality. Out of the 39 remaining responses, we found 94.8% of users chose to select the more concise explanation (i.e (a) or (b)), and 51.28% of the users chose explanations that involved just landmarks.
For H2, we used 75 participants and presented each participant with explanations that include (a) just landmark information, (b) landmark information with failure details of an exemplary plan and (c) just the exemplary plan failure. Here participants were paid $1 for 10 mins for H2 as the explanatory options were much simpler. After filtering using the control question, we found that out of 60 valid entries 75.4% of participants preferred explanations that included landmark information ((a) or (b)) and 44.2% wanted both landmarks and exemplary plan (i.e (b)). The supplementary file at https://goo.gl/nc2NP3 contains more details on the study setup.

Empirical Studies
In this section, we will present the results of an empirical evaluation of the computational charecteristics of our approach. One big concern with the methods discussed in this work is the fact that they involve solving multiple planning problems. Thus we were interested in identifying how the runtime for an explanation would change when the lattice size changed. As a baseline for comparison we use the trivialized problem where the agent must compute an explanation for a user whose model is known, which means the corresponding search space is much smaller (the supremum of the lattice will be the unique human model).
We considered five standard IPC domains and generated a stand-in for the human model by projecting out a random subset of state fluents. Next, we chose five problem instances for each of the domains and recorded the time required to generate explanations for the human model versus a case where the We simulated the latter case by considering a complete abstraction lattice generated from a superset of the fluents that the human is actually unaware of. For each of the five domains, the total number of fluents used to generate the lattice for the unknown case was at least twice the original number of fluents that was missing from the human model. Each problem instance was made unsolvable by including plan constraints that avoid a specific landmark of the original problem. The constraints were coded using domain control programs of the type discussed in [Baier, Fritz, and McIlraith, 2007]. The constraints ensures that plans avoid one of the landmarks of the original problem, thereby rendering it unsolvable. Figure 2, shows the average runtime and cost of explanations (the number of model updates corresponding to an explanation) related to each domain. We can see that the conciseness of the explanations does not suffer when the user model is not known! For most domains, the total runtime is quite comparable between the two cases, with the unknown case performing better in some domains. This is due to the fact that in the unknown case the test for solvability is usually carried out in more abstract models.

Related Work
As mentioned, there has been prior work on generating planner independent certificates or proofs for establishing the unsolvability of a given planning problem. Another related direction, has been the effort to generate "excuses" for unsolvability of a planning problem [Göbelbecker et al., 2010;Herzig et al., 2014]. They do not provide an intuitive explanation as to why a problem is unsolvable, but rather identifies initial state values (or some domain model conditions) whose update could make the problem solvable.
The contrastive explanations of the type studied in [Sreedharan, Srivastava, and Kambhampati, 2018], where the user presents an alternative plans (that are then refuted by the system) can be thought of as a special case of our approach for problems with plan advice. The problems studied in that earlier paper can be thought about cases where the advice only allows a single plan. Also, one could argue that people would be more comfortable giving advices than full plans.
Part of our explanations also try to reveal to the user information about the current task that was previously unknown to them. Thus our methods could also be understood as an example of explanation as model-reconciliation [Chakraborti et al., 2017]. Since our methods use abstractions, our approach doesn't make too many demands on the inferential capabilities of the user and hence can be applied to much larger and more complex domains.
Another closely related direction has been the work done on explaining unsynthesizability of hybrid controllers for a given set of high-level task specifications [Raman and Kress-Gazit, 2013]. The work tries to identify the subformulas of the given specification that lead to the unsynthesizability. This particular approach is specific to the planning framework detailed in [Finucane, Jing, and Kress-Gazit, 2010] and the objective of the work parallels the goals of work like [Göbelbecker et al., 2010;Herzig et al., 2014].
Outside of explanation generation, the work done in the model checking community is closely related to our current problem [Grumberg and Veith, 2008]. In fact, the hierarchical approach to identifying a model that can invalidate the given foil specification, can be seen as a special case of the CE-GAR based methods studied in the model-checking community [Clarke et al., 2000]. Most work in this field focuses on developing methods for identifying whether a given program meets some specifications and failures to meet specification are generally communicated via counterexamples.

Discussion and Future Directions
The work discussed in this paper investigates the problem of generating explanations for unsolvability of a given planning problem. We also saw how the same methods apply when dealing with problems with plan constraints. In addition to extending these methods to more expressive domains, an interesting extension would be to try tackling cases where the current problem is solvable but all the solutions are too expensive. While this additional cost threshold could be seen as a constraint, the setting becomes a lot more interesting when the action costs are affected by the abstractions (c.f state dependent costs [Geißer, Keller, and Mattmüller, 2016]). With respect to contrastive explanations, this would correspond to cases where the alternative posed by the user is more expensive than the plan proposed by the robot.Finally, an obvious challenge to fully realize this method in practical scenarios is to develop methods to convert user questions to plan constraints. Methods like [Tenorth et al., 2010] can be used to convert natural language statements to constraints like partial plans. Expert users can also directly write LTL and procedural programs as a way of interrogating the system.