Title: Belief-State Query Policies for User-Aligned POMDPs
Venue: NeurIPS 2024
Accepted: yes
Keywords: POMDPs

sequential decision making

user-preferences in POMDPs
Abstract: Planning in real-world settings often entails addressing partial observability while aligning with users' requirements. We present a novel framework for expressing users' constraints and preferences about agent behavior in a partially observable setting using parameterized belief-state query (BSQ) policies in the setting of goal-oriented partially observable Markov decision processes (gPOMDPs). We present the first formal analysis of such constraints and prove that while the expected cost function of a parameterized BSQ policy w.r.t its parameters is not convex, it is piecewise constant and yields an implicit discrete parameter search space that is finite for finite horizons. This theoretical result leads to novel algorithms that optimize gPOMDP agent behavior with guaranteed user alignment. Analysis proves that our algorithms converge to the optimal user-aligned behavior in the limit. Empirical results show that parameterized BSQ policies provide a computationally feasible approach for user-aligned planning in partially observable settings.

Belief-State Query Policies for User-Aligned POMDPs

Abstract

Planning in real-world settings often entails addressing partial observability while aligning with users' requirements. We present a novel framework for expressing users' constraints and preferences about agent behavior in a partially observable setting using parameterized belief-state query (BSQ) policies in the setting of goaloriented partially observable Markov decision processes (gPOMDPs). We present the first formal analysis of such constraints and prove that while the expected cost function of a parameterized BSQ policy w.r.t its parameters is not convex, it is piecewise constant and yields an implicit discrete parameter search space that is finite for finite horizons. This theoretical result leads to novel algorithms that optimize gPOMDP agent behavior with guaranteed user alignment. Analysis proves that our algorithms converge to the optimal user-aligned behavior in the limit. Empirical results show that parameterized BSQ policies provide a computationally feasible approach for user-aligned planning in partially observable settings.

1 Introduction

Users of sequential decision-making (SDM) agents in partially observable settings often have requirements and preferences on expected behavior, ranging from safety concerns to high-level knowledge of task completion requirements. However, users are ill-equipped to specify desired behaviors from such agents. For instance, although reward engineering can often encode fully observable preferences [Devidze et al., 2021, Gupta et al., 2023], it requires significant trial-and-error, and can produce unintended behavior even when done by experts working on simple domains [Booth et al., 2023]. These challenges are compounded in partially observable environments, where the agent will not know the full state on which the users' requirements and preferences are typically defined. For example, defining a reward function on the belief state to align the agent's behavior with the user can result in wireheading [Everitt and Hutter, 2016] (see Sec. 2 for further discussion on related work).

Consider a simplified, minimal example designed to illustrate the key principles (Fig. 1(a)). A robot located on a spaceship experiences a communication error with the ship and needs to decide whether to attempt to repair itself or the ship. Importantly, while a robot error is harder to detect, the user would rather risk repairing the robot than repairing the ship, as each repair risks introducing additional failures. In other words, the user may expect the robot to work with the following goals and preferences: The objective is to fix the communication channel. First, if there is a 'high' likelihood that the robot is broken, it should try to repair itself; otherwise, if there is a 'high' likelihood that the ship is broken, it should try to repair that. Such preferences go beyond preferences in fully observable settings: they use queries on the current belief state for expressing users' requirements while using the conventional paradigm of stating objectives in terms of the true underlying state. Such a formulation avoids wireheading, allowing users to express their constraints and preferences in partially observable settings. Although such constraints on behavior are intuitive and common, they leave a significant

(a) Spaceship Repair Problem

(c) Expected Cumulative Cost Function is

and

Non-Convex

Robot

Spaceship

Repair

Repair

Station

Station

-n

-1

0

1

n

1.0

12.0

11.5

0.8

9.72

11.0

0.6

9.65

10.5

?

2

9.03

10.0

0.4

9.50

9.5

9.05

9.0

0.2

9.06

- 8.5

0.0

0.0

8.63

0.2

0.4

01

0.6

0.8

1.0

8.0

amount of uncertainty to be resolved by the agent: it needs to optimize the threshold values of 'high' probability under which each rule would apply while attempting to achieve the objective.

We introduce mathematical and algorithmic foundations for addressing these problems by defining constraints on behaviors in terms of properties of the belief state, expressed through belief-state queries (BSQs). We prove the surprising result that although the space of possible threshold values in preferences such as the one listed above is uncountably infinite, only a finite number of evaluations are required for computing optimal, user-aligned policies for finite-horizon problems. We use this result to develop a probabilistically complete algorithm for computing optimal constrained policies. Our main contributions are:

A framework for encoding user requirements and preferences over agent behavior in goaloriented partially observable Markov decision processes (Sec. 3).

Mathematical analysis proving that the expected cost function of a parameterized BSQ policy w.r.t its parameters is piecewise constant but generally non-convex. (Sec. 4).

A probabilistically complete algorithm for computing optimal user-aligned policies in goal-oriented POMDPs (Sec. 5).

Empirical evaluation on a diverse set of problems showing both the efficiency of our algorithm and the quality of the computed user-aligned policies. (Sec. 7).

2 Related Work

Planning over preferences has been well studied in fully observable settings [Baier et al., 2007, Aguas et al., 2016]. Voloshin et al. [2022] present an approach for complying with an LTL specification while carrying out reinforcement learning. Other approaches for using LTL specifications use the grounded state to create a reward function to teach reinforcement learning agents [Toro Icarte et al., 2018, Vaezipoor et al., 2021]. These approaches do not extend to partially observable settings as they consider agents that can access the complete state.

In partially observable settings, existing approaches for using domain knowledge and preferences require extensive, error-prone reward design and/or do not guarantee compliance. LTL specifications have been incorporated either by designing a reward function that incentivizes actions more likely to adhere to these specifications [Liu et al., 2021, Tuli et al., 2022] or by imposing a compliance threshold [Ahmadi et al., 2020]. In both approaches, the user calibrates rewards for user alignment with those for objective completion; it is difficult to ensure user alignment. We focus on the problem of guaranteeing user alignment without reward engineering.

Mazzi et al. [2021, 2023] proposed expressing domain control knowledge using belief state probabilities. Mazzi et al. [2021] used expert-provided rule templates and execution traces to construct a shield to prevent irregular actions. Mazzi et al. [2023] used execution traces and domain-specified belief-state queries to learn action preconditions over the belief state. Both approaches use input traces and focus on ensuring a policy is consistent with previously observed behavior. We address the complementary problem of computing user-aligned policies without past traces.

Belief-state queries have been used to solve POMDPs with uniform parameter sampling [Srivastava et al., 2012] but formal analysis, feasibility of optimizing BSQ policies, and the existence of provably convergent algorithms have remained open as research questions prior to this work.

3 Formal Framework

This section formally defines the BSQ framework, which expresses user requirements on an agent's belief and is designed for relational goal-oriented partially observable Markov decision processes.

3.1 Goal-Oriented Partially Observable Markov Decision Process

Partially observable Markov decision processes (POMDPs) constitute a standard mathematical framework for modeling SDM problems in partially observable, stochastic settings [Kaelbling et al., 1998, Smallwood and Sondik, 1973]. State-of-the-art POMDP solvers often rely on approximate online approaches [Silver and Veness, 2010, Somani et al., 2013] where recent work addresses the problem of obtaining performance bounds [Barenboim and Indelman, 2023, Lim et al., 2023].

We use goal-oriented POMDPs (gPOMDPs), where the agent aims to complete one of the tasks/goals. This eliminates the burden of error-prone reward engineering by using a default cost function that associates a constant cost for each timestep before reaching the goal. E.g., the Spaceship Repair problem (Sec. 1) has two objects: the robot and the spaceship. A state is defined using a Boolean function broken p o q representing whether object o needs repair and an integer-valued function rlocation pq representing the robot's location. Both functions are not observable. The agent has two types of actions: try to repair object o ( repair p o qq or wait p wait pqq . A transition function expresses the distribution of rlocation pq depending on the action taken and the robot's previous location. At each timestep, the robot receives a noisy observation obs _ err p o q regarding the status of object o . The set of observations can be expressed as t obs _ err p robot q , obs _ err p ship qu . Due to noisy perception, obs _ error p o q may not match broken p o q . An observation function denotes the probability of each observation conditioned on the (hidden) current state. The goal is to reach the repair station corresponding to the truly broken component. We define gPOMDPs formally as follows.

Definition 1. A goal-oriented partially observable Markov decision process P is defined as x C , F , A , O , T , Ω , G , Cost , H, b 0 y where C is the finite set of constant symbols and F is the finite set of functions. The set of state variables for F , V F , is defined as all instantiations of functions in F with objects in O . The set of states S is the set of all possible valuations for V F ; A is a finite set of actions, O is a subset of F of observation predicates, T : S ˆ A ˆ S Ñ r 0 , 1 s is the transition function T p s, a, s 1 q ' Pr p s 1 | a, s q ; G Ď S is the set of goal states that are also sink states, Ω : S ˆ A ˆ O Ñ r 0 , 1 s is the observation function; Ω p s, a, o q ' Pr p o | s, a q , Cost p s q ' t 0 if s P G ;else 1 u is the cost function, H is the horizon, and b 0 is the initial belief state. A solution for a gPOMDP is a policy that has a non-zero probability of reaching G in H ´ 1 timesteps.

3.2 Belief-State Queries and Policies

Computing a policy for any gPOMDP requires planning around state uncertainty. This is done using the concept of a belief state , which is a probability distribution over the currently possible states. Formally, the belief state constitutes a sufficient statistic for observation-action histories [Astrom et al., 1965]. We express user requirements using queries on the current belief state.

For any belief state b , when action a is taken and observation o is observed, the updated belief state is computed using b 1 p s 1 q ' α Ω p s 1 , a, o q ř s T p s, a, s 1 q b p s q where α is the normalization factor. We refer to this belief propagation as b 1 ' bp p b, a, o q . We extend the notation to refer to the sequential application of this equation to arbitrary bounded histories as bp ˚ p b 0 , a 1 , o 1 , ..., a n , o n q ' bp p . . . bp p bp p b 0 , a 1 , o 1 q , a 2 , o 2 q . . . q .

For example, the Spaceship Repair problem user preference has the expression 'a high likelihood that the robot is broken' . This can be expressed as a query on a belief state b : Pr J broken p robot q K b ą Θ rob where Θ rob is a parameter. If rlocation pq is fully observable, the expression 'the robot location is smaller than Θ l in a belief state b ' can be expressed as Pr J rlocation pq ă Θ l K b '' 1 . We can combine both queries to express 'a high likelihood the robot is broken and its location is lower than Θ l ' , as: Pr J broken p robot q K b ą Θ rob ^ Pr J rlocation pq ă Θ l K b '' 1 .

Formally, BSQs use the vocabulary of the underlying gPOMDP. There are two types of queries we can ask: (1) whether formula φ is true with a probability that satisfies a threshold Θ ; (2) whether the fully observable portion of the state satisfies a formula φ containing a threshold Θ . These thresholds represent the parameters of a parameterized BSQ policy. The agent must optimize these parameters to achieve the goal while aligning with the user's requirements. BSQs can be combined using conjunctions or disjunctions to express more complex requirements, which we define as a compound BSQ in Def. 3. We omit subscripts when clear from context.

Definition 2. A belief-state query λ P p b ; φ, ˝ , Θ q , where b is a belief state, φ is a first-order logic formula composed of functions in gPOMDP P , ˝ is any comparison operator, and Θ P R is a parameter, is defined as λ P p b ; φ, ˝ , Θ q ' Pr J φ K b ˝ Θ .

Definition 3. A compound BSQ Ψ p b ; Θ q , where b is a belief state and Θ P R n , is either a conjunction or a disjunction of BSQs that contain n total parameters.

We use BSQs to formally express user requirements of the form discussed in the introduction by mapping BSQs with variable parameters to actions. Fig. 1(b) illustrates this with a parameterized BSQ policy for the Spaceship Repair problem. Formally,

Definition 4. Let b be a belief state and Θ be a tuple of n parameter variables over R . An nparameter Parameterized Belief-State Query policy π p b, Θ q is a tuple of rules t r 1 , ..., r m u where each r i ' Ψ i Ñ a i is composed of a compound BSQ Ψ i and an action a i P A . The set t Ψ 1 , ..., Ψ m u is mutually exclusive and covers the n-dimensional parameter space R n .

In practice, mutually exclusive coverage is easily achieved using an if... then... else structure, where each condition includes a conjunction of the negation of preceding conditions and the list of rules includes a terminal else with the catchall BSQ True (Fig. 1). Any assignment of values ϑ P R n to the parameters Θ of a parameterized BSQ policy produces an executable policy that maps every possible belief state to an action:

Definition 5. A BSQ policy π p b, ϑ q is a parameterized BSQ policy π p b, Θ q with an assignment in R to each of the n parameters Θ .

