{'fraction_non_alphanumeric': 0.030465098842876064, 'fraction_numerical': 0.005248294304351086, 'mean_word_length': 4.982060098669457, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 1, 'https://': 3, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 5, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Technical Report: A Hierarchical Deliberative-Reactive System Architecture for Task and Motion Planning in Partially Known Environments

We describe a task and motion planning architecture for highly dynamic systems that combines a domain-independent sampling-based deliberative planning algorithm with a global reactive planner. We leverage the recent development of a reactive, vector field planner that provides guarantees of reachability to large regions of the environment even in the face of unknown or unforeseen obstacles. The reachability guarantees can be formalized using contracts that allow a deliberative planner to reason purely in terms of those contracts and synthesize a plan by choosing a sequence of reactive behaviors and their target configurations, without evaluating specific motion plans between targets. This reduces both the search depth at which plans will be found, and the number of samples required to ensure a plan exists, while crucially preserving correctness guarantees. The result is reduced computational cost of synthesizing plans, and increased robustness of generated plans to actuator noise, model misspecification, or unknown obstacles. Simulation studies show that our hierarchical planning and execution architecture can solve complex navigation and rearrangement tasks, even when faced with narrow passageways or incomplete world information.


A. Motivation
In this work, we consider a setting in which a highly energetic quadrupedal robot, capable of behaviors like walking, trotting and jumping, is assigned mobile manipulation tasks in an environment cluttered with fixed obstacles and movable objects (see Fig. 2). Solving these tasks requires planning and execution of dynamical pedipulation (nonprehensile manipulation of the environment using general purpose legs) [1] as well as navigation amidst clutter.
Developing computationally and physically viable solutions for these scenarios is challenging, even assuming a deterministic robot in a fully observable world (e.g., PSPACE hardness of the Warehouseman's problem was established in [2]), and it has been well-understood for many years that hierarchical abstractions [3] are required to address the fundamental complexity of such task and motion planning (TAMP) problems [4]. However, when using hierarchical abstract planners, it is difficult to ensure the correctness of the resulting plan unless the entire trajectory of the motion primitive is checked for feasibility during planning, significantly impacting the overall computational cost.  Our proposed system architecture. Given a mobile manipulation task, a deliberative layer searches for a sequence of abstract actions, or a plan, using contracts that describe the reachability guarantees of a global reactive layer, which in turn implements these actions and guarantees collision avoidance in complex environments. The reactive layer transmits template commands (such as target velocity or grasping commands) to a gait layer that executes high-rate feedback to achieve parameterized steadystate or transitional behaviors on the robot. This architecture allows the deliberative layer to reason about sequencing actions without constructing explicit trajectories through the configuration space, improving computational efficiency while preserving probabilistic completeness. This paper shows how a deliberative layer and reactive layer can create abstract plans that are correct-byconstruction through the use of continuous constraint contracts (C3) between a deliberative and reactive layer [6]. For the reactive layer, we adapt a reactive, vector field planner from our prior work [7] that not only guarantees collisionfree convergence to targets but is also robust to environmental uncertainty, even in the presence of unanticipated obstacles.

B. Contributions
The contribution of this paper is a hierarchical planner, shown in Fig. 1, that has the desirable properties of achieving the computational efficiency seen in many previous task and motion planning approaches, while preserving guarantees of probabilistic completeness that are often sacrificed for such computational gains. Our planner uses the guarantees of an online, vector-field-based reactive layer to define action contracts, such as the reachability of target poses, to an offline deliberative layer, providing the deliberative planner with global knowledge of each parameterized action's basin of attraction, and allowing it to simply reason about sequencing actions without constructing explicit trajectories through the configuration space.
Focusing on the example of a quadruped robot navigating in an environment with static and movable obstacles, we   [5]. (c) An example of a complex dynamically-constrained domain in which a robot must reach the goal on the lower right, where the heights of the ground plane (z = 0), the obstacle (z = 1), and the goal (z = 2) are all different. The robot can jump only one unit, so the robot must move the cart (red square) to enable a sequence of jumps to reach a goal state (d).
demonstrate several significant computational advantages in the deliberative layer arising from delegating metric details to the reactive (closed loop) controller. First, the reactive layer allows the deliberative planner to plan only in terms of transitions between behaviors, such as grasping and releasing objects. As a result, fewer samples are needed to find a good plan. Second, because the deliberative planner is aware of the domain of convergence for each controller and can work out plans using the adjacency of those basins of reachability, it can construct plans with fewer steps than if it relied solely on fine-grained motion primitives-for example, lineof-sight connections-and without sacrificing any correctness guarantees. The difference is especially pronounced when the path requires traversing narrow passages, which are notoriously difficult for sampling-based planners. The reduction in the length of plans dramatically reduces the time required to search for a high-level plan.

C. Organization of the Paper
The paper is organized as follows. Section II summarizes related work. Section III describes the proposed multi-layer architecture, along with its formal guarantees. Section IV describes the mobile manipulation problems addressed in this paper, and the specific set of introduced symbolic actions for the Ghost Minitaur robot [5] used in this study, in two different planning approaches for the deliberative planner: a local reactive approach, employing the reactive layer to simply track reference trajectories from the deliberative layer, and our global reactive approach with the proposed architecture. Section V describes numerical studies contrasting the performance of the local reactive planner with the global reactive planner in different mobile manipulation scenarios. Section VI provides implementation examples with a simulated Minitaur, and, finally, Section VII concludes with our remarks and ideas for future research.

II. RELATED WORK
Hierarchical abstractions for TAMP have been well studied in the literature. Examples include the use of a deliberative planner that employs a reactive execution layer-such as a motion primitive library [8], or pre-image backchaining with a higher-level planner in deterministic [4] and stochastic [9] settings-to simplify the computational burden of planning. Solutions typically involve a marriage of fast discrete planning tools [10] and sampling-or grid-based discretizations of the continuous action space [11], with significant engineering effort expended on the design of effective heuristics and sampling strategies that exploit task-level and geometric information [12]. Angelic semantics [13] provide a way of describing abstractions that also preserve optimality, but there is no easy way of defining such abstractions in continuous domains. Our prior work [14] provided a step towards tractable planning with complex kinematic constraints, but no appropriate approach exists for the complex legged robot dynamics considered in this paper.
Motivated by the typically high-dimensional configuration spaces arising from combined task and motion planning, most approaches focus either on sampling-based methods that empirically work well [15], [16], or learning a symbolic language on the fly [17]. Such methods require constant replanning in the presence of unanticipated conditions and their search time grows exponentially with the number of configuration variables.
Other approaches focus on the use of reactive temporal logic planning algorithms [18], [19], [20], that can account for environmental uncertainty in terms of incomplete environment models, and also ensure correctness when the robot operates in an environment that satisfies the assumptions modeled in the task specification. Common in these works is the reliance on discrete abstractions of the robot dynamics [21], [22], while active interaction with the environment to satisfy the logic specification is neglected.

III. VECTOR-FIELD TASK PLANNING
Our objective is to compute plans for a robot to achieve a goal state, subject to kinodynamic constraints. The active constraints on the dynamics of the world state vary with the robot's behavior, enabling the robot to select different modes of its dynamics as it plans to move around the world. For example, a plan for the robot in Fig. 2 might simply be to navigate its workspace, or to make and break contact with the objects in the world as it moves around. Each of these modes corresponds to a different set of constraints.
Following the notation introduced in our prior work [14], we can define a planning domain by a tuple (h, C), where h : C × T C → R k defines a set of k constraints on the configuration space C and its tangent bundle T C. Then, a differentiable function σ : [0, T ] → C is a feasible path if h(σ(t),σ(t)) ≥ 0, ∀t ∈ [0, T ], whereσ(t) = dσ(t)/dt. We denote the set of feasible paths by Σ C .
Based on this description, we can define a planning problem as a tuple (c 0 , c * ), where c 0 , c * ∈ C are the initial and goal configurations respectively. Definition 1 A solution to a planning problem (c 0 , c * ) in a domain (h, C) is given by the solution to the problem: (1) is formally undecidable without further assumptions on h(σ(τ ),σ(τ )) [6], and solving the analogous problem for typical discrete approximations is computationally intractable for scenarios where the robot needs to make and break contact with the environment. A conventional approach is to decompose the problem into a task and motion planning problem: a deliberative layer first solves for a task plan corresponding to a sequence of dynamic modes, parameterized by starting and stopping conditions, and a motion planner generates trajectories within each mode from start condition to stopping condition.
For instance, for our quadrupedal robot manipulating objects as shown in Fig. 2, we can solve rearrangement or navigation problems as a sequence of traversals, jumping motions, and object grasps and movements. The deliberative layer determines the sequence of objects to interact with, and where to navigate to make or break contact with objects. The motion planner computes the specific trajectories the robot should follow to realize the sequence of mode changes.
However, the decomposition into separate task and motion planning problems typically leads to loss of completeness, because the task planner may create motion planning subproblems that are infeasible. We now describe the formal conditions under which a combined deliberative and motion planning layer can compute task plans that preserve probabilistic completeness guarantees of the underlying motion planner, even without first evaluating it.

A. Deliberative layer
We assume that the deliberative planner has knowledge of the entire configuration space, including a description of the world as a collection of objects with geometric information, such as shape and pose, and other properties that constrain the types of actions available with these objects.
We use the continuous constraint contract (C3) to represent states, presented in our prior work [6]. The C3 representation is a continuous extension of the SAS+ formalism [23]; as in most planning formalisms, the state of the world is parameterized by the value of different variables. A state s ∈ S is a collection of variable-value pairs, and represents the set of configurations satisfying the constraint defined by the value assigned to each variable. Each variable v corresponds to a function η v (c) mapping configurations c to an element of the variable's domain; a state {v 1 = p 1 , v 2 = p 2 } describes the set of configurations c such that η v1 (c) = p 1 and η v2 (c) = p 2 . For instance, for our example in Fig. 2, if a specific object is given a specific pose in the environment, then the state will be all configurations of the world (including all configurations of the robot) that have that object at that pose. There is no requirement that every variable have an assigned value; variables without values represent inactive constraints. This implies that a single configuration c could satisfy the requirements of multiple states at once; e.g., a configuration c that satisfies η v1 (c) = p 1 and η v2 (c) = p 2 corresponds to both states {v 1 = p 1 , v 2 = p 2 } and {v 1 = p 1 }. However, the latter state describes a larger set of configurations, with the constraint on v 2 being inactive.
To travel between states, we assume the lower level motion planner can instantiate actions, parameterized by a start and goal, in the form of different behaviors, such as "Navigate" or "Move-Object"; the deliberative planner must then choose a sequence of different behaviors as well as their parameterization. This representation is equivalent to the representation used in Definition 1 for controllable systems.
Theorem 1 (Representing constraints as analytic functions -Included in [6]) If the kinodynamic constraints h are piecewise-analytic in the sense of Sussmann [24], and the dynamical system is stratified controllable in the sense of Goodwine and Burdick [25], then there is a stratified C3 instance whose actions represent piecewise-analytic vector fields, in which the constraints can be expressed as equalities and inequalities involving only analytic functions.
The consequence of this theorem is that if the constraints are piecewise-analytic, and if the dynamics are stratified, then the complete plan can be expressed as a series of motions across a sequence of vector fields, where the vector fields are defined by the kinodynamic constraints such as obstacles or grasping and releasing objects. The planning problem then becomes one of choosing the sequence of vector fields and their parameterizations.
We can further take advantage of this theorem by defining actions as a contract between the deliberative and motion layers: formally, we define the requirements and effects of an action a with continuous parameterization Θ a in terms of two functions g a : S ×Θ a → B and f a : S ×Θ a → S, where S is the space of possible states s. The function g a (s, θ) defines the requirements of the action, and f a (s, θ) defines its effects. If the system is in state s when executing action a with parameters θ, then the motion planner guarantees that if g a (s, θ) = 1 then at some point in the future the system will reach state s = f a (s, θ).
However, such guarantees are in practice difficult to describe. The easiest guarantee to provide is one where the motion planner is restricted to straight-line actions parameterized by an end point, and enforces reachability by evaluating each straight-line trajectory for violations of the kinodynamic constraints. A deliberative planner using this simplistic motion planner would offer probabilistic guarantees, but with essentially no computational advantage from the decomposition into deliberative and motion planning. The challenge is to identify a motion planner that can enforce the C3 contracts in a computationally efficient manner.

B. Reactive layer
We now describe a reactive motion planner with a key property: the corresponding C3 contracts can be checked very quickly, without sampling, discretization, or collisionchecking. Rather than instantiating a single motion plan, the reactive layer constructs a control policy whose execution is guaranteed to achieve the objectives specified by the deliberative layer, or to return with a failure condition expressing the incorrectness of a presumed constraint in the actual environment. The reactive planner can reliably handle the geometric details of navigation and manipulation, even in the face of unknown obstacles.
The reactive layer models the robot as a polygon, and takes as input an estimate of the current reachable set of robot poses, in the form of a polygonal connected component of the robot's workspace, along with a high-level action a with all parameters θ ∈ Θ a chosen by the deliberative layer. Following our example from Fig. 2, one action in a plan for a rearrangement task might be push(ground, cart, x * ) (interpreted as "push object cart to a target location x * atop the object ground"). The reactive layer outputs the parameters of a behavior, such as a target velocity and yaw rate, which vary continuously with the state of the world.
The reactive layer is implemented using the vector-fieldbased feedback motion planning scheme introduced in our prior work [7]. Its critical advantage is the use of a diffeomorphism construction to deform non-convex environments to easily navigable convex worlds, by employing a "crude" geometric description of the environment (outer walls) from the deliberative layer, together with learned or intrinsic domain specific knowledge about encountered obstacles.
Unlike the deliberative layer's more general world representation including the robot and all movable objects and static obstacles, in the reactive layer we assume that the robot is the only active agent in the world, and behaves like a first-order, nonholonomically-constrained, disk-shaped robot, centered at location x ∈ R 2 , with radius r ∈ R >0 , orientation ψ ∈ S 1 and input vector u := (v, ω), consisting of a foreaft and an angular velocity command. We denote by W the robot's non-convex polygonal workspace, and by W x ⊆ W the polygonal region corresponding to the space reachable from the robot's current position x. The workspace is cluttered by a finite collection of disjoint obstacles of unknown shape, number, and placement. Similarly, the freespace F is defined as the set of collision-free placements for the robot in W, and we denote by F x ⊆ F the freespace component corresponding to W x .
During online execution, the reactive controller synthesizes an action as a control law by constructing a diffeomorphism h between F x and a convex model environment, where non-convex obstacles are either deformed to topologically equivalent disks or merged to the boundary of F x . Then, the robot can navigate by generating virtual commands v := (v,ω) as in [26], for an equivalent unicycle model (defined in [27,Eqs. (24)- (25)]) that navigates toward the assigned target position x * in this model environment, and then mapping the virtual commands to physical inputs (v, ω) through the pushforward of the inverse of h, i.e., u = [D x h] −1 v. Using the language of the deliberative layer, the requirements g a (x, x * ) of a navigation action are satisfied if both the robot and target positions are contained in the same component F x of the robot's freespace. Because we represent the workspace and obstacles using polygons, this calculation can be made using standard tools from computational geometry. More formally, we can decompose F into a finite collection of connected polygons (possibly with holes), and define a set-valued function β F : F → 2 F , such that F x β F (x) ⊆ F is the connected component containing x. We describe an implementation of this function in Section IV-C.
Theorem 2 (Target convergence and obstacle avoidance -Corollary of [7, Theorem 2]) If we define g a (x, x * ) to be equal to 1 when d(β F (x), β F (x * )) = 0 and 0 otherwise (with d(·, ·) the distance between sets), then the online reactive planner guarantees that the robot will converge to the target x * (i.e., f a (x) x * ), while avoiding all obstacles in its workspace.
In other words, during online execution, as long as both the initial robot position x and the target location x * lie in the same polygonal component F x of the robot's freespace, the robot can construct a diffeomorphism to the environment that allows it to compute a controller that will eventually reach x * while avoiding all (previously known or unforeseen) obstacles in the environment. This result also holds for rearrangement actions, using the framework in [28] for generating virtual commands for the center of the circumscribed disk, enclosing the robot and a grasped disk-shaped object.
It should be noted that Theorem 2 covers only navigation actions, where either the robot or the robot-object pair navigates to a desired location. To navigate across mode boundaries (i.e., across connected components of the configuration space), we use special-purpose local actions. For example, continuing to follow Fig. 2, we assume the existence of an action that can take the robot from ground to cart. Unlike for navigation, these local planners are not formally verified in the sense of Theorem 2, but may similarly be designed to use robust closed-loop mechanisms during realworld execution. The reader is referred to Section IV for a description of such an action (jump).

C. Combined deliberative-reactive planning
In practice, given a C3 problem instance describing the permitted behaviors, the world geometry, and a goal specification, we construct a graph by sampling random parameters for actions. In navigation or manipulation problems, this generally involves sampling candidate placements for objects or for the robot. Importantly, Theorem 1 allows us to sample from the free space of each object independently, rather than sampling from the joint configuration space, without sacrificing completeness. The sampling process implicitly defines a planning graph: by construction, the finite set of sampled parameters yields a finite (though exponentially large) set of potentially reachable states. Each distinct state is a node in the graph, connected with an edge to another state that satisfies the requirements of the action provided by the reactive planner. We then perform a direct heuristic search over this graph to synthesize a plan. We reduce computational cost by considering only a reduced set of constraints in the action requirements when sampling, and checking the remaining constraints only when we find a candidate plan to a given state. Although the graph grows exponentially with number of samples, we typically need to construct and search only a small fraction of the graph. We refer the reader to [14] for more details on the graph construction and search.
Theorem 3 (Combined probabilistic completeness -Corollary of Theorems 1-2) If our planning domain contains only modes defined by piecewise-analytic constraints and stratified controllable dynamics, and there exist local actions for navigating across mode boundaries, then the deliberative planner will eventually sample a feasible motion plan, expressed as a sequence of reactive planner actions between connected components of the configuration space.
Combining the deliberative and reactive layers within this sampling-based framework yields a planning algorithm that is provably sound, probabilistically complete, and synthesizes feedback control policies robust to perturbation from the environment and actuator noise.
IV. SYSTEM IMPLEMENTATION In this Section, we describe the specific class of mobile manipulation problems addressed in this work, and the implementation details of the above architecture. While our planner is general purpose for a wide range of problems, we consider the problem of a dynamically complex quadruped robot performing navigation among movable obstacles (NAMO) as in our prior work [28].

A. Problem Domain Description
Our chosen model abstraction for planning is a 2.5D semiplanar world representation, shown in Fig. 2c. All objects in the world, which can be either static or movable, are defined as planar polygons, with a pose in SE(2) augmented by a z value denoting vertical height. The robot can walk along the polygonal component describing the top of the currently occupied object, jump on and off the ground plane and between objects of varying heights provided the height difference and gap is within its physical capabilities, and manipulate movable objects on the currently occupied object. We use five types of actions to model the robot capabilities: Moving: For each object obj in the world that the robot can occupy, we include an action move(base, obj, p target), which requires feasibility of motion from the current pose to a new pose p target. The requirement isfeasible can either denote feasibility in the typical sense of motion planning that involves samplingbased collision checking (as explained in Section IV-B), or feasibility in the sense of our reactive planner (as explained in Section III-B and later in Section IV-C).
Jumping: An action jump(from, to, p target) requires that the robot can feasibly jump from object from to object to at pose p target. Grasping: An action grasp(base, obj, p target, p mount) defines the mounting of a movable object obj on top of object base to a new pose p target. An additional parameter p mount defines the relative pose of the robot and the grasped object during motion. Formally, this action guarantees transition from a state s, where both the robot R and the object obj are on top of object base and the value of grasping(R, obj) is 0, to a new state s , where R and obj remain on top of base, grasping(R, obj) = 1, pose(obj) = p target and relative pose(R, obj) = p mount. The requirement of this action is given by isfeasible(pose(R), pose(obj)) = 1, using the feasibility function described above.
Releasing: An action release(base, obj, p robot, p obj) defines the releasing of a grasped object obj on top of object base, such that the robot ends in pose p robot and the object in pose p obj. Formally, this action guarantees transition from a state s, where both the robot R and the object obj are on top of object base and grasping(R, obj) = 1, to a new state s , where R and obj remain on top of base, grasping(R, obj) = 0, pose(obj) = p obj, and pose(R) = p robot. The requirement of this action is given by isfeasible(pose(obj), p obj) = 1, using the same feasibility function.
Pushing: Finally, we define an action push(base, obj, p target) in which a robot moves atop an object base with a grasped object obj towards a pose p target, without releasing the object. The requirements and effects of push are similar to those of release, without defining a desired final pose for the robot R.
To demonstrate our proposed architecture, we attempt to solve mobile manipulation problems where the reactive layer is instantiated with either a local reactive approach that does not allow the deliberative planner to query the reactive planner for motion contracts, or with the proposed global reactive approach described in Section III (see Fig. 3). We use the local reactive approach as a baseline comparison because it is equivalent to state-of-the-art TAMP planners that provide correctness guarantees, for example, [11], [14], [29].

B. Local Reactive Planning Approach
Given a sequence of actions from the deliberative layer, the local reactive planner only guarantees the feasibility of navigating from a starting pose to a target pose if the path between them is collision-free (Fig. 3b). That is, the reactive planner can move from x to x * if isfeasible(x, x * ) = 1, with isfeasible(x 1 , x 2 ) equal to 1 when C F ,r (P sweep (x 1 , x 2 ), c) ≥ 0 and 0 otherwise, where P sweep (x 1 , x 2 ) is a polygon containing the robot polygon at each pose along a geodesic between poses x 1 and x 2 in SE(2), and C F ,r (P, c) checks for collision of a polygon P with any object or obstacle in configuration c. Here, the local reactive layer only plays its intermediating role when recovering the target pose in the face of unanticipated obstacles-or reporting the infeasibility of doing so.

C. Global Reactive Planning Approach
The crucial advantage of the global reactive controller developed in [7] is that it guarantees successful navigation to any pose in its connected component of the freespace, (a) In our baseline local reactive planning approach (left), the deliberative planner must conduct an optimized search over the configuration space of robot and object placements in the presumed freespace and is restricted to collision free straight-line paths. Motions that instantiate these paths are generated at runtime by the reactive layer, guaranteeing avoidance of unanticipated obstacles along the way. The global reactive planning approach (right) is guaranteed to generate a collision-free path to any target pose in the robot's current connected component (highlighted in yellow). Actions are now represented by putative robot-connected components and their adjacency relative to robot-object manipulations. This more abstract contract between layers reduces the deliberative planner's computational burden to the exploration of topological adjacency.
(b) Solution to the example from Fig. 2 using the local reactive planning architecture (Section IV-B) [28]. The deliberative planner finds a sequence of collision-free straight-line motion primitives to move the robot to the cart, push the cart near the goal, and finally jump to the goal. Resulting plans are often long sequences comprising the entire set of actions listed in Section IV-A.
Because the global reactive controller guarantees collisionfree convergence to any target configuration in the connected component of the robot's (or mated robot-object's) freespace, the deliberative planning domain includes actions whose requirements and effects are defined by closed-loop controller attractor basins. These are larger sets of the configuration space than the line-of-sight sets exposed by the local reactive planning approach. Any sequence of invocations of the reactive planner can be represented using these actions; because the actions can traverse long distances, this approach results in shorter plans, particularly in environments with unanticipated obstacles or complex geometric features.
We describe the global reactive planner as a C3 domain, and use the sampling-based planning algorithm described in Section III-C to search for a sequence of transitions between adjacent basins of attraction created by invocations of the reactive layer. To determine adjacency, we explicitly construct the polygonal connected components of the freespace containing each robot and object using the Boost Geometry library [30]. Two polygonal components are adjacent if the distance between them is small enough to be traversed by a jumping or manipulation action.

V. NUMERICAL EXPERIMENTS
In this Section, we present scenarios that describe common task specifications that can be solved using our system. We perform qualitative and quantitative analyses contrasting the performance of the deliberative planner with a local reactive and a global reactive planner by exploring the effect of environmental complexity on planning computation.

A. Known Environment Scenario
In the scenario in Fig. 4, the robot must move an object to a goal while navigating an increasingly dense set of randomly generated obstacles known by the deliberative layer. Fig. 4d shows that planning times increase with the number of obstacles at a higher rate using the local reactive approach. Despite the added overhead of decomposing the environment into connected components when using the global reactive planning approach, more samples are needed to successfully solve these tasks using the local reactive system, where the deliberative planner is required to sample collision-free straight-line motion primitives at a lower level of abstraction. Also, the success rate of planning with the local reactive approach decreases with environmental complexity. For all generated worlds in which the global reactive approach found a plan, we planned 10 times more with the local reactive approach. In the case of zero obstacles, average success rate was 100%, gradually decreasing to 66.5% for 20 obstacles.

B. Doorways Scenario
The scenario in Fig. 5 explores how planning time scales with environmental complexity, both in terms of static obstacles and movable objects. Since the complexity of walls is abstracted away with the global reactive layer, this scenario can be solved with less samples (and therefore in less time) than with the local approach, as shown in Fig. 5b. Moreover, extraneous objects that do not block a doorway have a significantly lower impact on planning time, as seen in the inflection points for the "3 Doorways" and "5 Doorways" lines at 3 and 5 objects, respectively. Planning time does increase when the number of walls (and thus doorways) increases while the number of objects is held fixed. This is partially attributed to additional node expansions in sampling placements for objects, but also to more polygon decomposition and adjacency checks per individual node expansion. The robot (blue) must move a block (red) to the goal in the lower right corner of the map. Obstacles (grey) are randomly generated, ranging from 0 to 20 in number, to explore the effects of obstacle density on planning time (a). With the global reactive approach, even though each individual graph node expansion becomes more expensive as obstacle density increases (b), the relative decrease in node expansions (c) results in an overall decrease in planning time (d). Shaded areas denote 5th to 95th percentiles. The robot (blue) must traverse an increasingly complex set of walls and push objects out of the doorways to reach the goal (a). Planning time increases with number of doorways and obstacles, which both add complexity to the problem. Additionally, the contract provided by the global reactive approach significantly reduces planning times for equivalent problems compared to when utilizing the local reactive approach. Shaded areas denote 5th to 95th percentiles. (b). Walls are added in the following order: first, the vertical wall containing doorway 1, then the horizontal wall with doorways 2 and 3, and finally the center walls containing doorways 4 and 5. Objects are randomly placed in locations 1-7, ensuring that first all existing doorways are blocked before placing extraneous objects in free space. We simulated this scenario in Gazebo (see the accompanying video submission), adding random cylindrical obstacles that were unknown to the deliberative planner (c), (d). By leveraging the proposed global reactive planning approach, the robot is able to navigate the environment and manipulate movable objects to reach a goal despite the unforeseen obstacles.

VI. SIMULATION EXPERIMENTS
We demonstrate our proposed system architecture on a Ghost Minitaur [5] quadrupedal robot using the Gazebo simulator 1 . In our implementation, the gait layer abstracts the details of determining how to move the limbs or negotiate uneven terrain, freeing the reactive planner to determine how to achieve local goals for placements of the body and movable objects in the world. Specifically, we employ the steady-state behaviors "Walk" and "Push-Walk" from [28], to either navigate the workspace or use the robot's front limbs as a virtual gripper when manipulating movable objects respectively. In addition, we use a set of four transitional behaviors: "Mount", "Dismount", "Jump-Up" and "Jump-Across", adapted from [31], to mount and dismount objects, or jump on platforms or across gaps.

A. Doorways Scenario
We show the robot executing plans generated using our method on the Doorways scenario of Section V-B. Fig. 5d demonstrates that the global reactive approach allows the deliberative layer to find plans even in the presence of a complex space punctured by a large number of obstacles. Here, the robot has prior knowledge of all fixed walls, but no 1 Video of these simulations is included in the video submission and online in https://youtu.be/Ta5sVFkNnxo. The files for simulating Minitaur in Gazebo can be found in https://github.com/KodlabPenn/ kodlab_gazebo and a C++ implementation of the reactive layer is included in https://github.com/KodlabPenn/semnav. prior information on the location of the cylindrical obstacles; it must discover and avoid them using an onboard LIDAR.

B. Unknown Environment Scenario
In this scenario, shown in Fig. 6, the robot must move from its starting pose to a specified goal pose. In the absence of obstacles, the lowest-cost solution involves directly moving along a hallway to the goal. As the robot discovers obstacles while moving down this hallway, it may be able to navigate around the obstacles and still reach the goal. However, as the obstacle density increases, it may become difficult to plan around these obstacles, or the hallway may be blocked altogether. In this case, there is a higher-cost alternative in which the robot can push a movable object near the top of the environment and navigate a longer path to the goal. For these simulations, we assume that the robot possesses a sensor of fixed range (set at 3 m), for localizing unexpected obstacles.
We qualitatively show that the global approach can handle unanticipated obstacles without triggering a full replan, unless a newly localized obstacle blocks the hallway, violating the contract between the layers.

VII. CONCLUSION
Our hierarchical planner exhibits the greatest gains in efficiency when finding long plans with a small number of actions; problems that require evaluating combinatorially many transitions remain an open challenge. Our contractbased approach to action modeling could be combined with Minitaur must move to a goal region at the top right of the environment. The lowest-cost solution involves navigating along the hallway on the right, which is successfully executed using both the local reactive and the global reactive approach (a). Random unanticipated obstacles (black) may appear in this hallway and are only detected and localized when the robot approaches them within a specified distance. Using the local reactive approach, the robot quickly abandons the initially evaluated plan because some of the initial waypoints lie in obstacle space, and replans. It then unnecessarily switches to a higher-cost plan, involving manipulating the movable object and navigating a longer path to the goal (b). Using the global reactive approach, the robot either avoids all interior obstacles without changing its initially executed plan (c), or requests an alternative plan when detecting that the requirements of the contract are violated, i.e., the robot and the goal lie in different connected components of the freespace (d).
recent improvements in sampling strategies, search algorithms, and planning heuristics to increase the size and complexity of planning problems we can address. In addition, our approach could be applied to other classes of robotic platforms for which local controllers can be devised. Finally, we note that one shortcoming of our approach is the lack of a mechanism for the deliberative planner to correct the reactive planner if it makes a locally suboptimal decision. In principle, we could defer the selection of the level of abstraction at which to search for a plan to execution time, or even interleave searches at different levels of abstraction to capitalize on the relative strengths of each representation.