Paper deep dive
Macro-Operator Generation and Predicate Selection for TAMP Operator Learning
Can Emir Bora, Emre Ugur
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 8/26/2026, 3:56:35 AM
Summary
This paper addresses bottlenecks in Task and Motion Planning (TAMP) operator learning by introducing a system that automatically generates macro-operators and prunes unused predicates. Unlike existing methods that learn actions in isolation, this approach discovers causally linked action pairs from training data to form composite macro-operators, reducing the effective planning horizon. Additionally, it employs Iterative Predicate Selection (IPS) to remove predicates not referenced by learned operators, shrinking the symbolic state space. Evaluated across four TAMP domains, the method achieves up to a 4.6x planning speedup over the LOFT baseline and solves long-horizon tasks previously unsolvable.
Entities (12)
Relation Signals (7)
Emre Ugur → affiliatedwith → Bogazici University
confidence 95% · Department of Computer Engineering, Bogazici University... (e-mail: emre.ugur@bogazici.edu.tr)
Can Emir Bora → affiliatedwith → Bogazici University
confidence 95% · Department of Computer Engineering, Bogazici University... (e-mail: can.bora@std.bogazici.edu.tr)
Macro-Operator Generation → improves → TAMP
confidence 90% · Macro-operator discovery thus not only accelerates planning but, in certain domains, determines solvability in practice.
LoFT → isbaselinefor → Macro-Operator Generation
confidence 90% · compared to the baseline method, namely Learning Operators for TAMP.
Iterative Predicate Selection → reduces → symbolic state size
confidence 90% · This shrinks the symbolic state the planner must parse and reason over at every node.
Macro-Operator Generation → replaces → individual actions
confidence 85% · single composite actions that each replace a short and fixed sequence of individual actions.
Kitchen → requires → long sequential tasks
confidence 85% · Kitchen demands long sequences of interdependent actions
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Creating symbolic operators by hand is one of the main bottlenecks in deploying Task and Motion Planning systems (TAMP). Recent works show that these operators can instead be learned directly from demonstration data. Existing methods, however, typically learn each action in isolation and cannot capture the recurring multi-step structure of manipulation tasks, so the search becomes intractable on long sequential tasks. A further inefficiency arises in the symbolic state: every provided predicate is evaluated at every search node, even when it never appears in any learned operator. We present a system that addresses both problems together. Its central component is the automatic generation of macro-operators, composite actions that compress a recurring sequence of individual actions into a single planning step. Our system discovers causally linked action pairs directly from the training data, where one action produces exactly the condition that the next one requires, and turns each pair into a new operator. Alongside this, our system prunes every predicate that no learned operator references, which shrinks the symbolic state evaluated at each search node. Together, these changes shorten the effective planning horizon, and the benefit they bring grows with the length of the task. Across four TAMP domains, our method reaches up to a 4.6x planning speedup compared to the baseline method, namely Learning Operators for TAMP. More importantly, it solves a long sequential task that the baseline cannot solve. Macro-operator discovery thus not only accelerates planning but, in certain domains, determines solvability in practice.
Tags
Links
- Source: https://arxiv.org/abs/2608.23629v1
- Canonical: https://arxiv.org/abs/2608.23629v1
Trouble viewing inline? Open PDF directly →
Full Text
60,046 characters extracted from source content.
Expand or collapse full text
Macro-Operator Generation and Predicate Selection for TAMP Operator Learning CAN EMIR BORA1 AND EMRE UGUR1 Abstract Creating symbolic operators by hand is one of the main bottlenecks in deploying Task and Motion Planning systems (TAMP). Recent works show that these operators can instead be learned directly from demonstration data. Existing methods, however, typically learn each action in isolation and cannot capture the recurring multi-step structure of manipulation tasks, so the search becomes intractable on long sequential tasks. A further inefficiency arises in the symbolic state: every provided predicate is evaluated at every search node, even when it never appears in any learned operator. We present a system that addresses both problems together. Its central component is the automatic generation of macro-operators, composite actions that compress a recurring sequence of individual actions into a single planning step. Our system discovers causally linked action pairs directly from the training data, where one action produces exactly the condition that the next one requires, and turns each pair into a new operator. Alongside this, our system prunes every predicate that no learned operator references, which shrinks the symbolic state evaluated at each search node. Together, these changes shorten the effective planning horizon, and the benefit they bring grows with the length of the task. Across four TAMP domains, our method reaches up to a ∼4.6× 4.6× planning speedup compared to the baseline method, namely Learning Operators for TAMP. More importantly, it solves a long sequential task that the baseline cannot solve. Macro-operator discovery thus not only accelerates planning but, in certain domains, determines solvability in practice. Index Terms: Bilevel Planning, Macro-Operator Discovery, Manipulation Planning, Operator Learning, Symbolic Planning, Task and Motion Planning †history: Date of publication x 00, 0000, date of current version x 00, 0000.†doi: 10.1109/ACCESS.2026.DOI†address: Department of Computer Engineering, Bogazici University, Istanbul 34342, Turkey (e-mail: can.bora@std.bogazici.edu.tr, emre.ugur@bogazici.edu.tr)†titlenote: This work was supported by the INVERSE project (101136067) funded by the European Union and by the STAR program funded by TUBITAK.†corresponding: Corresponding author: Can Emir Bora (e-mail: can.bora@std.bogazici.edu.tr). I Introduction Autonomous robots in real-world environments face complex planning tasks. High-level reasoning involves deciding which objects to interact with and in what sequence, while low-level tasks require precise geometric decisions, such as determining grasp poses, motion trajectories, and placement locations. This tight coupling between discrete choices and continuous parameters makes robotic planning fundamentally challenging [16]. Task and Motion Planning (TAMP) [8] addresses this challenge through a bilevel approach: symbolic planning operators define an abstract transition model that guides search over action sequences, while a low-level search refines these abstract plans by assigning continuous values (e.g., grasp poses, placement locations) to each step. By using classical AI planning methods, TAMP can leverage heuristics to guide the search and quickly discard infeasible plans, exploring far fewer options than brute-force enumeration [17]. A significant constraint of TAMP systems is their dependence on manually crafted symbolic operators, which necessitate considerable domain knowledge for accurate specification [40]. Learning can ease this burden, and it has been applied throughout the TAMP pipeline, from samplers that propose grasp poses and placement locations [24, 38, 9] to guidance models that steer the symbolic search toward promising action sequences [25, 13]. These methods make the search more efficient, but the operators themselves are still written by hand, so the core specification burden remains. To address exactly this problem, Learning Operators for Task and Motion Planning (LOFT) [32] demonstrates that the operators themselves can be learned directly from transition experience, continuing a long line of action-model learning in classical planning [5, 29, 4]. The learned operators follow the style of the Planning Domain Definition Language (PDDL) [15], a standard formalism that describes each action through its preconditions and effects, defined over symbolic facts called predicates. They are also probabilistic, since each possible effect is assigned a probability of occurring. At planning time, these operators guide a symbolic search that proposes plan skeletons, action sequences whose continuous parameters, such as grasp poses and placement locations, are left open and filled in afterwards by a sampling procedure. Although this shows that operators can be learned effectively for TAMP, the method comes with several assumptions and limitations. The most significant one is that it treats every individual action in isolation and does not sufficiently address the fact that some actions almost always occur together in a fixed causal order, with one action producing exactly the condition that enables the next. Because of this, the planner must rediscover these recurring two-step patterns from scratch at every search node, which inflates the effective planning horizon and causes the branching factor to explode on long-horizon tasks. A second limitation is that every provided predicate is evaluated at every search node even when it never appears in any learned operator, which wastes state parsing effort and enlarges the symbolic search space. In this work, we address these limitations one by one with the following contributions: • Generating macro-operators: To address the isolated treatment of individual actions, we automatically generate macro-operators from the training data, that is, single composite actions that each replace a short and fixed sequence of individual actions. For this, we identify pairs of actions that are causally linked, where the first produces a condition that the second consumes, and register each pair as a new composite operator. This collapses frequent two-step sub-routines into one planning step. As a result, the effective planning horizon shrinks and the branching factor grows more slowly on long-horizon tasks. • Pruning unused predicates: To address the fact that every provided predicate is evaluated at every search node even when many of them never appear in any learned operator, we propose Iterative Predicate Selection (IPS), a post-learning step that automatically removes predicates absent from all learned preconditions and effects. This shrinks the symbolic state the planner must parse and reason over at every node. Fig. 1: The 7-ingredient Kitchen domain in PyBullet. A Fetch robot manipulates seven ingredients, represented by distinct colored shapes, across three workstations: Burner (red pad), Chopping Board (brown pad), and Dish (green pad). Four ingredients wait at the far end of the counter while three are actively being processed. Each ingredient must be picked, chopped, cooked, and plated to satisfy the goal. We evaluate our method on four TAMP domains. Three of them, Cover, Blocks, and Painting, have relatively short plan lengths and are also used in the baseline work [32]. In addition, in order to verify the method on long-horizon tasks, we introduce Kitchen, a cooking domain that we designed following the kitchen tasks used in prior TAMP work [38, 18], in which seven ingredients must each be picked, chopped, cooked, and plated (Figure 1). Kitchen demands long sequences of interdependent actions, since every ingredient has to pass through several processing stations in a fixed order. Experiments show that our contributions achieve up to ∼4.6× 4.6× planning speedup and enable solving the Kitchen domain. The baseline cannot solve this domain, and no plan is found there even when the planning time limit is removed. A component-wise ablation study further quantifies the contribution of each proposed component. I Related Work I-A Task and Motion Planning (TAMP) Following the taxonomy of Garrett et al. [16], approaches to TAMP can be broadly categorized based on how symbolic reasoning interacts with continuous variables during the planning process. One family formulates TAMP as a single large-scale optimization problem. It optimizes over hybrid trajectories, that is, trajectories that combine discrete choices with continuous motion, and it integrates logic and geometry directly [34, 12]. A second family avoids this joint formulation and instead relies on sampling-based procedures that follow a search-then-sample pattern. These methods first search for a symbolic plan and then sample continuous values to realize it [23, 33, 18]. In these methods, symbolic operators, often represented in PDDL [15], are used to generate a plan skeleton, a sequence of high-level actions with their discrete arguments fixed but continuous parameters left open. A low-level continuous optimizer or sampler then attempts to fill in those continuous arguments. A nearly universal characteristic of these deeply integrated TAMP systems is their reliance on manually authored symbolic operators, whose preconditions and effects must be specified by a human expert [40]. Our work builds on the premise that these symbolic abstractions can instead be learned automatically from demonstration and interaction data. I-B Learning for TAMP and Operator Discovery To reduce the burden of manual specification, learning has been applied to several parts of the TAMP pipeline. At the geometric level, one line of work learns continuous samplers, i.e. generative models that propose promising grasp poses or placement locations from the current state, so that the low-level optimizer explores fewer dead ends [24, 38, 9]. At the symbolic level, a complementary line learns search guidance. Kim and Shimanuki [25] learn a value function over relational states that scores symbolic actions and steers the tree search. Driess et al. [13] train a sequence model that predicts whole high-level action sequences from an image of the scene. These approaches learn how to search but still rely on hand-written operators describing what each action does. Closer to our setting is the model-based paradigm of learning the operators themselves, i.e. their preconditions and effects. This has a long history in classical planning [5]. Examples include noisy deictic rules, a probabilistic rule format that tolerates noisy and uncertain action effects [29]; LOCM (Learning Object-Centred Models), which extracts action models from plan traces [11]; STRIPS-style learning, which recovers action models in the classic STRIPS (Stanford Research Institute Problem Solver) representation with the help of classical planners [4]; and sparse relational transition models learned from data [39]. Whereas these methods assume the symbolic predicates are given, a more recent thread discovers the predicates themselves from robot interaction. Ahmetoglu et al. introduce DeepSym, which trains a deep encoder-decoder to predict action effects [3]. This network turns continuous observations into discrete object symbols, and PDDL operators are then extracted over those symbols. Follow-up work extends the idea to multi-object scenes using attention layers that expose object roles and relations, producing relational predicates that generalize across object counts [1, 2]. Similarly, other efforts learn abstractions tailored to planning, each starting from a different representation: symbols grounded in an agent’s skills [26], entity-centric state abstractions for model-based reinforcement learning [36], and neuro-symbolic predicates optimized end-to-end for planning performance [31]. Most relevant to our setting, Huang et al. [22] infer a planning domain, that is, the preconditions and effects of each action, from a small number of demonstrations given at test time. A recent survey places these efforts in the broader context of combining learning and planning [35]. LOFT [32] belongs to this operator-learning family but targets TAMP directly: it learns lifted, object-parameterized operators from a handful of demonstrations and uses them inside a sampling-based TAMP planner. However, it suffers from the two limitations set out in Section I: each action is learned in isolation, and every provided predicate is evaluated at every search node. We address both in this paper. Since it keeps the operator structure explicit, it is also a natural foundation for the components we propose, and we adopt it as our baseline. I-C Macro-Operators in Planning Macro-operators are composite actions formed by chaining several individual actions into a single planning step. They have a long history in classical AI planning: early systems such as MACROPS, a mechanism in the STRIPS planner that stored successful action sequences for later reuse, showed that this can substantially reduce the depth of future searches [14, 27]. Subsequent work proposed various criteria for selecting useful macros, for example by analyzing which action pairs recur across problem instances or which state transitions are repeated in training data [7, 28]. In robotics, the same idea appears under the name of macro-actions, which group repetitive low-level behaviors into reusable skills and simplify control [19, 30]. Applied to TAMP, macros can collapse multi-step sub-routines such as picking up an object, moving it, and placing it into a single operator, which shortens the effective planning horizon. However, for learned probabilistic TAMP operators, the automatic discovery and validation of such macros remain underexplored: existing frameworks learn each action in isolation and ignore the sequential structure present in the demonstration data [32, 29, 4, 39]. We address this gap by discovering causally linked action pairs directly from training trajectories and registering each pair as a new operator, which the operator learner then treats identically to individual actions during precondition learning and probability estimation. I Method Fig. 2: Architecture of the full pipeline, from training data to an executable plan. Figure 2 shows the complete system we propose, from the training data to an executable plan. Our main contributions are shown with the stages colored with orange boxes, each of which is presented in its own subsection below. Before detailing our contributions, we first give an overview of the background methods used in our pipeline, namely Operator Learning and TAMP Planning, in the next subsection. I-A Background In this section, we provide the background methods on which our work is built. In our TAMP approach, at the high level, a symbolic planner searches with operators written in PDDL. Each operator has preconditions and effects defined over predicates, the symbolic facts that abstract the continuous state into a discrete representation. Using A* search [21] with the heuristic [6] that estimates goal distance by summing the costs of achieving each subgoal independently, this stage returns candidate plan skeletons: action sequences whose discrete arguments are fixed but whose continuous parameters are left open. At the low level, a backtracking search turns a skeleton into an executable plan. For each step, it calls domain-specific samplers to propose continuous values, then simulates the action to check feasibility, and reverts to an earlier step whenever the current one fails. Each step is given a fixed number of sampling attempts before it is considered a failure. If no assignment works for a skeleton, the high-level planner produces the next plan. Next, we describe the operator learning module, for which we use LOFT [32]. The input is a dataset of low-level transitions, together with a fixed set of user-provided typed predicates. The transitions come from two sources. The oracle demonstrations D are successful task solutions, whereas the random-exploration set ℛR is collected by taking random actions from states visited in the demonstrations, thereby providing the negative examples used during learning. The module first converts every continuous state into a symbolic state using a deterministic function, Parse, that returns the subset of predicates that hold in that state. Learning then proceeds in three stages. (1) Lifted effect clustering computes the predicates that the action adds and the predicates it deletes. Lifting, here, corresponds to replacing the object instances with typed variables. Transitions with the same effects but different object instances are grouped into one cluster, and each cluster becomes a candidate operator. (2) Precondition learning then finds, for each cluster, the preconditions under which its effect occurs. For this, it scores the sets of observed predicates before each action. A candidate set is scored positively when it is consistently observed in the cluster’s own transitions, and negatively when it is observed in transitions for the same action that produced different effects. Note that these negative transitions come mostly from the random exploration data. At the end, the best-scoring set becomes the operator’s precondition. (3) Parameter estimation computes each effect’s probability by counting how often the effect occurs and dividing by the number of times the action was applied: p^k=nk/N p_k=n_k/N. Effects whose estimated probability falls below a threshold are discarded. The remaining outcomes are converted into deterministic operators via all-outcome determinization [37], yielding one deterministic operator per retained outcome. I-B Our Method I-B1 Macro-Operator Generation We generate macro-operators automatically through what we call effect-complement analysis. The goal is to find pairs of actions that may be causally linked. Two actions form such a pair when the first consistently adds a predicate that the second consistently deletes. The first action thus creates exactly the condition that the second one needs, and then removes it. We detect these pairs directly from the training trajectories as explained in Algorithm 1. In the rest of this subsection, we will detail this procedure step by step, with references to this algorithm. Algorithm 1 Macro-Operator Generation 1: D: oracle transitions (xi,ai,xi+1)(x_i,a_i,x_i+1); ℛR: random-exploration transitions (xi,ai,xi+1)(x_i,a_i,x_i+1); A: action types 2: MA_M: discovered macro action types; +T_+: macro transitions 3: // Phase 1: Finding consistent effects of each action type 4: for each transition (xi,ai,xi+1)∈(x_i,a_i,x_i+1) do 5: si←Parse(xi)s_i← Parse(x_i); si+1←Parse(xi+1)s_i+1← Parse(x_i+1) ⊳ Parse returns the predicates that hold in a continuous state 6: record added predicates si+1∖sis_i+1 s_i and deleted predicates si∖si+1s_i s_i+1 for action type aia_i 7: end for 8: for each action type a∈a do 9: Adds[a]←p∣Pr[p added∣a]>0.5Adds[a]←\\,p [\,p added a\,]>0.5\,\ 10: Dels[a]←p∣Pr[p deleted∣a]>0.5Dels[a]←\\,p [\,p deleted a\,]>0.5\,\ 11: end for 12: // Phase 2: Causal pairs 13: ←∅C← 14: for each ordered pair of action types (ai,ai+1)(a_i,a_i+1) with ai≠ai+1a_i≠ a_i+1 do 15: ℒ(ai,ai+1)←Adds[ai]∩Dels[ai+1]L(a_i,a_i+1) [a_i] [a_i+1] ⊳ predicates aia_i creates and ai+1a_i+1 removes 16: if ℒ(ai,ai+1)L(a_i,a_i+1) contains a predicate of arity >0>0 then 17: ←∪(ai,ai+1)C ∪\(a_i,a_i+1)\ 18: end if 19: end for 20: // Phase 3: Validation and conflict resolution 21: f(ai,ai+1)←f(a_i,a_i+1)← number of times (ai→ai+1)(a_i→ a_i+1) occurs consecutively in ∪ℛD 22: ←(ai,ai+1)∈∣f(ai,ai+1)>0V←\\,(a_i,a_i+1) f(a_i,a_i+1)>0\,\ 23: for each pair with both (ai,ai+1)(a_i,a_i+1) and (ai+1,ai)(a_i+1,a_i) in V do 24: remove from V the direction with the smaller f 25: end for 26: // Phase 4: Build macro operators 27: M←∅A_M← ; +←∅T_+← 28: for each consecutive (xi,ai,xi+1,ai+1,xi+2)(x_i,a_i,x_i+1,a_i+1,x_i+2) in ∪ℛD with (ai,ai+1)∈(a_i,a_i+1) do 29: Create macro action M by unifying the arguments of aia_i and ai+1a_i+1 30: M←M∪MA_M _M∪\M\; +←+∪(xi,M,xi+2)T_+ _+∪\(x_i,M,x_i+2)\ 31: end for 32: return M,+A_M,\;T_+ Terminology. Before describing the procedure, we distinguish two terms used throughout. An action type is a template such as Pick or Stack, whose arguments are not yet bound to concrete objects. An action is one grounded instance of such a template, such as Pick(b, r), in which the arguments refer to specific objects. The first step is to characterize what each action type consistently changes in the symbolic state. Phase 1: Consistent effects of each action type. The aim of this phase (lines 1-8) is to find consistent effects of actions from the oracle demonstration set D, as the non-consistent and rare effects are caused by sampling variance rather than by the action itself. We deliberately exclude the random-exploration set ℛR at this stage, since most of its actions fail and change nothing, which would dilute these ratios and hide effects that the action does produce reliably. D includes transitions in the form of (xi,ai,xi+1)(x_i,a_i,x_i+1): a continuous state xix_i, the action aia_i applied in it, and the resulting continuous state xi+1x_i+1. For every transition, we compute the symbolic states si=Parse(xi)s_i= Parse(x_i) and si+1=Parse(xi+1)s_i+1= Parse(x_i+1), where Parse is the function introduced in Section I-A. A predicate is added if it is absent in sis_i but present in si+1s_i+1, that is si+1∖sis_i+1 s_i. It is deleted if it is present in sis_i but absent in si+1s_i+1, that is si∖si+1s_i s_i+1. Grouping transitions by their action type, we count how often each predicate is added or deleted. A predicate is considered to be a consistent add of action type a if it is added in more than half of a’s transitions, and a consistent delete if it is deleted in more than half of the times. These two sets, denoted by Adds[a]Adds[a] and Dels[a]Dels[a], correspond to the output of Phase 1. Phase 2: Causal pairs. The aim of this phase (lines 9-15) is to find action types that are causally linked, where one action produces a condition that the next one needs. A good macro should join exactly such a pair, since merging them removes an intermediate step the planner would otherwise have to rediscover. In order to find the set of predicates that one action consistently creates and another consistently removes, we consider every ordered pair of action types (ai,ai+1)(a_i,a_i+1), where the subscripts denote the order in which the two would be applied rather than positions in a particular trajectory. For each such pair, we compute the causal-link set ℒ(ai,ai+1)=Adds[ai]∩Dels[ai+1]L(a_i,a_i+1)=Adds[a_i] [a_i+1]. A non-empty ℒ(ai,ai+1)L(a_i,a_i+1) means that aia_i produces a condition that ai+1a_i+1 then consumes, which is exactly the causal link we aim to find. In case a non-empty ℒ(ai,ai+1)L(a_i,a_i+1) contains only zero-arity predicates, i.e., predicates without object arguments, they are discarded because such global state predicates carry no object-specific causal link, and keeping them would create spurious pairings between unrelated actions. The output of this phase is the causal pair set C that contains action pairs with produced-and-consumed predicates with at least one object argument (e.g. Holding(block) or On(block, table)). Phase 3: Validation and conflict resolution. The aim of this phase (lines 16-20) is to identify the causal pairs with empirical support, as some pairs in C might be plausible on paper, but may never actually occur in the data. In order to validate that they are in the data, we count how often each candidate (ai,ai+1)∈(a_i,a_i+1) appears as two consecutive actions in the data. We use both the oracle demonstrations D and the random exploration set ℛR for this. Unlike Phase 1, this step counts occurrences rather than ratios, so the additional sequences in ℛR can only add evidence. Let f(ai,ai+1)f(a_i,a_i+1) denote this count. We store only the candidates that occur at least once, giving the validated set =(ai,ai+1)∈∣f(ai,ai+1)>0V=\(a_i,a_i+1) f(a_i,a_i+1)>0\. After verification, we resolve the conflicting cases when both (ai,ai+1)(a_i,a_i+1) and (ai+1,ai)(a_i+1,a_i) appear in V. Registering both would create two macros for the same underlying pattern, thereby inflating the search branching factor. Whenever both directions are present, we keep only the one with the higher frequency f and discard the other pair. Phase 4: Building macro operators. The goal of this phase (lines 21-26) is to turn each verified pair into one usable macro operator. This requires two components: a single argument list for the macro, and training transitions from which the next stage can learn. Both are obtained by scanning the data for occurrences of the pair. The first difficulty is that the two sub-actions have separate argument lists. Some objects appear in both actions, others in only one. To behave as a single operator, the macro needs one merged list in which a shared object occupies a single slot. We call this argument unification. Consider a Pick followed by a Stack in the Blocks domain: ai=Pick(b1)a_i= Pick(b_1) picks up block b1b_1, and ai+1=Stack(b1,b2)a_i+1= Stack(b_1,b_2) places it onto block b2b_2. Here b1b_1 is shared, and b2b_2 is specific to Stack, so the merged argument list is (b1,b2)(b_1,b_2). To recall how this list maps back to each sub-action, we store two index vectors: 1=(1)i_1=(1) for Pick, which uses only b1b_1, and 2=(1,2)i_2=(1,2) for Stack, which uses both. These vectors let the planner recover the original arguments of each sub-action when the macro is later split back into its two steps at execution time. The macro operator M produced this way is added to the macro action set MA_M. We then build the training data for M, that is, the transitions from which its preconditions and effects will later be learned. For every consecutive occurrence (xi,ai,xi+1,ai+1,xi+2)(x_i,a_i,x_i+1,a_i+1,x_i+2) in ∪ℛD with (ai,ai+1)∈(a_i,a_i+1) , we record a positive transition (xi,M,xi+2)(x_i,M,x_i+2). This transition skips the intermediate state xi+1x_i+1, so the macro appears to be a single step that takes the world from xix_i directly to xi+2x_i+2. These transitions form the set +T_+. Note that the set of shared objects can differ from one occurrence to another, so the same pair can yield more than one macro, each with its own argument pattern and its own preconditions and effects learned in the next stages. Generation leaves us with the macro action types MA_M and their positive transitions +T_+. At this point a macro is only a typed argument list together with a set of transitions, and not yet a usable operator. It has no learned preconditions or effects, no procedure for proposing continuous parameters for its two sub-actions, and no means of execution on the robot, since it does not belong to the original action set. The next section describes how we integrate the generated macros into the operator learning module to obtain all three. I-B2 Integrating Macros into the Operator Learning Module Negative Example Generation. To learn accurate preconditions, the module requires both positive and negative examples: states where the macro’s effect occurred, and states where it did not [29]. Phase 4 already provides the positives +T_+, but no negatives exist for macros. For individual actions, such negatives are already available: the random exploration set ℛR contains many states in which an action was attempted and produced no effect. Macros, however, were not part of the action set when ℛR was collected, so ℛR holds no such record for them. We must therefore generate macro negatives ourselves, and we do so by manufacturing states in which a macro clearly does not apply. To this end, for each macro type M∈M _M we draw a random state x from ℛR and bind the macro’s parameters to objects o of matching types. We then record the transition (x,M(),x)(x,M(o),x), in which the state is left unchanged. A macro that genuinely applied would alter the state, so an unchanged state is direct evidence that the macro’s preconditions did not hold in x. This makes (x,M(),x)(x,M(o),x) a valid negative, and these transitions form the negative set −T_-. Learning Macro Operators. To learn the generated macros without modifying the module, we present each one in the form it already expects for an ordinary action. It takes three inputs: action types A, demonstration transitions D, and random-exploration transitions ℛR that supply negatives. We augment each with its macro counterpart: ′=∪MA =A _M (generated macro types), ′=∪+D =D _+ (positive transitions from Phase 4), and ℛ′=ℛ∪−R =R _- (synthetic negatives). Each macro is therefore treated as an ordinary action type, and the module learns its preconditions and effects through the same three stages it applies to individual actions. The only macro-specific addition is a sequential sampler, described next. Sequential Continuous Sampling. A macro must still propose continuous values, such as a grasp pose for its first sub-action and a placement location for its second. These two are not independent: a valid placement depends on where the object was grasped. Sampling them separately would ignore this dependency and produce many infeasible combinations. We therefore give each macro a sequential sampler that respects the order of the two sub-actions. It samples the first sub-action’s parameters, simulates that sub-action to reach the intermediate state xi+1x_i+1, and then samples the second sub-action’s parameters conditioned on xi+1x_i+1. The index vectors from Phase 4 tell the sampler which arguments belong to each sub-action, and any parameter shared by both is sampled once and reused. The same index vectors are used once more after planning, when every macro in the returned plan is expanded back into its two sub-actions to give an executable plan over the original action set A. I-B3 Iterative Predicate Selection (IPS) The two preceding subsections together form our first contribution. Our second contribution targets the symbolic state itself. As described in the Background, the module turns each continuous state into a symbolic one by evaluating every predicate in the user-provided set P through Parse. The planner does this at every node it expands, so the cost of P is paid repetitively throughout the search. The set is also fixed before learning starts, which means the user must choose it without knowing which predicates the learned operators will end up using. These two facts together create the problem. Once learning has finished, some predicates in P turn out to appear in no learned precondition and in no learned effect. Such a predicate is still evaluated at every node, and it still enlarges the grounded state, that is, the symbolic state instantiated with all concrete objects in the scene. Yet no operator ever reads it or changes it, so the facts it produces are ones the planner can do nothing with. IPS removes them once operator learning is complete. Drawing on the principle of feature selection in machine learning [20], we retain only the predicates that occur in at least one learned operator. Writing O for the learned operator set and Preds[o]Preds[o] for the predicates appearing in the preconditions or effects of an operator o, the retained set is ′←∩⋃o∈Preds[o].P ∩ _o Preds[o]. (1) The planner then parses states with ′P in place of P. The operators themselves are left untouched, and the filter costs a single scan over O, which is negligible beside learning. IV Experiments IV-A Experimental Setup Our evaluation spans four TAMP domains, from simple tabletop manipulation to complex multi-stage cooking. Cover is the simplest: place two blocks on targets, performed in 2–4 steps. Blocks raises the difficulty by requiring six blocks to be stacked into goal configurations in approximately 10 steps. Painting adds object attributes such as color and dryness, producing 8 operators and plans of approximately 32 steps. Kitchen is the hardest: seven ingredients, each requiring pick, chop, cook, and plate in strict sequence, yielding plan lengths that overwhelm search when only individual actions are available. Operator learning is performed with the implementation of the baseline [32], and PyBullet [10] serves as the physics backend. Training data consists of expert demonstrations, where a planner with full access to the ground-truth operators solves each task, together with random exploration trajectories that expose the agent to a broader set of state transitions. The resulting probabilistic operators learned from this data are then determinized as described in Section I-A for use with A* search. Each domain uses 20 test problems evaluated over 5 independent seeds, with timeouts ranging from 1 to 10 s per problem. We compare the original baseline against our complete pipeline, referred to as Ours, which integrates both contributions presented in Section I: macro-operator generation (Sections I-B1 and I-B2) and Iterative Predicate Selection (Section I-B3). IV-B System Behavior: Learned Operators and Macro Discovery We examine macro discovery in detail in the Blocks domain, whose action set is small enough that every discovered macro can be checked by hand against what a person would expect. Effect-complement analysis. We apply the effect-complement analysis of Section I-B1 to this domain. Table I shows the outcome: five causal candidates emerge, and resolving reverse-ordered pairs by frequency leaves two validated macros, Pick→\!→\!PutOnTable (34.1% of consecutive pairs) and Pick→\!→\!Stack (28.0%). Both rest on the same causal link: Pick adds Holding(b), which PutOnTable and Stack each delete as their first precondition. This outcome is the desired one. In this domain, a picked block can only be placed on the table or stacked on another block, and these are exactly the two macros the analysis retains. Without any manual guidance, the procedure thus discovers all meaningful pick-and-place routines of the domain and discards only the spurious reverse orderings. TABLE I: Effect-complement macro discovery in the Blocks domain. Five causal candidates are identified; symmetric-pair resolution retains the two highest-frequency directions. Candidate Pair Shared Predicate(s) Frequency Retained Pick → PutOnTable Holding 34.1% ✓ Pick → Stack Clear, Holding 28.0% ✓ PutOnTable → Pick Clear 21.9% (symmetric) PutOnTable → Stack Clear 9.8% (symmetric) Stack → Pick Clear, On 6.1% (symmetric) Unified macro operators. Here we examine what the module actually learns for a validated pair. For each pair, the arguments of the two sub-actions are first unified into a single list (Section I-B1), and the module then learns the macro’s preconditions and effects from the augmented dataset, with no manual guidance. As an example, consider the Pick→\!→\!Stack macro for the case where block b1b_1 starts On another block b3b_3. Here Clear(b) means nothing is stacked on block b, On(b, b′b ) means b rests on b′b , and HandEmpty means the gripper holds nothing. The learned operator takes the following form: MacroPickStack(b1b_1:block, b2b_2:block, b3b_3:block) PRE: Clear(b1b_1) ∧ Clear(b2b_2) ∧ HandEmpty ∧ On(b1b_1,b3b_3) ADD: On(b1b_1,b2b_2) ∧ Clear(b3b_3) DEL: Clear(b2b_2) ∧ On(b1b_1,b3b_3) ∧ HandEmpty Read together, the operator says: starting from b1b_1 on b3b_3 with both b1b_1 and b2b_2 clear and the gripper empty, the macro ends with b1b_1 on b2b_2 and b3b_3 now clear. This is exactly what a domain engineer would write by hand for “pick b1b_1 off b3b_3 and stack it on b2b_2”, with the intermediate Holding state absorbed inside the macro. A second variant, for the case where b1b_1 starts OnTable rather than on another block, is discovered automatically. The precondition search treats the two situations as distinct patterns without any manual guidance. Planning implications. Adding these macros brings the total action set from 4 individual operators to 7. Executed plan lengths stay roughly the same (10.0±1.110.0± 1.1 steps after macro expansion versus 10.2±1.110.2± 1.1 for the baseline), but the A* search is considerably faster, dropping from 0.185±0.9120.185± 0.912 s to 0.040±0.0590.040± 0.059 s. Because each macro collapses two decisions into one, the effective branching factor at every step is reduced, and the planner reaches goal-relevant states with fewer search nodes. A representative solved plan illustrates this: [MacroPickPutOnTable(b5b_5, pose), [MacroPickPutOnTable(b4b_4, pose), [MacroPickStack(b4b_4, b3b_3), MacroPickStack(b5b_5, b4b_4), …] In the Kitchen domain, the same discovery process validates 3 causal pairs, namely Pick followed by each of the three placement actions (PlaceOnBoard, PlaceOnBurner, PlaceOnDish). Because these pairs occur with two different argument-sharing patterns, they yield 6 macro operators and 16 in total (10 individual + 6 macro). Without these macros, each of the 7-ingredient pick-chop-cook-plate workflows requires more than 50 individual steps, and the expanded plans our pipeline returns average 55.655.6 steps. This plan length overwhelms the A* search budget entirely. With macro operators, however, the same goals are achieved in 0.051±0.0190.051± 0.019 s across all 20 test problems. To confirm that the baseline failure is not merely a timeout issue, we ran it with the timeout disabled; no plan was found after 30 minutes on a single Kitchen problem. IV-C Baseline vs. Full Pipeline In this section we compare our full pipeline against the baseline on all four domains, in terms of success rate, planning time, and the structure of the learned operator sets (Tables I and I). Success rates. Both approaches achieve 100.0±0.0100.0± 0.0% on Painting. In Blocks, the baseline achieves 99.0±2.099.0± 2.0%. The single failure across five seeds occurs when the backtracking sampler exhausts its budget on a step whose geometric constraints (e.g. a tight grasp pose) are unusually hard to satisfy. Our full pipeline achieves a perfect 100.0±0.0100.0± 0.0% on this domain, because macros shorten the plan skeleton and the sampler therefore encounters fewer steps at which it can fail. In Cover the ordering reverses, and our pipeline drops to 98.0±4.098.0± 4.0%; we return to this domain below. The most consequential difference arises in Kitchen: every approach without macro operators achieves 0.00.0% success, while our macro-augmented pipeline solves all 100 test instances (20 problems × 5 seeds) without a single failure. These numbers show that macros do not cost reliability. On the three short domains the success rate stays within two points of the baseline. On Kitchen the gap is not small but total, since the baseline solves nothing there. Planning time. The impact of macro operators is most visible in Blocks, where our method achieves 0.040±0.0590.040± 0.059 s versus the baseline’s 0.185±0.9120.185± 0.912 s, a ∼4.6× 4.6× speedup arising from the reduced number of A* nodes that must be expanded to reach the goal. In Kitchen, our method plans in 0.051±0.0190.051± 0.019 s while the baseline fails entirely. Painting shows a small gain (0.028±0.0260.028± 0.026 s versus 0.024±0.0070.024± 0.007 s), as it is solved near-instantly regardless of the approach. Cover is the only domain where the cost of macros exceeds their benefit: our method needs 0.093±0.1900.093± 0.190 s against the baseline’s 0.001±0.0010.001± 0.001 s. Plans there are only two to four steps long, so the planner already finishes in about a millisecond, and the discovered Pick→ macro adds a further branch at every search node without any depth left to remove. The success rate is affected as well, although the effect is small in absolute terms: two of the 100 instances are left unsolved, which is within the variation we observe across seeds. This is the known trade-off in macro planning [7]. A macro is worthwhile only when the depth it removes outweighs the branching it adds. In a domain this small there is almost no depth left to remove. Across the four domains the pattern is clear. The benefit of macros grows with plan length: a net loss on two-step tasks, a speedup on ten-step tasks, and the difference between failure and success on the longest one. TABLE I: Planning performance of the baseline versus our full pipeline. Plan time and plan length are mean ± std over 5 seeds (20 problems each). “Failed” indicates 0.0%0.0\% success or no available measurement. Plan Time (s) Plan Length (steps) Domain Baseline Ours Baseline Ours Cover 0.001±0.0010.001± 0.001 0.093±0.1900.093± 0.190 2.6±0.02.6± 0.0 2.6±0.12.6± 0.1 Blocks 0.185±0.9120.185± 0.912 0.040±0.0590.040± 0.059 10.2±1.110.2± 1.1 10.0±1.110.0± 1.1 Painting 0.028±0.0260.028± 0.026 0.024±0.0070.024± 0.007 31.8±0.431.8± 0.4 31.8±0.431.8± 0.4 Kitchen Failed 0.051±0.0190.051± 0.019 Failed 55.6±0.055.6± 0.0 TABLE I: Structural properties of learned operator sets: operator count, predicate count after IPS, and training time. Operator learning succeeds in every domain, including Kitchen, where it is planning rather than learning that fails without macros. Operators Predicates Train Time (s) Domain Baseline Ours Baseline Ours Baseline Ours Cover 4 5 5 3 0.013 0.021 Blocks 4 7 6 5 0.069 0.196 Painting 8 9 14 14 3.829 3.918 Kitchen 10 16 8 8 0.271 0.424 Structural properties. Table I shows operator counts, predicate counts after IPS, and training times. Macro generation adds 3 operators in Blocks (one Pick→ and two Pick→ variants), 1 in Cover, 1 in Painting, and 6 in Kitchen. The number of macro operators exceeds the number of validated pairs whenever a pair occurs with different argument-sharing patterns, as explained in Section I-B1. IPS (Section I-B3) reduces the active predicate count in Cover (→35\!→\!3) and Blocks (→56\!→\!5) by removing predicates unreferenced by any learned operator. This directly shrinks the grounded state representation computed at each A* node. In Painting and Kitchen, all provided predicates appear in the learned rules, so IPS has no effect. Training times scale with operator set complexity: Painting requires ∼3.8 3.8 s due to its 8-operator, 14-predicate state space, while all other domains train in under 0.5 s. Macro generation adds modest overhead (e.g., →0.1960.069\!→\!0.196 s in Blocks) for generating macro transitions and learning preconditions for the additional operators. The cost of the method is therefore small. At most six operators are added, and training stays below four seconds in every domain. Both costs are paid once, before planning starts. The benefit returns at every node of every later search. IV-D Ablation Study: Isolating Component Contributions We test a subtractive ablation: start from the full model and remove one component at a time. This isolates the contribution of each component. We run the ablation on Blocks, where both components contribute but the effect is modest, and on Kitchen, where the macro component is the deciding factor. TABLE IV: Subtractive ablation on Blocks (5 seeds). Removing the macro component is the only modification that degrades both success rate and planning time. Variant Success (%) Plan Time (s) Operators Predicates Ours 100.0±0.0100.0± 0.0 0.041±0.0600.041± 0.060 7 5 Ours w/o IPS 100.0±0.0100.0± 0.0 0.042±0.0600.042± 0.060 7 6 Ours w/o Macro 99.0±2.099.0± 2.0 0.180±0.8860.180± 0.886 4 5 TABLE V: Subtractive ablation on Kitchen (5 seeds). Only removing macro operators causes complete failure. Variant Success (%) Plan Time (s) Operators Ours 100.0±0.0100.0± 0.0 0.050±0.0180.050± 0.018 16 Ours w/o IPS 100.0±0.0100.0± 0.0 0.051±0.0210.051± 0.021 16 Ours w/o Macro 0.0±0.00.0± 0.0 Failed 10 Blocks domain. Removing macros has the largest effect, as Table IV shows. The success rate decreases from 100.0100.0 to 99.0±2.099.0± 2.0% and planning time grows 4.4×4.4×, from 0.0410.041 to 0.1800.180 s. Removing IPS leaves the success rate at 100.0100.0% but adds one predicate back to the state, which carries a small cost at every A* node and raises planning time from 0.0410.041 to 0.0420.042 s. The two components work at different levels. IPS removes a fixed cost from every node. Macros reduce how many nodes are visited. Kitchen domain. Table V shows that Kitchen separates the two components more clearly. Removing IPS leaves performance essentially unchanged, since every provided predicate already appears in some learned operator and there is nothing left to prune. Removing the macros, however, takes the success rate to 0.0±0.00.0± 0.0% across every seed and problem, with no plan found even when the timeout is lifted (Section IV-B). The two ablations together explain what macro operators provide. Their gain is not a fixed percentage. It grows with the length of the task, and beyond a certain horizon it is the only reason a plan is found. V Conclusion Learning symbolic operators from data removes one of the main bottlenecks in deploying TAMP systems, yet existing methods leave two practical barriers in place: a symbolic state cluttered with predicates that no learned operator ever uses, and a planning horizon that search with individual actions alone cannot overcome. This work closes both gaps. We proposed an automated macro-operator generation pipeline that discovers causally linked action pairs through effect-complement analysis. We also proposed Iterative Predicate Selection, which prunes up to 40% of the unreferenced predicates and cuts the parsing overhead paid at every A* node. Taken together, the experiments suggest that the benefit of macro-operators is not a fixed speedup but a shortened effective planning horizon, whose value scales with the length of the task. In very short, two-step problems, the added branching outweighs that gain, so our method does not bring any advantage of the baseline method. In longer, for example 10-step problems, our method can achieve a ∼4.6× 4.6× speedup over the baseline method. Moreover, in tasks, for example, of more than 50 steps, it determines whether a plan is found at all: baseline individual-action planner can not solve that domain within thirty minutes, while our pipeline solves it in ∼0.05 0.05 s. Therefore, for long-horizon manipulation, finding which actions belong together is therefore a requirement for planning to work rather than a late optimization. Our current approach leaves several directions open. Our generation pipeline currently considers only pairs of consecutive actions. Extending it to longer chains or nested sequences (e.g., discovering full pick-wash-dry-place routines) would enable deeper plan abstraction. A second direction concerns the predicates themselves: our pipeline prunes unused predicates but cannot create new ones. Discovering new predicates automatically from sensor data would reduce the remaining domain engineering effort. Similarly, the continuous samplers that propose grasp poses and placement locations are currently hand-designed; learning them from interaction data would remove another manual component. All experiments in this work run in simulation using PyBullet [10]. Deploying the learned operators on a real robot would introduce noisy perception, imprecise execution, and sim-to-real transfer challenges that the current pipeline does not address. Evaluating robustness under these conditions is an important next step. Finally, the current system learns offline: it first collects all training data, then mines macros and learns operators in a single batch. An online variant that updates its operator set incrementally as the robot encounters new situations would be more practical for long-lived deployment, where the task distribution may shift over time. References [1] A. Ahmetoglu, B. Celik, E. Oztop, and E. Ugur (2024) Discovering predictive relational object symbols with symbolic attentive layers. IEEE Robotics and Automation Letters 9 (2), p. 1977–1984. Cited by: §I-B. [2] A. Ahmetoglu, E. Oztop, and E. Ugur (2025) Symbolic manipulation planning with discovered object and relational predicates. IEEE Robotics and Automation Letters 10 (2), p. 1968–1975. External Links: Document Cited by: §I-B. [3] A. Ahmetoglu, M. Y. Seker, J. Piater, E. Oztop, and E. Ugur (2022) DeepSym: deep symbol generation and rule learning for planning from unsupervised robot interaction. Journal of Artificial Intelligence Research 75, p. 709–745. Cited by: §I-B. [4] D. Aineto, S. Jiménez, and E. Onaindia (2018) Learning strips action models with classical planning. In Proceedings of the International Conference on Automated Planning and Scheduling, Vol. 28, p. 399–407. Cited by: §I, §I-B, §I-C. [5] A. Arora, H. Fiorino, D. Pellier, M. Métivier, and S. Pesty (2018) A review of learning planning action models. The Knowledge Engineering Review 33. Cited by: §I, §I-B. [6] B. Bonet and H. Geffner (2001) Planning as heuristic search. Artificial Intelligence 129 (1-2), p. 5–33. Cited by: §I-A. [7] A. Botea, M. Enzenberger, M. Müller, and J. Schaeffer (2005) Macro-F: improving AI planning with automatically learned macro-operators. Journal of Artificial Intelligence Research 24, p. 581–621. Cited by: §I-C, §IV-C. [8] S. Cambon, R. Alami, and F. Gravot (2009) A hybrid approach to intricate motion, manipulation and task planning. The International Journal of Robotics Research 28 (1), p. 104–126. Cited by: §I. [9] R. Chitnis, L. P. Kaelbling, and T. Lozano-Pérez (2019) Learning quickly to plan quickly using modular meta-learning. In 2019 International Conference on Robotics and Automation (ICRA), p. 7865–7871. Cited by: §I, §I-B. [10] E. Coumans and Y. Bai (2016) PyBullet, a Python module for physics simulation for games, robotics and machine learning. Note: GitHub Cited by: §IV-A, §V. [11] S. N. Cresswell, T. L. McCluskey, and M. M. West (2013) Acquiring planning domain models using locm. In The Knowledge Engineering Review, Vol. 28, p. 195–213. Cited by: §I-B. [12] N. T. Dantam, Z. K. Kingston, S. Chaudhuri, and L. E. Kavraki (2016) Incremental task and motion planning: a constraint-based approach.. In Robotics: Science and Systems (RSS), Cited by: §I-A. [13] D. Driess, J. Ha, and M. Toussaint (2020) Deep visual reasoning: learning to predict action sequences for task and motion planning from an initial scene image. In Proceedings of Robotics: Science and Systems (RSS), Cited by: §I, §I-B. [14] R. E. Fikes, P. E. Hart, and N. J. Nilsson (1972) Learning and executing generalized robot plans. Artificial intelligence 3 (1-3), p. 251–288. Cited by: §I-C. [15] M. Fox and D. Long (2003) PDDL2.1: an extension to pddl for expressing temporal planning domains. Journal of Artificial Intelligence Research 20, p. 61–124. Cited by: §I, §I-A. [16] C. R. Garrett, R. Chitnis, R. Holladay, B. Kim, T. Silver, L. P. Kaelbling, and T. Lozano-Perez (2021) Integrated task and motion planning. Annual Review of Control, Robotics, and Autonomous Systems 4, p. 265–293. Cited by: §I, §I-A. [17] C. R. Garrett, T. Lozano-Pérez, and L. P. Kaelbling (2018) FFRob: leveraging symbolic planning for efficient task and motion planning. The International Journal of Robotics Research 37 (1), p. 104–136. Cited by: §I. [18] C. R. Garrett, T. Lozano-Pérez, and L. P. Kaelbling (2020) PDDLStream: integrating symbolic planners and blackbox samplers via optimistic adaptive planning. In Proceedings of the International Conference on Automated Planning and Scheduling, Vol. 30, p. 440–448. Cited by: §I, §I-A. [19] E. Gizzi, M. G. Castro, and J. Sinapov (2019) Creative problem solving by robots using action primitive discovery. In International Conference on Development and Learning and Epigenetic Robotics (ICDL-EpiRob), p. 228–233. Cited by: §I-C. [20] I. Guyon and A. Elisseeff (2003) An introduction to variable and feature selection. Journal of Machine Learning Research 3, p. 1157–1182. Cited by: §I-B3. [21] P. E. Hart, N. J. Nilsson, and B. Raphael (1968) A formal basis for the heuristic determination of minimum cost paths. IEEE Transactions on Systems Science and Cybernetics 4 (2), p. 100–107. Cited by: §I-A. [22] J. Huang, A. Tao, R. Marco, M. Bogdanovic, J. Kelly, and F. Shkurti (2025) Automated planning domain inference for task and motion planning. In 2025 IEEE International Conference on Robotics and Automation (ICRA), p. 12534–12540. Cited by: §I-B. [23] L. P. Kaelbling and T. Lozano-Pérez (2011) Hierarchical task and motion planning in the now. In 2011 IEEE International Conference on Robotics and Automation, p. 1470–1477. Cited by: §I-A. [24] B. Kim, L. P. Kaelbling, and T. Lozano-Pérez (2017) Learning to guide task and motion planning using score-space representation. In 2017 IEEE International Conference on Robotics and Automation (ICRA), p. 2810–2817. Cited by: §I, §I-B. [25] B. Kim and L. Shimanuki (2020) Learning value functions with relational state representations for guiding task-and-motion planning. In Conference on Robot Learning, p. 955–968. Cited by: §I, §I-B. [26] G. Konidaris, L. P. Kaelbling, and T. Lozano-Perez (2018) From skills to symbols: learning symbolic representations for abstract high-level planning. Journal of Artificial Intelligence Research 61, p. 215–289. Cited by: §I-B. [27] R. E. Korf (1985) Learning to solve problems by searching for macro-operators. Pitman. Cited by: §I-C. [28] M.A. H. Newton, J. Levine, M. Fox, and D. Long (2007) Learning macro-actions for arbitrary planners and domains. In Proceedings of the International Conference on Automated Planning and Scheduling (ICAPS), Cited by: §I-C. [29] H. M. Pasula, L. S. Zettlemoyer, and L. P. Kaelbling (2007) Learning symbolic models of stochastic domains. Journal of Artificial Intelligence Research 29, p. 309–352. Cited by: §I, §I-B, §I-C, §I-B2. [30] V. Sarathy, D. Kasenberg, S. Goel, J. Sinapov, and M. Scheutz (2021) Spotter: extending symbolic planning operators through targeted reinforcement learning. In Proceedings of the 20th International Conference on Autonomous Agents and MultiAgent Systems (AAMAS), p. 1118–1126. Cited by: §I-C. [31] T. Silver, R. Chitnis, N. Kumar, W. McClinton, T. Lozano-Perez, L. P. Kaelbling, and J. B. Tenenbaum (2023) Predicate invention for bilevel planning. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 37, p. 12120–12129. External Links: Document Cited by: §I-B. [32] T. Silver, R. Chitnis, J. Tenenbaum, L. P. Kaelbling, and T. Lozano-Perez (2021) Learning symbolic operators for task and motion planning. In 2021 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), p. 3182–3189. External Links: Document Cited by: §I, §I, §I-B, §I-C, §I-A, §IV-A. [33] S. Srivastava, E. Fang, L. Riano, R. Chitnis, S. Russell, and P. Abbeel (2014) Combined task and motion planning through an extensible planner-independent interface layer. In International Conference on Robotics and Automation (ICRA), p. 639–646. Cited by: §I-A. [34] M. Toussaint (2015) Logic-geometric programming: an optimization-based approach to combined task and motion planning.. In IJCAI, p. 1930–1936. Cited by: §I-A. [35] E. Ugur, A. Ahmetoglu, Y. Nagai, T. Taniguchi, M. Saveriano, and E. Oztop (2025) Neuro-symbolic robotics. Note: TechRxiv External Links: Document, Link Cited by: §I-B. [36] R. Veerapaneni, J. D. Co-Reyes, M. Chang, M. Janner, C. Finn, J. Wu, J. B. Tenenbaum, and S. Levine (2020) Entity abstraction in visual model-based reinforcement learning. In Conference on Robot Learning (CoRL), Cited by: §I-B. [37] S. W. Yoon, A. Fern, and R. Givan (2007) F-replan: a baseline for probabilistic planning. In ICAPS, Vol. 7, p. 352–359. Cited by: §I-A. [38] Z. Wang, C. R. Garrett, L. P. Kaelbling, and T. Lozano-Pérez (2018) Active model learning and diverse action sampling for task and motion planning. In 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), p. 4107–4114. Cited by: §I, §I, §I-B. [39] V. Xia, Z. Wang, K. R. Allen, T. Silver, and L. P. Kaelbling (2019) Learning sparse relational transition models. In International Conference on Learning Representations, Cited by: §I-B, §I-C. [40] Y. Zhu, J. Tremblay, S. Birchfield, and Y. Zhu (2021) Hierarchical planning for long-horizon manipulation with geometric and symbolic scene graphs. In 2021 IEEE International Conference on Robotics and Automation (ICRA), p. 6541–6548. External Links: Document Cited by: §I, §I-A. Can Emir Bora is currently pursuing the B.S. degree in computer engineering with Boğaziçi University, Istanbul, Turkey. He is currently an Undergraduate Researcher with the Cognition, Learning and Robotics (CoLoRs) Lab, Boğaziçi University, under the supervision of Associate Professor Emre Ugur. He also has professional industry experience as a Software Engineer, focusing on the development of scalable backend architectures and microservices. His research interests include cognitive robotics, robot learning, computer vision, and machine learning. Emre Ugur is an Associate Professor of Computer Engineering at Boğaziçi University, Istanbul, Türkiye. He received his B.Sc., M.Sc., and Ph.D. degrees in Computer Engineering from Middle East Technical University (METU), Ankara, Türkiye. He previously worked at ATR Computational Neuroscience Laboratories in Japan, the University of Innsbruck in Austria, and Osaka University in Japan. He currently leads the Cognition, Learning and Robotics (CoLoRs) Lab at Boğaziçi University. His research interests include cognitive robotics, robot learning, developmental robotics, neuro-symbolic artificial intelligence, symbol emergence, and learning from demonstration.