Let Pr π t p G q be the probability that an execution of a policy π reaches a state in G within t timesteps. A BSQ policy π p b, ϑ q is said to be a solution to a gPOMDP with goal G and horizon H iff Pr π p b,ϑ q H ´ 1 p G q ą 0 . The quality of a BSQ policy is defined as its expected cost; due to the uniform cost function in the definition of gPOMDPs, the expected cost of a BSQ policy is the expected time taken to reach a goal state. Formally, the expected cost of a BSQ policy π p b, ϑ q is E π p ϑ ; H q ' ř H t ' 1 t ˆ Pr G ,t r π p b, ϑ qs , where H is the horizon and Pr G ,t r π p b, ϑ qs is the probability of policy π p b, ϑ q reaching a goal state for the first time at timestep t . Thus, given a gPOMDP P , with goal G , and a parameterized BSQ policy π p b, Θ q , the objective is to compute:

4 Formal Analysis

Our main theoretical result is that the continuous space of policy parameters is, in fact, partitioned into finitely many constant-valued convex sets. This insight allows the development of scalable algorithms for computing low-cost user-aligned policies. We introduce formal concepts and key steps in proving this result here; complete proofs for all results are available in the Appendix. We begin with the notion of strategy trees to conceptualize the search process for BSQ policies.

4.1 Strategy Trees

Every parameterized BSQ policy π p b, Θ q and gPOMDP P defines a strategy tree (e.g., Fig. 2(a)) that captures the possible decisions at each execution step. Intuitively, the tree starts at a belief node representing the initial belief state. Outgoing edges from belief nodes represent rule selection in π p b, Θ q , resulting in action nodes. Outgoing edges from action nodes represent possible observations,

(a) Spaceship repair H=2 strategy tree (red and blue correlate to two distinct braids)

(b) Partitioned parameter space

leading to belief nodes representing the corresponding updated belief. If the tree is truncated at horizon H , each leaf represents the outcome of a unique trajectory of rules from π p b, Θ q and observations.

Each belief node represents a belief state that can be calculated using the rule-observation trajectory leading to that node. A labeling function l : V B Y V A Ñ B Y A maps the set of belief nodes V B to belief states in B and the set of action nodes V A to actions in A . For ease of notation we define b ˚ i ' l p v i q for all belief nodes v i P V B and a ˚ j ' l p v j q for all action nodes v j P V A .

Definition 6. Let P be a gPOMDP, π p b, Θ q be a parameterized BSQ policy for P , and b 0 be the initial belief state. The strategy tree T π p b o q is defined as T π p b o q ' x V, E y where set V ' V B Y V A contains belief nodes V B and action nodes V A , whereas, set E ' E B Y E A contains edges from belief nodes to action nodes ( E b Ď V B ˆ V A ) and edges from action nodes to belief nodes ( E A Ď V A ˆ V B ). E B is defined as tp v i , r, v j q| v i P V B , v j P V A , r P π p b, Θ q , and D Ψ : r ' Ψ Ñ a ˚ j u . E a is defined as tp v m , o, v n q| v m P V A , v n P V B , o P O , Dp v p , r ' Ψ Ñ a, v m q P E b ; b ˚ n ' bp p b ˚ p , a, o qu .

Non-convexity of the expected cost function Each parameterized BSQ policy permits infinitely many BSQ policies, one for each assignment of real values to its parameters. Unfortunately, the expected cost of parameterized BSQ policies is not a convex function of these parameters. Fig. 1(c) shows this with a counterexample using the parameterized BSQ policy from Fig. 1(b), a horizon of 12, and setting the robot's initial distance from each repair station to 5. This plot was constructed by sampling the expected cost for 251,001 equally-spaced parameter assignments to the Fig. 1(a) parameterized BSQ policy. E π p ϑ ; H q is clearly not convex: the expected cost along the line Θ 2 ' Θ 1 ´ 0 . 25 has two inflection points at Θ 1 ' 0 . 6 and Θ 1 ' 0 . 8 . This creates two local minima: Θ 1 ď 0 . 16 and Θ 1 ě 0 . 83 ^ Θ 2 ď 0 . 1 . Intuitively, this is due to the short horizon, which causes the optimal strategy to be selecting a repair station and traversing to it regardless of the observations. This complicates finding good BSQ policies using existing solvers. However, every possible BSQ policy can be associated with a set of strategy tree leaves that are reachable under that policy. Thus, for a given horizon, there are only finitely many expected costs for BSQ policies for a given problem.

The main challenge in computing good BSQ policies is that the set of possible BSQ policies with distinct expected costs grows exponentially with the horizon and good BSQ parameters could be distributed arbitrarily in the high-dimensional, continuous space of parameter values. We use strategy trees to define groups of leaves called braids, which we will then use to prove that the space of BSQ policy parameters turns out to be well-structured in terms of the expected cost function.

Braids We refer to the set of all leaves reachable under a policy π p b, ϑ q as the braid of ϑ . Due to the mutual exclusivity of rules for every assignment of parameter values to a parameterized BSQ policy, at most, one outgoing edge can be taken from each belief node (as these correspond to the rules and actions). However, the stochasticity of dynamics and observations allows for multiple outgoing edges to be possible from action nodes. E.g., in the strategy tree for the Spaceship Repair problem (Fig. 2(a)), leaves ℓ 2 and ℓ 10 cannot both be reachable under a BSQ policy because that would require rules r 1 and r 2 to be satisfied at the same belief. However, both ℓ 1 and ℓ 5 may be reachable under the same BSQ policy since their paths diverge on an action node. Formally,

Definition 7. Let H be the horizon, and let π p b, Θ q be a parameterized BSQ policy for a gPOMDP P . The braid of a parameter assignment ϑ , braid π,H p ϑ q , is the set of all leaves in strategy tree T π p b 0 q rooted at the initial belief b 0 that can be reached while executing π p b, ϑ q : braid π,H p ϑ q ' t ℓ H : the path to ℓ H is p r 1 , o 1 , ..., r H , o H q ; @ i r i ' Ψ i Ñ a i , b i ' bp ˚ p b 0 , r 1 , o 1 , ..., r i , o i q and ϑ satisfies Ψ i .

The unique interval of parameter values where a leaf is reachable can be calculated by taking the intersection of the parameter intervals needed to satisfy each rule on the path to that leaf. This is because for any compound BSQ Ψ , we can compute the unique interval of parameter values I p Ψ q under which b will satisfy I p Ψ q by substituting each BSQ in Ψ with its corresponding inequality:

Lemma 1. Let Ψ p b ; Θ q be an n-dimensional compound BSQ. There exists a set of intervals I p Ψ q Ď R n s.t. Ψ p b ; Θ q evaluates to true iff Θ P I p Ψ q .

We can utilize this result to compute the unique interval of parameter values consistent with a braid by taking the intersection of the intervals of each leaf contained in that braid (Def. 8):

Definition 8. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, b 0 be the initial belief state, and H be the horizon. The interval of leaf ℓ , I p ℓ q , is defined as the intersection of intervals Ş i I p Ψ i q of the conditions of each rule r i that occurs in the path to that leaf. The interval for a set of leaves L is defined as I p L q ' Ş ℓ i P L I p ℓ i q .

Any leaf or braid with an empty parameter interval does not align with the user's requirements. For example, in Fig. 2, note that r 1 is the only rule satisfiable if r 1 is selected from b 0 and the robot is observed to be broken. Using the Fig. 1(b) policy and assuming the sensor accuracy is 60%, picking a rule other than r 1 implies that 50% likelihood was high enough to fix the robot yet 60% was not, which is a contradiction. Removing misaligned leaves and braids prunes the tree.

4.2 BSQ Policies are Piecewise Constant

We now use the concept of braids to prove that the continuous, high-dimensional space of parameter values of a parameterized BSQ policy reduces to a finite set of contiguous, convex partitions with each partition having a constant expected cost. This surprising result implies that although the expected cost of BSQ policies is not a convex function of parameter assignments, optimizing a parameterized BSQ policy requires optimization over a finite set rather than over a continuous space. We first define a notion of similarity over assignments to parameterized BSQ policies that define BSQ policies:

Definition 9. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, and H be the horizon. Two assignments ϑ 1 , ϑ 2 P Θ are said to be similar, ϑ 1 ' H ϑ 2 , iff braid π,H p ϑ 1 q ' braid π,H p ϑ 2 q .

It is trivial to show ' H is transitive, symmetric, and reflexive, making it an equivalence relation over R n . As such, ' H defines a partition over the same space:

Theorem 1. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, b 0 be the initial belief state, and H be the horizon. The operator ' H partitions R n .

However, this result is not sufficient to define the structure of partitions induced in R n , which will be required for an efficient optimization algorithm. Based on Sec. 4.1, we know that leaves whose trajectories diverge due to different rules must not be in the same braid. Furthermore, a belief state can only lead to one set of possible observations for an action regardless of the BSQ policy being followed. Intuitively, this prevents braids from being proper subsets of each other, which implies that the parameter intervals for two braids can never have overlapping parameter intervals. This gives us the desired structure for partitions induced in the space of parameter values for parameterized BSQ policies: there are parameter intervals corresponding to distinct braids in the policy tree. In other words, the set of braids partitions the parameter space into contiguous, high-dimensional intervals. This can be proved formally and stated as follows:

Theorem 2. Let π p b, Θ q be a parameterized BSQ policy, b 0 be the initial belief state, and H be the horizon. Each partition ρ created by operator ' H partitioning R n is the disjoint intervals, ρ Ď R n where @ ϑ P ρ , braid π,H p ϑ q ' L where L is a fixed set of leaves.

Since each partition corresponds to a braid and each braid corresponds to a fixed set of leaves, which defines the expected cost for all policies corresponding to that braid, all policies defined by a partition

of the parameter space have a constant expected cost. As such, the domain of the expected cost function E π p ϑ ; H q for gPOMDP P can be represented as the disjoint intervals of each braid partition. Thus, E π p ϑ ; H q is piecewise constant. The following result formalizes this.

Theorem 3. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, b 0 be the initial belief state, and H be the horizon. Each partition created by ' H on R n has a constant expected cost.

In some situations, the braids that partition the parameter space can be calculated in closed form (e.g., see the Appendix for partitions for the Spaceship Repair problem). The next section develops a general approach for computing the braids and intervals corresponding to a parameterized BSQ policy, for evaluating the expected cost for each such partition, and for optimizing over these partitions.

5 Partition Refinement Search

In this section, we present a novel algorithm for optimizing the parameters for a parameterized BSQ policy using the theory of braids developed above. The Partition Refinement Search (PRS) algorithm (Algo. 1) constructs the set of partitions using hierarchical partition selection and refinement, where a partition is selected to be refined, a leaf that can occur in that partition is sampled and evaluated, and the partitions are refined to isolate the interval of the braid corresponding to the sample. The hypothesized optimal partition is tracked and returned as the final result after timeout.

PRS constructs the first parameter space interval as the domain of all possible parameter values (line 3). This is set as the initial hypothesized optimal partition (line 4). In each iteration, a partition ρ is selected using exploration-exploitation approaches discussed in Sec. 6 (lines 6). A leaf ℓ is sampled from ρ by uniformly sampling parameter value ϑ from ρ 's parameter intervals and

Algorithm 1 Partition Refinement Search (PRS)

1: Inputs: gPOMDP P , parameterized BSQ policy π p b, Θ q , horizon H

2: Output: Minimum cost partition and its ex- pected cost x ρ opt , ˆ E r ρ opt sy

3: ρ init Ð Θ P Θ D Θ

Ś

4: X ' tx ρ init , 8yu , X opt ' x ρ init , 8y

5: while ! TimeOut pq do

6: x ρ, ˆ E r ρ sy Ð SelectPartition p X q

7: ϑ s ' UniformSample p ρ q

8: ℓ, E ℓ Ð Rollout p P , π p b, ϑ s q , H q

9: X Ðp X zx ρ, ˆ E r ρ syq Y x ρ z I p ℓ q , ˆ E r ρ sy

10: X Ð X Yx ρ X I p ℓ q , ˆ E r ρ s Y E ℓ y

11: X opt Ð arg min ˆ E r ρ

x ρ, ˆ E r ρ syP X s

12: end while

13: return X opt

performing rollouts from the initial belief state to a reachable leaf using the BSQ policy π p b, ϑ q (lines 7 and 8). The sampled leaf ℓ is used to refine partition ρ using the insight braids cannot overlap (Sec. 4.2). If there exists a subinterval of ρ where ℓ does not occur, a new partition for this subinterval is constructed containing ρ 's previous leaves and expected cost (line 9). The remaining portion of ρ , where ℓ can occur, is used to construct a partition with an updated expected cost representing ρ 's previous leaves and ℓ (line 10). The hypothesized optimal partition is then updated (line 11).

PRS converges to the true optimal BSQ policies in the limit:

Theorem 4. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, b 0 the initial belief state, and H be the horizon. The likelihood of the Partition Refinement Search algorithm returning the optimal parameter interval converges to one in the limit of infinite samples.

Complexity analysis While the theoretical space and time complexity are linear in the number of leaves, due to PRS grouping leaves from the strategy tree (Def. 6), there is good reason to expect better performance in practice. As discussed in Sec. 4.1, strategy trees can get pruned with the removal of branches and leaves that do not align with the user's requirements. For example, in the Spaceship Repair problem using the Fig. 1 parameterized BSQ policy, a third of the possible leaves are pruned at a horizon of two, and the pruning becomes even more significant for longer horizons. Additionally, empirical results suggest that rules earlier in rule-observation trajectories are more important in dictating the partitions. Furthermore, selecting and refining partitions can be performed in parallel, further improving performance.

6 Partition Selection Approaches

We explored multiple partition selection approaches with a multiprocessing version of PRS. Each approach used the same dynamic exploration rate e r that diminished over time. Each thread managed a subset of partitions X 1 Ď X and updated a global hypothetical optimal partition. Additionally, we warm start PRS by randomly selecting 20 points in the parameter search space and evaluating them 40 times to build an initial set of partitions. Also, partitions that have a lower expected cost than the hypothesize optimal are sampled up to 40 before updating the hypothesize optimal. In this paper, we focus on three selection approaches and discuss two others in the Appendix.

Epsilon Greedy (PRS-Epsilon) We explore e r percent of the time by uniformly sampling s ' U 1 0 and checking if s ď e r . If we are exploring, we uniformly at random select a partition from X 1 . Otherwise, the partition with minimum expected cost, arg min x ρ, ˆ E r ρ syP X 1 ˆ E r ρ s , is selected.

Boltzmann Exploration (PRS-Bolt) Partitions are selected in a weighted random fashion with the probability of selecting partition ρ as α ˆ exp p ˆ E r ρ s{ e r q with α being the normalization factor.

Local Thompson Sampling (PRS-Local) Each thread treats the problem as a multi-armed bandit problem where the expected cost for the next sample from each partition is simulated using N p µ c , σ c q with µ c and σ c being the partition's mean and standard deviation, respectively. The partition with the lowest estimated expected cost is selected.

7 Empirical Results

We created an implementation of PRS and evaluated it on four challenging risk-averse problems. Complete source code is available in the supplementary material. We describe the problems and user preferences here; further details, including parameterized BSQ policy, can be found in the Appendix.

Lane merger (LM) In this problem, an autonomous vehicle driving on a two-lane road must switch lanes safely before reaching a lane merger. However, there is currently a car in the other lane that the agent does not know the location or speed of. Switching lanes too close to this car risks a severe accident. The autonomous vehicle has a noisy detection system that returns whether a vehicle is located in regions around the car. The user's preference is: If there's a high likelihood of safely switching lanes, do so. If there is a high likelihood of the other car being in close proximity and it is possible to slow down, slow down. Otherwise, keep going.

Spaceship repair (SR) This is a modified version of the running example with parameterized BSQ policy Fig. 1(b). The robots start 7 steps and 5 steps away from the robot and ship repair stations, respectively. Additionally, the robot's sensor is 75% accurate at detecting errors with the robot and only 55% for the ship. With the short horizon H ' 12 , this results in the parameter space being not convex with multiple local minimums with differing expected costs.

Graph rock sample (GRS) We modified the classic RockSample( n, k ) problem [Smith and Simmons, 2004] by replacing the grid with a graph with waypoints where some waypoints contain rocks. Additionally, we introduced risk by causing the robot to break beyond repair if it samples a rock not worth sampling. We also categorized the rocks into types, and the rover's goal is to bring a sample of each type to the desired location if a safe rock for that type exists. This goal requires a longer horizon to reach compared to the other problems. The user's preference is: Evaluating rocks of types not sampled in order r 1 , ..., r n , if the rock has a high likelihood of being safe to sample, go and take a sample of it. Else, if the rock has a high likelihood of being safe to sample, get close enough and scan it. Otherwise, move towards the exit if no rocks are worth sampling or scanning.

Store visit (SV) This problem is based on the partially observable OpenStreetMap problem in Liu et al. [2021]. A robot is located in a city where some locations are unsafe (e.g., construction, traffic), which can terminally damage the robot. The robot is initially uncertain of its location but it can scan its surroundings to determine its general location. The agent traverses the city and can visit the closest building. The goal is to visit a bank and then a store. This problem features a nuanced parameterized BSQ policy: If you are significantly unsure of your current location, scan the area. If you have visited a bank, do the following to visit a store; otherwise, do it to visit a bank. If you are sufficiently sure the current location has the building you are looking for, visit it. Otherwise, move towards where you think that building is while avoiding unsafe locations. If all else fails, scan the current area.

0

10

20

30

Expected Cost

0

10

20

30

40

0.0

2.5

5.0

7.5

10.0

Spaceship Repair

0

20

40

60

Store Visit

0

40

80

120

0

25

50

75

100

% Goal Achievement

0

40

80

120

0

25

50

75

100

0

10

20

30

0

25

50

75

100

0

50

100 150 200

0

25

50

75

100

PRS (Ours)

Nelder-Mead

Particle Swarm

Time (Seconds)

7.1 Baselines

We evaluated PRS against three different types of baselines.

RCompliant Select random parameter values uniformly at random from the parameter space to produce user-aligned policies.

Hyperparamter optimization algorithms To measure the benefits of PRS against existing hyperparameter optimization algorithms, we implemented both Nelder-Mead [Nelder and Mead, 1965] and Particle Swarm [Kennedy and Eberhart, 1995]. The expected cost of parameter space point ϑ , for parameterized BSQ policy π , was computed by averaging 1,000 parallel runs of the policy π p b ; ϑ q . For Nelder-Mead optimization, we used a simplex that had vertices numbering one more than the number of parameters in the parameterized BSQ policy being optimized. We warm start by initially evaluating a 100 random points to construct the initial simplex using the best-performing points. For Particle Swarm optimization, 10 particles were used with the location and momentum of each particle clipped to the search space. The coefficients changed based on steps since the last improvement.

Unconstrained POMDP solvers To measure the differences between BSQ policies and unconstrained POMDP solvers, we implemented variations of our problems into POMDPX and solved them with DESPOT [Somani et al., 2013] and SARSOP [Kurniawati et al., 2009] for 1,000 evaluation runs. To measure whether an action-observation trajectory produced with these solvers aligns with the user's requirements, we check if there exist parameter values ϑ where policy π p b ; ϑ q could produce that trajectory. We use this to evaluate the solutions produced.

7.2 Analysis of Results

For each problem, we evaluated each baseline and PRS variant ten times. The horizon was 12 for Spaceship Repair and 100 for the other problems. The timeout for PRS was set on a problem-byproblem basis. Timeout for Nelder-Mead and Particle Swarm was one hour. Note that the highest expected cost is equal to the horizon due to the default cost function. The performance of each PRS partition selection approach can be found in Figure 4 and the quality of solutions over time compared to the baselines are shown in Figure 3.

Partition selection approach evaluations PRS partition selection approaches converged to a similar quality policy. The only difference was the time taken with approaches that did not rely on the standard deviation converging faster due to there being a lower standard deviation near the optimal solution, causing selection approaches that used the standard deviation to explore the wrong partitions. We use PRS-Bolt as a representative when comparing against the other baselines.

PRS solution quality PRS produced a higherquality policy compared to the ones produced by RCompliant. For Spaceship Repair, the simplest problem solved on the shortest horizon, policies produced by PRS-Bolt had a 15.68% lower expected cost and 3.47% higher goal achievement rate. For the other problems, policies produced by RCompliant had more than triple the expected cost and achieved only half the success rate on both Graph Rock Sample and Store Visit. These results demonstrate that optimizing BSQ parameter values has a significant impact on the performance of user-aligned policies.

PRS-Bolt

PRS-Epsilon

PRS-Local

25

100

Cost

20

75

Expected

15

50

10

25

5

0

%

0

LM

GRS

SR

SV

LM

GRS

SR

SV

Hyperparameter optimization evaluation Compared to traditional hyperparameter optimization algorithms, PRS always found the user-aligned policy with the lowest expected cost with little performance deviation. This is due to Nelder-Mead and Particle Swarm struggling to optimize a nonconvex piecewise-constant function using noisy data, resulting in known problems with local-search algorithms: problems of getting stuck in sub-optimal local minima and exploring the incorrect space. Additionally, PRS converged first since it is more sample-efficient. It is computationally expensive to update the belief state, resulting in poor-quality solutions being more expensive to evaluate due to taking longer to reach the goal. PRS only requires a couple of evaluations before spending the computational resources on more promising areas.

An interesting result is that, in Spaceship Repair, solutions found by Nelder-Mead and Particle Swarm both had a 7.73% higher expected cost and 18.31% higher goal achievement rate than the PRS-Epsilon solutions. There is likely a high negative correlation between the expected cost and goal achievement rate. PRS is better at optimizing the stated objective of minimizing the expected cost.

Unconstrained solver evaluation Without guiding from the parameterized BSQ policies, DESPOT and SARSOP struggled with this set of problems. SARSOP failed to converge to a policy due to the long problem horizon. DESPOT could not run on Lane Merger, which had the largest state space and branching factor. DESPOT also only achieved the goal 0.5% of the time on Graph Rock Sample. DESPOT achieved a lower expected cost of 20.0% and 13.3% on variations of Spaceship Repair and Store Visit, respectively. However, DESPOT's policy never aligned with the user's requirements on Store Visit and only 7.3% of the time on Spaceship Repair. This indicates that the BSQ framework offers a new approach for expressing both domain knowledge and user requirements.

8 Conclusion

We presented the BSQ policy framework for expressing users' requirements over the belief state in partially observable settings for computing user-aligned agent behavior. We performed a formal analysis of these policies, proving that the parameter value space introduced in the parameterized BSQ policies can be partitioned, resulting in parameterized BSQ policies being optimizable through a hierarchical optimization paradigm. We introduced the probabilistically complete Partition Refinement Search algorithm to perform this optimization. Our empirical results show that it converges to the optimal user-aligned policy quicker and more consistently than existing approaches. Results indicate that parameterized BSQ policies provide a promising approach for solving diverse real-world problems requiring user alignment.

Limitations and future work There are many interesting directions for future work based on the current BSQ policy framework. BSQ representations can be made more expressive by allowing deterministic functions, which would not compromise the presented theoretical results. Furthermore, there exists a natural extension of this work into finite memory controllers that allows temporally extended requirements to be encoded with the same theoretical results. Relaxing the constraints on mapping each belief state to a single action would expand the usability. For more complex problems, a belief-state approximation approach would be required, but the underlying strategy tree discussed in this work would remain mostly unchanged. Another interesting research direction is to develop methods that help users express their requirements in the BSQ framework.

Acknowledgments and Disclosure of Funding

This work was supported in part by ONR grant N000142312416 and NSF grant IIS 1942856.

References

Rati Devidze, Goran Radanovic, Parameswaran Kamalaruban, and Adish Singla. Explicable reward design for reinforcement learning agents. In M. Ranzato, A. Beygelzimer, Y. Dauphin, P.S. Liang, and J. Wortman Vaughan, editors, Advances in Neural Information Processing Systems , volume 34, pages 20118-20131. Curran Associates, Inc., 2021. URL https://proceedings.neurips.cc/ paper_files/paper/2021/file/a7f0d2b95c60161b3f3c82f764b1d1c9-Paper.pdf .

Dhawal Gupta, Yash Chandak, Scott Jordan, Philip S. Thomas, and Bruno C. da Silva. Behavior alignment via reward function optimization. In A. Oh, T. Naumann, A. Globerson, K. Saenko, M. Hardt, and S. Levine, editors, Advances in Neural Information Processing Systems , volume 36, pages 52759-52791. Curran Associates, Inc., 2023. URL https://proceedings.neurips.cc/paper_files/paper/2023/file/ a5357781c204d4412e44ed9cbcdb08d5-Paper-Conference.pdf .

Serena Booth, W. Bradley Knox, Julie Shah, Scott Niekum, Peter Stone, and Alessandro Allievi. The perils of trial-and-error reward design: Misdesign through overfitting and invalid task specifications. Proceedings of the AAAI Conference on Artificial Intelligence , 37(5):5920-5929, Jun. 2023. doi: 10.1609/aaai.v37i5.25733. URL https://ojs.aaai.org/index.php/AAAI/article/view/ 25733 .

Tom Everitt and Marcus Hutter. Avoiding wireheading with value reinforcement learning. In Artificial General Intelligence: 9th International Conference, AGI 2016, New York, NY, USA, July 16-19, 2016, Proceedings 9 , pages 12-22. Springer, 2016.

Jorge A Baier, Christian Fritz, and Sheila A McIlraith. Exploiting procedural domain control knowledge in state-of-the-art planners. In ICAPS , pages 26-33, 2007.

Javier Segovia Aguas, Sergio Jiménez Celorrio, and Anders Jonsson. Generalized planning with procedural domain control knowledge. In Proceedings of the International Conference on Automated Planning and Scheduling , volume 26, pages 285-293, 2016.

Cameron Voloshin, Hoang Le, Swarat Chaudhuri, and Yisong Yue. Policy optimization with linear temporal logic constraints. In S. Koyejo, S. Mohamed, A. Agarwal, D. Belgrave, K. Cho, and A. Oh, editors, Advances in Neural Information Processing Systems , volume 35, pages 17690-17702. Curran Associates, Inc., 2022. URL https://proceedings.neurips.cc/paper_files/paper/ 2022/file/70b8505ac79e3e131756f793cd80eb8d-Paper-Conference.pdf .

Rodrigo Toro Icarte, Toryn Q Klassen, Richard Valenzano, and Sheila A McIlraith. Teaching multiple tasks to an rl agent using ltl. In Proceedings of the 17th International Conference on Autonomous Agents and MultiAgent Systems , pages 452-461, 2018.

Pashootan Vaezipoor, Andrew C Li, Rodrigo A Toro Icarte, and Sheila A. Mcilraith. Ltl2action: Generalizing ltl instructions for multi-task rl. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning , volume 139 of Proceedings of Machine Learning Research , pages 10497-10508. PMLR, 18-24 Jul 2021. URL https://proceedings.mlr.press/v139/vaezipoor21a.html .

Jason Liu, Eric Rosen, Suchen Zheng, Stefanie Tellex, and George Konidaris. Leveraging temporal structure in safety-critical task specifications for pomdp planning. 2021.

Mathieu Tuli, Andrew Li, Pashootan Vaezipoor, Toryn Klassen, Scott Sanner, and Sheila McIlraith. Learning to follow instructions in text-based games. Advances in Neural Information Processing Systems , 35:19441-19455, 2022.

Mohamadreza Ahmadi, Rangoli Sharan, and Joel W Burdick. Stochastic finite state control of pomdps with ltl specifications. arXiv preprint arXiv:2001.07679 , 2020.

Giulio Mazzi, Alberto Castellini, and Alessandro Farinelli. Rule-based shielding for partially observable monte-carlo planning. In Proceedings of the International Conference on Automated Planning and Scheduling , volume 31, pages 243-251, 2021.

Giulio Mazzi, Daniele Meli, Alberto Castellini, and Alessandro Farinelli. Learning logic specifications for soft policy guidance in pomcp. arXiv preprint arXiv:2303.09172 , 2023.

Siddharth Srivastava, Xiang Cheng, Stuart Russell, and Avi Pfeffer. First-order open-universe pomdps: Formulation and algorithms. Technical report, Technical report, EECS-2013-243, EECS Department, UC Berkeley, 2012.

Leslie Pack Kaelbling, Michael L Littman, and Anthony R Cassandra. Planning and acting in partially observable stochastic domains. Artificial intelligence , 101(1-2):99-134, 1998.

Richard D Smallwood and Edward J Sondik. The optimal control of partially observable markov processes over a finite horizon. Operations research , 21(5):1071-1088, 1973.

David Silver and Joel Veness. Monte-carlo planning in large pomdps. In J. Lafferty, C. Williams, J. Shawe-Taylor, R. Zemel, and A. Culotta, editors, Advances in Neural Information Processing Systems , volume 23. Curran Associates, Inc., 2010. URL https://proceedings.neurips.cc/ paper_files/paper/2010/file/edfbe1afcf9246bb0d40eb4d8027d90f-Paper.pdf .

Adhiraj Somani, Nan Ye, David Hsu, and Wee Sun Lee. Despot: Online pomdp planning with regularization. Advances in neural information processing systems , 26, 2013.

Moran Barenboim and Vadim Indelman. Online pomdp planning with anytime deterministic guarantees. In A. Oh, T. Naumann, A. Globerson, K. Saenko, M. Hardt, and S. Levine, editors, Advances in Neural Information Processing Systems , volume 36, pages 79886-79902. Curran Associates, Inc., 2023. URL https://proceedings.neurips.cc/paper_files/paper/2023/ file/fc6bd0eef19459655d5b097af783661d-Paper-Conference.pdf .

Michael H Lim, Tyler J Becker, Mykel J Kochenderfer, Claire J Tomlin, and Zachary N Sunberg. Optimality guarantees for particle belief approximation of pomdps. Journal of Artificial Intelligence Research , 77:1591-1636, 2023.

Karl J Astrom et al. Optimal control of markov decision processes with incomplete state estimation. Journal of mathematical analysis and applications , 10(1):174-205, 1965.

Trey Smith and Reid Simmons. Heuristic search value iteration for pomdps. In Proceedings of the 20th Conference on Uncertainty in Artificial Intelligence , UAI '04, page 520-527, Arlington, Virginia, USA, 2004. AUAI Press. ISBN 0974903906.

John A Nelder and Roger Mead. A simplex method for function minimization. The computer journal , 7(4):308-313, 1965.

James Kennedy and Russell Eberhart. Particle swarm optimization. In Proceedings of ICNN'95international conference on neural networks , volume 4, pages 1942-1948. ieee, 1995.

Hanna Kurniawati, David Hsu, and Wee Sun Lee. Sarsop: Efficient point-based pomdp planning by approximating optimally reachable belief spaces. 2009.

A Appendix Organization

The Appendix is organized as follows. Appendix B contains the proofs for showing the expected cost function is piecewise constant. Appendix C contains the proof that PRS is probabilistically complete. Appendix D discusses the evaluation problems and provides the parameterized BSQ policies used. Appendix E discussed additional implementation details of both Nelder-Mead and Particle Swarm. Appendix F discusses two additional partition selection approaches we tested and provides additional analysis of our results. Appendix G discusses the experimental setup and computational cost of our experiments. Appendix H contains the calculated closed-form solution of the partitions for the Spaceship Repair problem. Appendix I discusses the broader impacts of our work. Finally, Appendix J discusses additional limitations not discussed in the main paper.

B Lemmas and Proofs From Formal Analysis [Section 3]

In this section, we provide the formal proofs for Lemma 1, Theorem 1, Theorem 2, and Theorem 3 from Section 3, where we proved that braids partition the parameter space resulting in the expected cost function of a parameterized BSQ policy w.r.t its parameter being piecewise constant. We define and prove Lemmas 2, 3, 4, and 5 in this section for building these proofs.

First, we prove that the similarity operator ' H for braids (Def. 9) has the properties of being reflexive, symmetric, and transitive. As such, ' H defines an equivalence relation over the n-dimensional parameter space R n , meaning it defines a partition over R n .

Theorem 1. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, b 0 be the initial belief state, and H be the horizon. The operator ' H partitions R n .

Proof. Let ϑ P R n be n -parameter values and H be the horizon. By way of contradiction, let's assume that ϑ is not similar to itself, ϑ ı ϑ . This would mean that braid H, 1 p ϑ q ‰ braid H, 2 p ϑ q . As such, there must exist a leaf ℓ , which is in one but not the other braid. Note that ℓ represents a unique rule-observation trajectory t r 1 , o 1 , ..., r H , o H u . Additionally, for ℓ to be in one of these braids it would need to be true that @ i, r i . Ψ p b ˚ i , ϑ q must be satisfied, where b ˚ i ' bp ˚ p b 0 , r 1 , o 1 , ..., r i , o i q (Def. 7). However, note that this would hold true for the other braid as well, making it a contradiction for ℓ to be exclusive in either braid H, 1 p ϑ q or braid H, 2 p ϑ q . As such, ϑ must be similar to itself meaning the similarity property holds.

Let ϑ 1 , ϑ 2 , ϑ 3 P R n where ϑ 1 ' H ϑ 2 and ϑ 2 ' H ϑ 3 . Therefore, braid π,H p ϑ 1 q ' braid π,H p ϑ 2 q and braid π,H p ϑ 2 q ' braid π,H p ϑ 3 q (Def. 7). Using substitution, braid π,H p ϑ 1 q ' braid π,H p ϑ 3 q meaning ϑ 1 ' H ϑ 3 . As such, the transitive property holds.

Due to set equality being symmetric, the symmetric property holds. Thus, the operator ' H is an equivalence relation over R n causing ' H to define a partition over R n .

For compound BSQs Ψ , we now prove that there exist unique intervals of the parameter space where Ψ is satisfied that we can calculate.

Lemma 1. Let Ψ p b ; Θ q be an n-dimensional compound BSQ. There exists a set of intervals I p Ψ q Ď R n s.t. Ψ p b ; Θ q evaluates to true iff Θ P I p Ψ q .

Proof. Let P be a gPOMDP, b be a belief state, Θ P R be a parameter, ˝ be a comparison operator, and φ be a first-order logic formula composed of functions from P . There exist two possible forms for a BSQ (Def. 2). Let λ p p b ; φ, ˝ , Θ q ' Pr J φ K b ˝ Θ . Note that Pr J φ K b evaluates into the probability of φ being satisfied in a belief state b . Therefore, we can simplify λ p p b ; φ, ˝ , Θ q to p ˝ Θ where p P r 0 , 1 s , meaning this type of BSQ simplifies to an inequality. Now, let λ p p b ; φ, ˝ , Θ q ' Pr J φ K b '' 1 where φ is composed of Θ and fully observable functions in P . We assume that Θ cannot be used as a function parameter, meaning that it must be an operand of a relational operator in φ . Since the functions are fully observable, they can be evaluated for b , leaving the inequalities involving Θ to dictate whether φ is satisfied. Thereby, BSQs evaluate to inequalities involving Θ .

A compound BSQ Ψ comprises conjunctions/disjunctions of BSQs by Definition 3 . By substituting each BSQ with its inequalities, we can calculate the interval of Ψ , I p Ψ q .

Let us assume that Θ P I p Ψ q . By way of contradiction, let us assume that Θ does not satisfy Ψ . If Ψ is a conjunction of BSQs, there exists at least one BSQ that is not satisfied by Θ . If Ψ is a disjunction, all the BSQs are unsatisfied by Θ . However, this would mean that Θ cannot satisfy the inequalities from these BSQs, so Θ cannot be in I p Ψ q since I p Ψ q is constructed using the regions of the parameter space that satisfy the necessary BSQs, which is a contradiction.

Conversely, let us assume that Θ satisfies Ψ . This means one or all the BSQs are satisfied by Θ depending on if Ψ is a conjunction or disjunction. If Θ was not in I p Ψ q , there could not exist a set of BSQs satisfied for Ψ to be satisfied.

Thus, for a belief state b , a n-parameter compound BSQ Ψ has an interval in the parameter space I p Ψ q s.t. @ Θ P R n , Θ P I p Ψ q iff Θ p b ; Θ q evaluates true.

As mentioned in Section 3, braids cannot be proper subsets of each other, which we will now prove in Lemma 2. As a high-level intuition, removing a leaf can only occur if a rule along that leaf's rule-observation trajectory is not satisfied, which would mean another rule must be satisfied since Def. 2 guarantees coverage of the belief state and parameter space. This results in at least one leaf being added to a braid that removes this first leaf, making this new braid not a subset of the other one.

Lemma 2. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, b 0 be the initial belief, and H be the horizon. @ ϑ 1 , ϑ 2 P R n , if braid π,H p ϑ 1 q Ď braid π,H p ϑ 2 q then braid π,H p ϑ 1 q ' braid π,H p ϑ 2 q .

Proof. Assume there exists ϑ 1 , ϑ 2 P R n s.t. braid π,H p ϑ 1 q Ă braid π,H p ϑ 2 q implying there exists leaf ℓ 2 where ℓ 2 P braid π,H p ϑ 2 qz braid π,H p ϑ 1 q .

Let ℓ 1 P braid π,H p ϑ 1 q be the leaf with the largest rule-observation trajectory τ 0 prefix shared with ℓ 2 before differing. The trajectory for ℓ 1 can be expressed as τ 0 τ 1 where τ 1 is the remaining trajectory for reaching ℓ 1 . Similarly, the trajectory for ℓ 2 can be expressed as τ 0 τ 2 . Note τ 0 represents the actions executed and observations observed from the initial belief state till right before the diversion resulting in the the belief state b being the same for both leaves up to this point.

If the first element in τ 1 and τ 2 is a rule, note that braid π,H p ϑ 2 q must also contain ℓ 1 . This would imply that π p b ; ϑ 2 q is not mutually exclusive since two rules can occur in one element of the strategy tree. This is a contradiction by Def. 4. If the first element in τ 1 and τ 2 is an observation, different observations occurred after executing the last shared action in τ 0 . Due to the observation model and sharing the belief state b at this point, both observations must be possible. This means a leaf in braid π,H p ϑ 1 q must have a larger shared trajectory prefix than ℓ 1 , which is a contradiction. Thus, braids cannot be strict subsets of each other.

Since braids cannot be proper subsets of each other, we can now prove that both braids must contain leaves the other does not have. In turn, this prevents the interval of braids from overlapping. Note that the interval of a braid can be calculated by taking the intersections of the intervals of each leaf contained in that braid (Def. 8): I p braid π,H p ϑ qq ' Ş ℓ P braid π,H p ϑ q I p ℓ q .

Lemma 3. Let π p b, Θ q be a parameterized BSQ policy, P be gPOMDP, b 0 be the initial belief, and H be the horizon. @ ϑ 1 , ϑ 2 P R n , if braid π,H p ϑ 1 q X braid π,H p ϑ 2 q ‰ ∅ and braid π,H p ϑ 1 q ‰ braid π,H p ϑ 2 q then I p braid π,H p ϑ 1 qq X I p braid π,H p ϑ 2 qq ' ∅ .

Proof. Let ϑ 1 , ϑ 2 P R n where braid π,H p ϑ 1 q X braid π,H p ϑ 2 q ‰ ∅ and braid π,H p ϑ 1 q ‰ braid π,H p ϑ 2 q . Both braids cannot be proper subsets (Lemma 2) meaning both braids must contain leaves that are not in the other braid: braid π,H p ϑ 2 qz braid π,H p ϑ 1 q ‰ ∅ and braid π,H p ϑ 1 qz braid π,H p ϑ 2 q ‰ ∅ .

By Definition 8, the interval of a braid is the conjunction of the intervals of each leaf it contains. Using the associative and commutative properties, this can be rewritten as the conjunction of two sets: the interval of leaves shared and the interval of leaves not.

I p braid π,H p ϑ 1 qq ' I p braid π,H p ϑ 1 q X braid π,H p ϑ 2 qq X I p braid π,H p ϑ 1 qz braid π,H p ϑ 2 q

I p braid π,H p ϑ 2 qq ' I p braid π,H p ϑ 1 q X braid π,H p ϑ 2 qq X I p braid π,H p ϑ 2 qz braid π,H p ϑ 1 q

A braid's interval must exclude these unreachable leaves since a braid is all reachable leaves (Def. 7). As such, I p braid π,H p ϑ 2 qq must not overlap with I p braid π,H p ϑ 1 qz braid π,H p ϑ 2 q and I p braid π,H p ϑ 1 qq must not overlap with I p braid π,H p ϑ 2 qz braid π,H p ϑ 1 q . However, due to the conjunctions of intervals, I p braid π,H p ϑ 1 q Ď I p braid π,H p ϑ 1 qz braid π,H p ϑ 2 q and I p braid π,H p ϑ 2 q Ď I p braid π,H p ϑ 2 qz braid π,H p ϑ 1 q . Thus, the intervals of I p braid π,H p ϑ 1 q and I p braid π,H p ϑ 2 q cannot overlap.

The fact that two braids cannot have overlapping intervals allows us to prove that the sets of parameter values are similar iff they share the same braid interval.

Lemma 4. @ ϑ 1 , ϑ 2 P R n , ϑ 1 ' H ϑ 2 iff I p braid π,H p ϑ 1 qq ' I p braid π,H p ϑ 2 qq .

Proof. Let ϑ 1 ' H ϑ 2 , meaning braid π,H p ϑ 1 q ' braid π,H p ϑ 2 q ' L where L is the set of reachable leaves (Defs. 7 and 9). By Definition 8, the interval of a set of leaves is the intersection of each leaf contained in the set, meaning both braids must have the same interval.

Let I p braid π,H p ϑ 1 qq ' I p braid π,H p ϑ 2 qq . By way of contradiction, assume braid π,H p ϑ 1 q ‰ braid π,H p ϑ 2 q . By Lemma 3, this would mean I p braid π,H p ϑ 1 qq X I p braid π,H p ϑ 2 qq ' ∅ , which is a contradiction. Thus, braid p ϑ 1 q ' braid p ϑ 2 q meaning ϑ 1 ' H ϑ 2 (Def. 9).

We can now prove that partitions produced by ' H partitioning the parameter space R n each represent a single braid, causing each partition to have a disjoint interval where a constant set of leaves is reachable.

Theorem 2. Let π p b, Θ q be a parameterized BSQ policy, b 0 be the initial belief state, and H be the horizon. Each partition ρ created by operator ' H partitioning R n is the disjoint intervals, ρ Ď R n where @ ϑ P ρ , braid π,H p ϑ q ' L where L is a fixed set of leaves.

Proof. Let ρ be a partition produced by ' H partitioning the parameter space R n . Note that this means that parameter value sets contained in ρ must be similar (Def. 9): @ ϑ 1 , ϑ 2 P ρ, ϑ 1 ' H ϑ 2 . As such, all parameter values have the same braid (Def. 7), meaning there exists a set of leaves L that are reachable in ρ . By Def. 8, this set's interval must be I p L q ' Ş ℓ H P L I p ℓ H q . By Lemma3, the interval of other braids cannot overlap with I p L q . Also, there are no proper subsets (Lemma 2), meaning that no other braid can occur in I p L q making it disjoint.

By Def. 8, I p L q must be contained in ρ due to all parameter value sets in I p L q having the same braid of L leaves. If ρ contained parameter value sets not in I p L q , this would imply there exists ϑ outside of I p L q where just the leaves in L are reachable, which is a contradiction due to I p L q being the only interval space where all the leaves of L are reachable. Meaning the interval of ρ is actually I p L q . Thus, each partition represents a disjoint interval where only all leaves in L are reachable.

Due to the braid intervals not overlapping, we can prove that parameter value sets contained in that braid's interval must have a constant expected cost.

Lemma 5. Let π p b, Θ q be a parameterized BSQ policy and H be the horizon. @ ϑ 1 P R n , @ ϑ 2 , ϑ 3 P I p braid p ϑ 1 qq , E π p ϑ 2 ; H q ' E π p ϑ 3 ; H q .

Proof. Let ϑ 2 , ϑ 3 P I p braid π,H p ϑ 1 q where ϑ 1 P R n is a tuple of n parameters. Note that braid p ϑ 1 q ' braid p ϑ 2 q ' braid p ϑ 3 q due there being no strict subsets (Lemma 2) and leaves in ϑ 2 and ϑ 3 would have to be reachable in ϑ 1 . Each braid represents a policy tree (Def. 5), and the expected cost is based on the probability distribution of leaves in the braid. Since both ϑ 2 and ϑ 3 represent the same policy tree, they must have identical expected cost values.

It is now trivial to show that each partition represents a disjoint interval of the parameter space where the expected cost is constant.

Theorem 3. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, b 0 be the initial belief state, and H be the horizon. Each partition created by ' H on R n has a constant expected cost.

Proof. Let ρ be a partition created by partitioning R n with ' H . By Theorem 2, all parameter value sets in the disjoint interval of ρ must have the same braid. As such, by Lemma 5, the expected cost is constant for all the parameter sets. Thus, the disjoint interval of each partition must have a constant expected cost.

C Proofs For Partition Refinement Search [Section 5]

In this section, we provide the formal proof for Theorem 4 proving that the Partition Refinement Search algorithm introduced in Section 5 is probabilistically complete. We define and prove Lemmas 6, 7, and 8 for building this proof.

When PRS refines a partition ρ using a leaf ℓ , it can produce up to two possible partitions: a partition for ρ where ℓ is reachable and a partition for ρ where ℓ is not (if it exists). We now show that this process prevents empty partitions.

Lemma 6. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, b 0 be the initial belief state, and H be the horizon. For each partition ρ constructed by Partition Refinement Search, ρ ‰ ∅ .

Proof. Let ρ Ď R n be a partition constructed by PRS. Since PRS creates partitions based on whether sampled leaves are included or excluded, let L i be the leaves PRS included in partition ρ and L e be the leaves excluded. Therefore, ρ ' I p L i qz I p L e q .

By way of contradiction, let ρ ' ∅ . There are two cases where this could occur: (1) excluding leaf ℓ caused ρ ' ∅ or (2) including ℓ caused ρ ' ∅ . For case (1), we explicitly do not add partitions if excluding the leaf results in an empty interval, meaning this cannot happen. For case (2), this implies that there exists a previous partition ρ 0 where sampling leaf ℓ 0 resulted in the partition constructed from ρ 0 including ℓ 0 creating ρ where ρ ' ∅ . Due to ℓ 0 being uniformly sampled from ρ 0 , ℓ 0 must be reachable in ρ 0 meaning ρ 0 X I p ℓ 0 q ‰ ∅ . However, line 10 of Algo. 1 calculates the interval of ρ as ρ 0 X I p ℓ 0 q meaning ρ ‰ ∅ , which is a contradiction. Thus, all partitions must be not empty.

A critical property of PRS is that each partition constructed converges to represent a single braid.

Lemma 7. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, b 0 be the initial belief state, and H be the horizon. Let ρ be a partition constructed by Partition Refinement Search. If all leaves reachable in ρ Ď R n have been sampled, @ ϑ P ρ, I p braid π,H p ϑ qq ' ρ .

Proof. Let ρ Ď R n be a partition constructed by PRS. Let L ρ ' t ℓ 1 , ..., ℓ n u be the n-sampled unique leaves for ρ . Let all leaves reachable from ρ be sampled, @ ℓ, ℓ P L ρ ØrD ϑ P ρ, ℓ P braid π,H p ϑ qs .

Due to ρ ‰ ∅ (Lemma6) and parameterized BSQ policies covering R n (Def. 4), there must exist a non-empty set of leaves L reachable within ρ . Since all leaves are sampled, we know that L Ď L ρ . However, there cannot be proper subsets (Lemma 2) meaning L ' L ρ . This means that the interval of ρ must also equal the interval of leaves I p L q . Thus, ρ must represent a braid.

Since partitions are constructed by including/excluding sampled leaves hierarchically, we can prove that this makes each partition represent a unique braid.

Lemma 8. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, b 0 be the initial belief state, and H be the horizon. Let ρ 1 , ρ 2 Ď R n be partitions constructed by Partition Refinement Search. If all leaves reachable in ρ 1 and ρ 2 have been sampled, @ ϑ 1 P ρ 1 , @ ϑ 2 P ρ 1 , braid π,H p ϑ 1 q ‰ braid π,H p ϑ 2 q .

Proof. Let ρ 1 , ρ 2 Ď R n be two different partitions constructed by PRS. Note that the PRS partitions R n by refining one partition using leaf ℓ into two by explicitly including I p ℓ q in one partition and excluding I p ℓ q in the other (Algorithm 1). Meaning ρ 1 and ρ 2 cannot overlap.

Since both partitions represent a possible non-empty braid (Lemma 7), there exists a set of leaves reachable in both partitions. However, by the partition construction process, there must exist at least one leaf included in one but excluded in the other. Due to there being no interval overlap between braids, two different braids must be reachable in each partition (Lemma 2). Thus, all partitions must represent a unique braid.

Using the property that each partition in PRS represents a unique braid, we can now prove that PRS is probabilistically complete.

Theorem 4. Let π p b, Θ q be a parameterized BSQ policy, P be a gPOMDP, b 0 the initial belief state, and H be the horizon. The likelihood of the Partition Refinement Search algorithm returning the optimal parameter interval converges to one in the limit of infinite samples.

Proof. Note that gPOMDPs have a finite set of observations and finite horizon (Def. 1), and parameterized BSQ policies have a finite number of rules (Def. 4). As such, there exists a finite number of unique rule-observation trajectories in the strategy tree (Def. 6). Therefore, there exists a finite number of leaves due to each leaf having a unique rule-observation trajectory. This results in there only being a finite set of braids being all possible combinations of reachable leaves (Def. 7). Since each partition represents a unique braid (Lemma 8), the number of partitions must be finite.

Let ρ Ď R n be a partition constructed by PRS that is not equivalent to a braid. By Lemma 7, this means there exists a leaf ℓ reachable in ρ that has not been sampled yet. This also means there must exist a non-empty interval ρ X I p ℓ q where sampling from ρ can reach ℓ . Due to uniform sampling selecting parameter values when sampling a leaf for refining the partition (line 7 of Algorithm 1), the probability of selecting a parameter value that could sample ℓ can be calculated as ρ X I p ℓ q ρ ' Pr p I p ℓ q| ρ q .

Note that ℓ represents a unique rule-observation trajectory t r 1 , o 1 , ..., r H , o H u . Note the probability of an observation o being observed in belief state b after action a is executed is Pr p o | b, a q ' ř s 1 r Ω p s 1 , a, o q ř s T p s, a, s 1 q b p s qs . Meaning that the probability of reaching ℓ during rollout is Pr p ℓ q ' ś i Pr p o i | b i q where b i ' bp ˚ p b 0 , r 1 , o 1 , ..., r i , o i q . Since we know that ℓ is reachable, Pr p ℓ q ą 0 .

We assume that partition selection approaches discussed in Section 6 have a non-zero probability of refining any partition. Let Pr p ρ q be the probability of ρ being selected. This means that in any refinement step, the probability of sampling leaf ℓ is Pr p ℓ q Pr p I p ℓ q{ ρ q Pr p ρ q . Due to each probability being greater than zero, the probability of any non-sampled leaf being sampled must be greater than zero. Therefore, with enough refinement steps, all the leaves will be sampled since there is only a finite number of leaves. Thus, the set of partitions will be refined to the set of braids as the number of samples increases to infinite.

Note that each partition represents a unique braid (Lemma 8) with a set probability distribution of outcomes based on the reachable leaves. Due to a non-zero probability of refining a partition Pr p ρ q , the sampled expected cost of a partition will converge to the actual expected cost due to the law of large numbers.

Therefore, within a finite number of samples, the partitions constructed by PRS will accurately represent the set of braids with an accurate representation of their expected costs. Thus, PRS will find the minimal expected cost partition as the number of samples increases to infinite.

D Evaluation Problem's Belief-State Query Preferences

In this section, we provide the parameterized BSQ policies for the Lane Merger, Graph Rock Sample, and Store Visit problems discussed in Section 7. To do this, we first describe the functions that compose each problem's states and actions. We use loops and quantifiers in the parameterized BSQ policies for clarity that can be unrolled on a problem-by-problem basis.

D.1 Lane Merger

The Lane Merger problem is that there are two lanes, and the agent must merge into the other lane within a certain distance. In this other lane, there is another car whose exact location and speed are unknown. Therefore, there exist two objects in the environment: the agent (agent) and the other car (other). For either object o , the location and speed are tracked using the unary integer functions loc p o q and speed p o q . For actions, the agent can increase their speed ( speed _ up pq ), decrease their speed ( slow _ down pq ), remain in their current lane at their current speed ( keep _ speed pq ), or attempt to merge lanes ( merge pq ). Using these functions, the parameterized BSQ policy π lm p b ; Θ 1 , Θ 2 q is formally defined as follows.

D.2 Graph Rock Sample

The Graph Rock Sample problem is that there is a rover with pre-programmed waypoints, where some waypoints contain rocks. These rocks have been categorized into types, and whether it is safe for the rover to sample them is unknown. The objective of the rover is to sample each type with a safe rock before traversing to a dropoff location. The objects are the waypoints, including the rocks t r 1 , ..., r n u and the dropoff location (dropoff). The rover knows if or if it is not located at waypoint w using the unary Boolean function loc p w q . The rover also knows whether it needs to sample rocks of type t using the unary Boolean function needed p t q . For any rock r , the distance from the rover, whether the rock is type t , and if the rock is safe to sample are tracked using the unary double function distance p r q and the Boolean functions type p r, t q , and safe p r q , respectively. The rover can move to neighboring waypoint w ( move p w q ), sample rock r at its current waypoint ( sample p r q ), and scan any rock r ( scan p r q ). For clarity, we use the function goto p w q to specify taking the edge that moves the rover closer to waypoint w . Using these functions, the parameterized BSQ policy π grs p b ; Θ 1 , Θ 2 , Θ 3 q is formally defined as follows.

D.3 Store Visit

The Store Visit problem involves an agent in a city with a grid-based layout. Some locations are unsafe, while others contain a bank or a store. The objective is for the agent to visit a bank safely and then a store. The objects are the agent, the set of stores t s 1 , ..., s n u , and the set of banks t b 1 , ..., b m u . Labeling functions bank p o q and store p o q check whether object o is a bank or store, respectively. The ternary Boolean function keeps track of the current p x, y q location of the object o , loc p o, x, y q . Similarly, whether location p x, y q is safe is tracked by the binary Boolean function is _ safe p x, y q . Lastly, the state keeps track of whether the agent has visited a bank using the nullary Boolean function vbank pq . The agent can move left ( left pq ), right ( right pq ), up ( up ), and down ( down pq ) in the grid. The agent can also visit a building in its current location ( visit pq ) or scan its surroundings to figure out its location ( scan pq ). Using these functions, the parameterized BSQ policy π sv p b ; Θ 1 , Θ 2 , Θ 3 q is formally defined as follows.

E Hyperparameter Optimization Algorithms Implementation

As a baseline comparison, we implemented Nelder-Mead and Particle Swarm as hyperparameter optimization algorithms to compare solving for the optimal parameter values for a parameterized BSQ policy to minimize the expected cost of the resulting BSQ policy. Both algorithms evaluate points in the parameter space to decide which areas to explore next. For both, we evaluate a parameter point by taking a thousand parallel runs of the BSQ policy with those values to approximate the expected cost.

Nelder-Mead We used a simplex that has edges numbering one more than the number of parameters in the parameterized BSQ policy being optimized. To start with a better initial simplex, we randomly sampled a hundred points and tracked the points that had lower expected costs and were 0.4 distance away from each of the better-performing points. The closer points were saved but were given a lower priority. Each iteration followed the standard Nelder-Mead steps with the sum quality of all the edges in the simplex calculated. If five iterations pass without an increase in quality, the run is deemed to have converged, and the best quality point of the simplex is returned as the solution.

Particle Swarm Particle swarm used 10 particles randomly selected from within the parameter space with a random velocity. Let t be the number of iteration steps since the last improvement in the best quality point found. For each iteration, the cognitive coefficient is 1 . 0 ´ 0 . 1 t , and the social coefficient is 0 . 1 ` 0 . 1 t , which causes the particles to become more greedy as time since the last improvement increases. The momentum is statically set to 0.6 with the velocity clipped between ˘ 0 . 5 . The location of points is also clipped to the parameter search space. If 10 iteration steps pass without seeing an improvement, the run is deemed to have converged, and the best quality point of the swarm is returned as the solution.

0

10

20

30

Expected Cost

0

10

20

30

40

0.0

2.5

5.0

7.5

10.0

Spaceship Repair

0

20

40

60

Store Visit

0

40

80

120

0

25

50

75

100

% Goal Achievement

0

40

80

120

0

25

50

75

100

0

10

20

30

0

25

50

75

100

0

50

100 150 200

0

25

50

75

100

PRS-Bolt

PRS-Epsilon

PRS-Local

PRS-Global

PRS-Max

Time (Seconds)

F Additional Results

In this section, we provide additional results from the experiments performed. This includes introducing two additional partition selection approaches we evaluated: Global Thompson Sampling and Maximum Confidence. We also provide graphs of the performance of the hypothesized optimal partition across all PRS variants. Finally, we provide a results table for all five partition selection approaches and the baseline RCompliant.

PRS is implemented for multiprocessing by having each process manage a subset of the partitions X 1 Ď X but share a global hypothesis of the optimal partition. Also, a dynamic exploration rate e r is used that diminishes over the solving time. Using this framework, two additional partition selection approaches were explored.

Maximum Confidence (PRS-Max) We explore e r percent of the time by uniformly sampling s ' U 1 0 and checking if s ď e r . If exploring, we uniformly at random select a partition from X 1 . Otherwise, the partition with maximum standard deviation, arg min x ρ, ˆ E r ρ syP X 1 σ p ˆ E qr ρ s , is selected.

Global Thompson Sampling (PRS-Global) Unlike the other partition selection approaches, each processor iterates over all partitions it manages before selecting multiple partitions to refine. Partitions are chosen for two reasons: (1) they are below the minimum number of samples, or (2) the partition has the potential of being better than the current global hypothesized optimal partition. This is simulated for each partition using N p µ c , σ c ˆ e r q with µ c and σ c being the mean and standard deviation of that partition, respectively. If the sample taken from this normal distribution has a lower expected cost than the hypothesized optimal partition, this partition is selected for refinement.

Performance of the hypothesized optimal In Figure 5, the hypothesized optimal over the runtime of PRS for each partition selection approach is shown. On Lane Merger and Spaceship Repair, the performance of each PRS variant is quite similar, with the solver quickly converging to a near-optimal policy. However, PRS-Global has a much slower convergence rate due to trying to evaluate all promising partitions rather than focusing on the most promising ones. This resulted in PRS-Global not converging before timeout on Store Visit. PRS-Max is expected to perform poorly due to its poor partition-selection strategy. These results highlight that, with a competent partition-selection strategy, PRS will converge to the optimal policy that minimizes the expected cost, with the main variation being the convergence time.

Tabulated performance In Table 1 and Table 2, the expected cost and the goal achievement rate have been tabulated, showing the near identical performance of four of the partition refinement approaches. The solution for Nelder-Mead and Particle Swarm are taken at PRS's timeout time to give each solver the same solving time. For all the problems, the more effective partition-selection approaches

discussed in the main paper achieved equal, if not better, performance than Nelder-Mead and Particle Swarm.

G Experimental Setup And Computational Cost

In this section, we go through the empirical setup of the experiments performed in Section 7 and include an estimate of the computation cost for running the experiments for this paper.

All experiments were performed on an Intel(R) Xeon(R) W-2102 CPU @ 2.90GHz without using a GPU. The Partition Refinement Search algorithm was implemented using a manager-worker design pattern where 8 workers were initialized when solving. The manager maintained the hypothesized optimal partition and current exploration rate. Table 3 shows the timeout and sample rate used for each problem for PRS. PRS was allowed to use an addition minute beyond timeout in the case the hypothesized optimal partition had less than the minimum allowed samples, however this case did not occur.

Both solutions and recorded hypothesized optimal partitions were evaluated using the same random seed to ensure that the same initial states were assessed. This evaluation process was carried out in parallel using a manager-worker design pattern with 16 workers. 25,000 independent runs were conducted for each solution to determine the expected cost and goal achievement rate. Additionally,

for each recorded hypothesized optimal partition, 10,000 runs were performed. The average performance and standard deviation error were calculated by averaging the results of ten runs for each combination of problem and solver. A similar approach was used to evaluate the random-parameter user-compliant policy RCompliant. Instead of using solved policies, ten parameter value sets were uniformly selected randomly from the parameter space, and each set was evaluated for 25,000 runs. These results are presented in Figure 3.

For constructing the Spaceship Repair heatmap (Figure 1), all combinations of parameters Θ 1 and Θ 2 were evaluated with parameter values sampled from 0 to 1 with increments of 0.002. This produced 251,001 equally-spaced parameter values. Parameter values were evaluated on 300 runs with a horizon of 12 to calculate the expected cost.

Computational cost Running the Partition Refinement Search algorithm for the empirical evaluation section (Section 7) involved nine processes running simultaneously for 25 minutes across ten trials for each of the five partition-selection approaches. This resulted in 1.58 hours of CPU usage when run in parallel, equivalent to 14.22 hours if executed sequentially. Evaluation complexities were significant, such as the variance in time per run and problem type. For instance, evaluating the solutions and hypothesized optimal partitions for the Lane Merger problem using 17 processes took approximately 48 hours in parallel. The overall CPU usage for the main experiment approximates to 360 hours (15 days) in parallel, translating to about 6,288 hours (262 days) if run sequentially. Additionally, constructing the Spaceship Repair heatmap (Figure,1) required approximately 24 hours of CPU time using 11 processes. These experiments were conducted thrice, culminating in an estimated total computational cost of 2,160 hours (90 days) using an Intel(R) Xeon(R) W-2102 CPU @2.90GHz, or 19,656 hours (819 days) if operations were performed sequentially.

H Spaceship Repair Partitions Closed Form

In this section, we calculate the braids that partition the parameter space for the Spaceship Repair problem with the parameterized BSQ policy from Fig. 1.

First, we give the exact observation model used. From Section 3.1, the Spaceship Repair state is composed of two functions: broken p o q and rlocation pq . This means each state is expressed as t broken p robot q , broken p ship q , rlocation pqu . Additionally, the set of observations can be expressed as t obs _ err p robot q , obs _ err p ship qu . Let p r and p s be the probability of the observation reflecting the actual state of the robot and spaceship, respectively. The probability of observation o in state s after action a is executed is calculated as follows.

Note observations are independent of the robot's location and actions. For clarity, we express the states as whether or not the robot and spaceship are broken, t broken p robot q , broken p ship qu . This means there are four possible states depending on whether the robot and ship are broken. For ease of notation, we represent these states as S ' t s TT , s TF , s FT , s FF u , where s TF represents that state where the robot is broken and the spaceship is not. Similar, let the four possible observations be represented as O ' t o TT , o TF , o FT , o FF u .

The precondition of the first rule of the Spaceship Repair problem parameterized BSQ policy is J broken p robot q K b ď Θ 1 (Figure 1). For any belief state b , the probability of the robot being broken is the probability of the states where that is true: J broken p robot q K b ' b p s TT q ` b p s TF q .

Let t a 1 , o 1 , ..., a t , o t u be an action-observation trajectory for t timesteps where at each timestep an action is executed followed by an observation being observed. We can calculate the probability of the state where the robot and spaceship are broken, s TT , as follows.

Note that, due to the observations being independent of the robot's location, the observation and transition functions are independent of the action. For example, there is no action the robot can perform to change whether the robot or spaceship is broken due to the problem being to reach a broken component rather than fixing it. We can simplify Equation 2 significantly as follows.

We can now rewrite Equation 3 by unrolling the recursion. Note that α is the normalization factor meaning we don't need to calculate α each timestep because the final normalization will factor in all these changes. Additionally, due to the probability of each initial state being uniform, we don't need to keep track of the initial belief. Also, note there exist four possible observations. Due to the commutativity of multiplication, we can rearrange to get the following. Let c TT , c TF , c FT , and c FF be the counts of the number of each observation where c TT ` c TF ` c FT ` c FF ' t .

Using Equation 1, the probability of this state can be written in terms of p r and p s .

This same process can be applied to the other three states to get the equation of their likelihoods.

We can group the states into two groups depending on whether or not the robot is broken. By factoring we can get the following.

Note that in Equations 10 and 11 everything in the brackets is shared, which is due to the individual observations of the spaceship and robot being independent of each other. Also, for normalization, we just divide the sum of Equations 10 and 11, which is equivalent to the sum probability of all states. Additionally, note that Equation 10 is equivalent to the BSQ precondition J broken p robot q K b t . Substituting into this BSQ and simplifying we get the following.

Note that there are two exponent values: the number of times the robot is observed to be broken and the number it is not. Let d r ' c TT ` c TF ´ c FT ´ c FF be the difference in the number of times that the robot is observed to be broken to not. If d r ą 0 , then the robot has been observed to be broken more often than not. By substituting d r ` c FT c FF ' c TT ` c TF into Equation 12 the equation simplifies down.

Following a similar process, the BSQ from the second rule in the parameterized BSQ policy from Figure 1 can be written similarly. Let d s be the difference in the number of times the spaceship is observed to be or not. If d s ą 0 , then the spaceship has been observed to be broken more often than not.

Note that the observation model used p r ' 0 . 6 and p s ' 0 . 75 for the heatmap in Figure 1. The horizontal thresholds can be calculated using Equation 14 and the vertical with Equation 13.

Therefore, a partition is specific value of d r P Z and d s P Z that is equivalent to saying: The objective is to fix the communication channel. If the difference in the number of times the robot has been observed being broken than not is greater than d r , it should try to repair itself; otherwise, if the difference in the number of times the spaceship has been observed being broken than not is greater than d s , it should try to repair that. Formally, this partition represents the parameter space where p dr ´ 1 r p dr ´ 1 r `p 1 ´ p r q dr ´ 1 ď Θ 1 ă p dr r p dr r `p 1 ´ p r q dr and p ds ´ 1 s p ds ´ 1 s `p 1 ´ p s q ds ´ 1 ď Θ 2 ă p ds s p ds s `p 1 ´ p s q ds where all parameter value sets that satisfy both inequalities are similar. Due to d r and d s being the difference between observation counts, the set of possible partitions is finite for finite horizons.

We explored solving the Spaceship Repair problem directly using these inequalities. The belief state reflects the probability of each outcome, meaning the main challenge is calculating the average number of timesteps to reach the goal. This can be solved by finding the average length of time of the Gambler's Ruin problem. One possible direction of future work is exploring solving parameterized BSQ policies and gPOMDPs this way.

I Broader Impacts

The primary positive impact of parameterized BSQ policies is their accessibility to non-experts, allowing them to input their requirements directly into a solver that optimizes the completion of tasks while aligning with the user. Moreover, parameterized BSQ policies enable encoding safety constraints with enforceable guarantees over the belief state. Thus, this paper represents an important step in making AI more usable for non-experts, particularly in encoding constraints and preferences, while addressing safety concerns in real-world applications."

A potential negative impact of making AI more accessible through parameterized BSQ policies is that it could also be exploited by bad actors who might encode harmful preferences. To mitigate this risk, one approach is to design goals such that negative outcomes inherently prevent goal completion, thereby teaching the agent to avoid these outcomes. Additionally, future work can explore methods for prioritizing certain constraints to ensure that the AI does not align with harmful intentions.

J Additional Limitations

While we discussed in Section 8 some of the limitations of this work, one additional limitation is an essential direction of future work: aligning user and problem objectives. For example, in Graph Rock Sample, if the encoded goal for the gPOMDP did not require collecting rocks but the user still wanted to collect one rock of each type using the parameterized BSQ policy in Appendix D.2, PRS would optimize the parameters to make it so no rocks are worth scanning or sampling to exit as fast as possible to minimize the expected cost. While this case is an obvious misalignment between the gPOMDP and parameterized BSQ policy, these misalignments can be more subtle, leading to the optimal policy not behaving as intended. Therefore, future work needs to be done to explore catching misalignments to allow the user to understand and fix them.

NeurIPS Paper Checklist

1. Claims

Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?

Answer: [Yes]

Justification: The claims made in both the abstract and introduction reflect the paper where we introduced a new framework for user preferences (Section 3), performed a formal analysis of it (Section 4), introduced a piecewise constant algorithm (Section 5), and empirically evaluated this algorithm (Section 7).

Guidelines:

The answer NA means that the abstract and introduction do not include the claims made in the paper.

The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.

The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.

It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.

2. Limitations

Question: Does the paper discuss the limitations of the work performed by the authors?

Answer: [Yes]

Justification: Please refer to both Section 8 and Appendix J.

Guidelines:

The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.

The authors are encouraged to create a separate "Limitations" section in their paper.

The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.

The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.

The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.

The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.

If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.

While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.

3. Theory Assumptions and Proofs

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

Answer: [Yes]

Justification: Refer to Appendix B and Appendix C for the formal proofs of the lemmas and theorems defined in the paper.

Guidelines:

The answer NA means that the paper does not include theoretical results.

All the theorems, formulas, and proofs in the paper should be numbered and crossreferenced.

All assumptions should be clearly stated or referenced in the statement of any theorems.

The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition.

Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.

Theorems and Lemmas that the proof relies upon should be properly referenced.

4. Experimental Result Reproducibility

Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?

Answer: [Yes]

Justification: Both the code has been provided in the supplementary material and the detailed methodology can be found in Appendix G.

Guidelines:

The answer NA means that the paper does not include experiments.

If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.

If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.

Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.

While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example

(a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.

(b) If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.

(c) If the contribution is a new model (e.g., a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).

(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.

5. Open access to data and code

Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?

Answer: [Yes]

Justification: The code used for this paper has been provided in the supplementary material.

Guidelines:

The answer NA means that paper does not include experiments requiring code.

Please see the NeurIPS code and data submission guidelines ( https://nips.cc/ public/guides/CodeSubmissionPolicy ) for more details.

While we encourage the release of code and data, we understand that this might not be possible, so 'No' is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for a new open-source benchmark).

The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines ( https: //nips.cc/public/guides/CodeSubmissionPolicy ) for more details.

The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.

The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why.

At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).

Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted.

6. Experimental Setting/Details

Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?

Answer: [Yes]

Justification: Refer to Appendix G for a detailed methodology.

Guidelines:

The answer NA means that the paper does not include experiments.

The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them.

The full details can be provided either with the code, in appendix, or as supplemental material.

7. Experiment Statistical Significance

Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?

Answer: [Yes]

Justification: In both Section 7 and Appendix F, all shown results are shown with standard deviation error. Additionally, we make it clear in both sections that we are using standard deviation error.

Guidelines:

The answer NA means that the paper does not include experiments.

The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.

The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)

The assumptions made should be given (e.g., Normally distributed errors).

It should be clear whether the error bar is the standard deviation or the standard error of the mean.

It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified.

For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).

If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.

8. Experiments Compute Resources

Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?

Answer: [Yes]

Guidelines:

The answer NA means that the paper does not include experiments.

The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.

The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.

The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper).

9. Code Of Ethics

Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines ?

Answer: [Yes]

Justification: We have reviewed and can confirm our research conforms to NeurIPS Code of Ethics.

Guidelines:

The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.

If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics.

The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction).

10. Broader Impacts

Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?

Answer: [Yes]

Guidelines:

The answer NA means that there is no societal impact of the work performed.

If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.

Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.

The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.

The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.

If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).

11. Safeguards

Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?

Answer: [NA] .

Justification: This paper poses no risk of being misused.

Guidelines:

The answer NA means that the paper poses no such risks.

Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.

Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.

We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.

12. Licenses for existing assets

Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?

Answer: [NA]

Justification: This paper does not use existing assets.

Guidelines:

The answer NA means that the paper does not use existing assets.

The authors should cite the original paper that produced the code package or dataset.

The authors should state which version of the asset is used and, if possible, include a URL.

The name of the license (e.g., CC-BY 4.0) should be included for each asset.

For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.

If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset.

For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.

If this information is not available online, the authors are encouraged to reach out to the asset's creators.

13. New Assets

Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?

Answer: [Yes]

Justification: Documentation on the code used in this paper is provided with the code.

Guidelines:

The answer NA means that the paper does not release new assets.

Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.

The paper should discuss whether and how consent was obtained from people whose asset is used.

At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.

14. Crowdsourcing and Research with Human Subjects

Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?

Answer: [NA]

Justification: This paper does not involve crowdsourcing nor research with human subjects. Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper.

According to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.

15. Institutional Review Board (IRB) Approvals or Equivalent for Research with Human Subjects

Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?

Answer: [NA]

Justification: This paper does not involve crowdsourcing nor research with human subjects. Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.

We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.

For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.

Peer reviews:
comments: SUMMARY:
This paper proposes a method for computing optimal policy in a given POMDP and a specific policy class (the class of BSQ policies).

STRENGTHS:
In this work, to ensure compliance with user's preference, the policies are directly parameterized by the preferences (formalized by boolean formulas). This approach is quite different from the more well-known approach of including preferences in the objective function, and it is worth investigating.

WEAKNESSES:
(1) Readability: This paper introduces many heavy notations. The definitions (of BSQ, policies, etc.) are pretty abstract.

(2) The policies are defined using BSQ. The expressiveness of such a policy class is not well-justified: it is not clear whether this policy class includes all policies that comply with the agent's preferences.

(3) The experiments are performed on several different environments, but the uniformly random baseline (RCompliant) is probably too weak.

QUESTIONS:
N/A

LIMITATIONS:
N/A
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2024-07-11

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper provides a method for computing policies with user preferences called belief state queries (BSQ). A BSQ consists of a condition and a desired action and can be used for expressions like: \"Given a high likelihood of a, do b.\" To express this, the condition of a BSQ compares the probability of a first-order logic formula over the belief to a threshold. This paper aims to find the threshold values for a BSQ and the corresponding policy that minimizes the number of steps required to reach the goal states with a positive probability.\n\nThe authors give a theoretical analysis, showing that the expected cost function, i.e., the number of steps to reach the goal states for the first time, for a BSQ-compliant policy is piecewise constant. These piecewise constant areas of the expected cost function can be used to partition the parameter space. Using this result, they develop an algorithm for computing the threshold values for the optimal BSQ-compliant policy. They try various partition refinement algorithms and compare their resulting BSQ-compliant policies against a policy using uniformly selected random partitions (RCompliant). The results show that their BSQ-compliant policies have a lower expected cost and a higher probability of goal achievement than the RCompliant policies.\n\nSTRENGTHS:\n- The problem of user-preference compliant policy computation in a partially observable setting is interesting. It allows specifying additional objectives for the agent that cannot be directly expressed with LTL, as the agent cannot observe the complete state of the model.\n- The definition of BSQs allows the specification of user preferences in more natural language, making it accessible to non-experts.\n- The paper removes limitations from previous works: the difficulty of guarantees in reward calibration approaches, the need for past traces in the works of Mazzi et al., and the lack of a formal analysis in the work of Srivastava et al.\n\nWEAKNESSES:\n-- I raise my score after the rebuttal of the authors with an additional evaluation of the method -- \n\n- The experimental comparison is limited. It would have been interesting to see how the approach compares to the reward calibration approaches that do not guarantee preference compliance or the referenced works of Mazzi et al. There is no mention of why this comparison would not be possible. Another interesting comparison would be to compare to a non-BSQ-compliant policy and analyze the difference in probability of reaching the goal states and satisfying the BSQ. Such a comparison would give insight into the gains and losses of being BSQ-compliant.\n- Information about the sizes of the problems used for the experiments is missing, making it difficult to estimate the strength of the approach.\n- The definition of the goal-oriented POMDPs is hard to follow. It is still unclear to me where the constant symbols are used, why the states S are defined as valuations for Vf, how the set of state variables for a function F follows from instantiations of F, and what the type of F is. The second part, starting with the definition of the transition function, is clear. The part before that is not.\n\nI list a couple of questions related to these weaknesses, and I am happy to reconsider the score depending on the answers.\n\nMinor comments:\n- The paper mentions relational goal-oriented POMDPs at the start of section 3, but afterward, only goal-oriented POMDPs are explained.\n- Grounded state is mentioned without explanation (L59). This term is not familiar to me.\n- Figure 2a contains a lot of information introduced in different parts of the text. Perhaps this can be split into two iterative figures for clarity.\n- I think the input theta for the compound BSQ in lemma 1 (L220) should be a capital theta.\n- Definition 9 (L204) contains a curly P to many.\n- The R with superscript 1 and subscript 0 (L503) was not introduced.\n- The union between the expected cost of a partition and the expected cost of a leaf in Algorithm 1 line 10 seems a bit weird. Is this the correct operator? If so, a small explanation would be helpful.\n\nQUESTIONS:\n1. What is the motivation for minimizing the cost instead of maximizing the probability of reaching the goal states?\n2. Is there a reason for not comparing your approach to other existing approaches? Can you give some intution on how the approaches would compare to each other?\n3. What are the sizes of the problems used for the experimental evaluation? What makes them challenging (L327)?\n4. Why is the comparison sign not an input for the BSQ?\n5. Definition 1 (goal-oriented POMDPs) uses unintroduced symbols (the non-curly F, O, and T). Is this correct? If so, what do they mean?\n6. Can you clarify Definition 1 (goal-oriented POMDP)? See weaknesses for the unclear parts.\n\nLIMITATIONS:\nThe authors addressed the limitations of their work, discussing the impact on their results.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-07-11"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper introduces a method for partially observable policy optimization under belief-state query (BSQ) policy constraints (or in the author's terminology, preferences). A BSQ preference, as defined by the authors, is a class of policies parameterized by probability thresholds $\\theta$ on beliefs about certain propositions. Fixing the thresholds to particular values results in a BSQ policy --- a policy that branches on (conjunctions of) threshold-based predicates about the agent's belief state, taking certain actions if the agent believes with high enough probability that some proposition $\\phi$ if true, and going into another branch if the condition is not met.\n\nAfter introducing these definitions, the paper proves a number of theoretical results, including the result that the expected cost-to-go of a BSQ policy is a piece-wise constant function of the threshold parameters $\\theta$ for finite-horizon goal-POMDPs. In particular, the parameter space can be partitioned into a finite number of intervals, within which the cost-to-go is constant. This motivates the development of a BSQ policy optimization algorithm based on partition refinement --- by repeatedly selecting intervals of the parameter space, then trying to refine them by sampling a concrete set of threshold parameters, it is possible to eventually find the optimal (multi-dimensional) interval of threshold values. In experiments, the authors show that this approach leads to better performance than a baseline with randomly sampled threshold values.\n\nSTRENGTHS:\nBSQ polices haven't received attention for some time, so it's good to see a paper developing the theory and practice of BSQ policy evaluation and optimization. My concerns about the framing and motivation around \"preferences\" aside (see Weaknesses), the paper is technically sound, and elucidates the structure of the BSQ policy value function in a much deeper way than previously studied by Srivastava et al (2012). Given the piecewise constant nature of this value function, the partition-based policy optimization algorithm is a natural but principled approach. The proofs that I checked appear to be correct, and the experiments indicate that convergence to the optimal policy is indeed achieved. Insofar as BSQ policies provide a tractable and interpretable alternative to more direct approaches to solving POMDPs (though to me this remains to be seen), this paper is a step towards improving their practical applicability, and is likely of interest to others working on POMDPs.\n\n**References:**\n\nSrivastava, S., Cheng, X., Russell, S., & Pfeffer, A. (2012). First-order open-universe POMDPs: Formulation and algorithms. Technical report, EECS-2013-243, EECS Department, UC Berkeley.\n\nWEAKNESSES:\nMy concerns about this paper center around two main issues (i) motivation and framing around \"preferences\" (ii) the strength of the evaluation.\n\n**Motivation and Framing**\n\nBuilding upon the concept of BSQ policies introduced in Srivastava et al (2012), this paper introduces the concept of \"BSQ preferences\", which are basically BSQ policies without fixed probability thresholds $\\theta$. In other words, a \"BSQ preference\" is just a parameterized family of BSQ policies -- a *policy class* -- which can alternatively be interpreted as a *policy constraint* (Hasanbeig et al, 2018), a *policy sketch* (Andreas et al, 2017; Verma et al, 2018) or a *partial (policy) program* (Andre & Russell, 2002; Hahn et al, 2022) where branch conditions take the form of belief-state queries.\n\nGiven these other interpretations of what a \"BSQ preference\" is -- which, in my opinion, are much more natural -- it is strange to me that the paper adopts the terminology of \"preferences\" instead. This leads to a motivation in the Introduction that feels quite at odds with the actual technical content: While it's undoubtedly the case that reward engineering is difficult, especially in partially observable settings, it's far from obvious that specifying BSQ policy constraints actually address these specification challenges. Indeed, the paper does not study whether humans find it easier to specify BSQ policy constraints rather than (a) rewards or (b) the more common notion of preferences as pairwise comparisons (used in e.g. RLHF).\n\nI understand that the authors are building upon the literature of \"planning with preferences\" in the way they use the term \"preferences\", but IMO that choice of terminology was always unfortunate*, and people should really have called stuff like LTL specifications \"constraints\" rather than \"preferences\". This is especially important if the authors are hoping to learn BSQ policies from human preference data in the future (as they suggest in the Discussion) --- it will be very confusing for the term \"preference\" to both refer to a class of (BSQ) policies, and also the more standard notion of a pairwise comparison between trajectories / choices.\n\nAt the very least, I think the authors should discuss the alternative interpretations of a \"BSQ preference\" that I have listed above -- and cite the relevant literature -- though I think it would be ideal to just move away from the \"preference\" terminology altogether.\n\n(*Note that even in the \"planning with preferences\" literature, a preference specification is understood to introduce an ordering relation over plans, in accordance with the standard notion of preferences. This notion of an ordering relation isn't discussed by the definition of a \"BSQ preference\" in this paper. I would be happier with the \"preference\" terminology if ordering relations were actually discussed, and if the paper said something about how to handle *multiple* BSQ policy constraints, each with different priorities, since this would introduce a richer ordering relation than the trivial one that prefers all policies that satisfy the constraint.)\n\n**Strength of Evaluation**\n\nWhile the Partition Refinement Search (PRS) algorithm is well explained and motivated, the evaluation is unfortunately quite limited, only comparing PRS variants to a baseline where the probability thresholds are sampled at random, with no policy optimization at all. I think minimally, there should be some kind of grid-search baseline similar to the one in Srivastava et al (2012), which more clearly shows the benefits of a search strategy based on partition refinement, compared to one which enumerates over the full space of thresholds until the time limit is up. I think there should also be a random search baseline --- i.e. one which repeatedly samples random threshold values, evaluates the resulting policies, and returns the best threshold combination so far. An even stronger baseline would be some kind of coordinate-ascent or Gibbs sampling algorithm, which optimizes one threshold at a time (via gridding or sampling) while keeping the other thresholds fixed.\n\nThe above suggestions only pertain to policy optimization under the assumption that we know for sure we want to satisfy the constraint induced by the BSQ policy class. But if the authors really want to show the benefits of BSQ policies as either (i) a way of specifying user constraints or (ii) a way of avoiding downsides of unconstrained policy optimization in POMDPs, then I think more experiments are in order.\n\nFor example, to show that BSQ policy constraints might be a more concise way of communicating user requirements than alternatives, it would be great to see a comparison with reward engineering, or with fitting and then optimizing a reward model learned from pairwise trajectory preferences (as in RLHF). I think this would be especially important if the authors want to keep the \"preference\" oriented framing of the paper.\n\nAnd to show that BSQ policies have practical engineering value over direct POMDP solution approaches like POMCP or PBVI, it would be good to find some way of comparing the solution quality of PRS vs. those other approaches --- for example, it might be the case that BSQ policy optimization actually produces better outcomes in less solution time because it allows users/developers to constrain the space of policies (i.e. provide \"policy guidance\"), similar to the benefits of HTN planning over classical planning.\n\n**References:**\n\nSrivastava, S., Cheng, X., Russell, S., & Pfeffer, A. (2012). First-order open-universe POMDPs: Formulation and algorithms. Technical report, EECS-2013-243, EECS Department, UC Berkeley.\n\nHasanbeig, M., Abate, A., & Kroening, D. (2018). Logically-constrained reinforcement learning. arXiv preprint arXiv:1801.08099.\n\nAndreas, J., Klein, D., & Levine, S. (2017, July). Modular multitask reinforcement learning with policy sketches. In International conference on machine learning (pp. 166-175). PMLR.\n\nVerma, A., Murali, V., Singh, R., Kohli, P., & Chaudhuri, S. (2018, July). Programmatically interpretable reinforcement learning. In International Conference on Machine Learning (pp. 5045-5054). PMLR.\n\nAndre, D., & Russell, S. J. (2002, July). State abstraction for programmable reinforcement learning agents. In AAAI/IAAI (pp. 119-125).\n\nHahn, E. M., Perez, M., Schewe, S., Somenzi, F., Trivedi, A., & Wojtczak, D. (2022). Recursive reinforcement learning. Advances in Neural Information Processing Systems, 35, 35519-35532.\n\nQUESTIONS:\nPOST-REBUTTAL: I have adjusted my score to a 6 given the additional baseline comparisons in the author's rebuttal, which show that PRS outperforms less naive parameter search methods, as well as unconstrained policy optimization methods like POMCP and DESPOT.\n\n===\n\nIn light of the issues with framing and evaluation, I am currently recommending a paper score of 4. If only the framing issues existed, I would give a score of 5. But unfortunately the combination of issues leads me to think this paper isn't ready for publication in NeurIPS yet, even though the theory portion is interesting and sound.\n\nTo address these issues, here are my recommendations / questions:\n\n- Consider renaming \"BSQ preference\" to \"BSQ policy class/sketch/constraint\". Minimally, please discuss these alternative interpretations of a \"BSQ preference\".\n- If the \"BSQ preference\" terminology and framing is kept, there should be more rhetorical and empirical justification for why BSQ policies are a useful way of specifying user preferences, and more discussion of the notion of preferences as ordering relations.\n- Why is PRS not compared against stronger policy optimization baselines, e.g. grid search, random search, or coordinate ascent?\n- Consider comparing PRS against unconstrained policy optimization to more clearly show the benefits of BSQ policy constraints as a form of policy guidance.\n- If the \"BSQ preference\" framing is kept, consider comparing user specified BSQ preferences against user specified reward functions or reward models fitted to pairwise comparison data.\n\nMinor Comments:\n\n- In the description of PRS, the terms \"partition\" and \"optimal partition\" seem to be used in place of \"interval\" / \"optimal interval\", which led to some confusion when I was reading that section. I think the authors should try to keep to the standard notion of \"partition\" as a way of splitting a set into mutually exclusive and exhaustive subsets, and use \"interval\" to refer to one of those (continguous) subsets.\n\nLIMITATIONS:\nA number of important limitations are discussed in Appendix H. There are other limitations that I've pointed out above that should be either addressed or discussed.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-07-11"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper presents a new way of encoding preferences using so-called belief state queries in goal-oriented POMDPs. The modelling allows for optimising agent behaviour while complying to those preferences. In a formal analysis, the paper shows that the expected value function, although non-convex (abstract) / non-concave (main body), is piecewise constant, enabling a finite partitioning of the parameter search space. The experiments show that the theoretical potential is realisable in an implementation for the given examples.\n\nSTRENGTHS:\n- The paper tackles an interesting problem by looking at goal orientation and preferences in combination.\n- The framework appears sound and well-rounded.\n\nWEAKNESSES:\n- The presentation could be improved. There are some (minor) details that need fixing for a final version, should the paper be accepted:\n\t* Please use abbreviations consistently. Introduce an abbreviation once when the term occurs for the first time in the main text and then use the abbreviation only (exception: headings). At least one abbreviation is introduced several times (BSQ, PRS), at least one is not introduced upon first occurrence of the term (gPOMDP), one is not introduced at all in the main body (POMDP).\n\t* It usually is a sign of a weak text structure if sections have single subsections as seen with 5.1 and 6.1 (as also argued in most style guides). In the cases here, the first part of the sections deserve their own subsection headings. If the space does not permit this, consider making 5.1 and 6.1 part of the section, maybe using \\paragraph to further structure the overall section.\n\t* I recognise that space is scarce but the figures are very small, especially the experiments figures are hard to read. Please make sure that a colour-blind person can also read the figures.\n\t* It could be more explicitly stated which parts of the formalisation is new and which part is already existing. The way it is formulated right now, it could be read as gPOMDPs and BSQ being existing concepts used for the first time for preference encoding or that both are new concepts.\n\t* Again a question of available space but wrapping an algorithm in text is highly uncommon in academic AI papers.\n\n(Not sure where this needs to go in the review form; minor comments: \n- For the sake of consistency: align convexity / concavity between the abstract and the main body of the paper\n- In Def. 1, the $F$ in line 104 is not defined. Should it be $\\mathcal{F}$?\n- p. 7, line 276: missing space between (PRS)(Algo. 1) // abbreviate Algorithm by Alg. to save the space of the 'o'?\n)\n\nQUESTIONS:\n-\n\nLIMITATIONS:\nThe limitations are discussed in the appendix. It would be great to have at least some discussion / acknowledgement of it in the main paper.", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 4, "DATE": "2024-07-12"}