Overview
Ada uses language-model proposals to build planner-compatible action libraries and grounds those actions through environment interaction.
At a glance
Action Domain Acquisition learns high-level symbolic operators and reusable low-level control routines for a collection of language-described tasks. A language model proposes goals and operators; a hierarchical planner and execution feedback test their usefulness. The reported experiments solve all tested Mini Minecraft tasks and 79% of selected ALFRED tasks under a best-of-proposals protocol. These results assume predefined predicates, state abstractions, goal checking, and simplified navigation, rather than learning planning directly from raw visual observations.
1 Introduction
Long tasks become easier when useful subgoals and reusable actions are available, but those abstractions are often hand-designed. Ada uses linguistic background knowledge as a proposal source and environment interaction to filter it. The intended library must support symbolic composition and realizable local control. Language-model output alone is not treated as an executable or universally correct world model.
2 Problem Formulation
The formulation assumes deterministic low-level transitions, a fixed known mapping from raw states to symbolic predicates, and language-described goals whose success can be queried. Each high-level operator contains a name, typed arguments, preconditions, effects, and an associated controller. A symbolic plan sequences operators; low-level procedures attempt to achieve their effects.
Operator semantics ideally promise successful effects whenever preconditions hold, but the learned library is validated by finite executions and thresholds. Empirical acceptance does not prove that promise over every possible state. The given predicates, abstraction map, and success signal are substantial prior structure.
3 Action Abstractions from Language
Each iteration proposes candidate operators, translates task goals, attempts hierarchical plans, learns local control routines, and retains operators with enough successful executions. The process aims to adapt both abstraction granularity and control to the domain, rather than simply accumulate every plausible language-generated skill.
3.1 Operator Proposal
A first prompt decomposes tasks into named actions using language goals and a shortened symbolic state containing unary features. Undefined action names then seed a second prompt that generates typed PDDL preconditions and effects. Syntax repair removes invalid predicates or types and can leave an operator underspecified; execution-based filtering must handle those remaining errors. The proposed action sequence is used to discover vocabulary, while a formal planner builds the eventual plan.
Equation
3.2 Goal Proposal and Bi-Level Planning
The model proposes several first-order goal formulas because natural-language descriptions can be ambiguous. Fast Downward searches for a symbolic plan under the candidate operators. Each operator’s instantiated effects become a local subgoal, which receives a bounded low-level search budget. A complete low-level sequence is finally checked against the environment’s hidden true goal.
Successful local effects and correct interpretation of the final task are distinct: a physically feasible sequence can still solve the wrong proposed goal. Multiple proposals and an external task-success checker are part of the reported performance.
Equation
| for each unsolved task : | |||
3.3 Policy Learning and Guided Low-Level Search
Local search experience is reused through a shared subgoal-conditioned controller. The implemented controller is a dictionary of lifted action sequences, rather than the neural policy suggested as an option in the general framework. Hindsight relabeling turns encountered state changes into additional achieved subgoals, even when a search fails its original objective.
Equation
3.4 Scoring LLM Operator Proposals
An operator is retained only after enough attempted uses and a sufficiently high ratio of successful local-subgoal executions. This tests practical compatibility with the controller and environment. Its score does not depend on whether the language model’s final-goal interpretation matches the true task, and a high empirical ratio is not a formal soundness certificate.
Equation
4 Experiments
Mini Minecraft tests mining, crafting, and their composition, with over two thousand possible grounded actions and up to twenty-six steps excluding path planning. ALFRED uses household tasks in simulation, with predefined object/state predicates and goal descriptions. Both environments provide a direct move-to primitive, removing ordinary navigation planning from the evaluation.
Except for the stated compositional-transfer settings, systems make two learning passes over the same randomly ordered tasks whose final accuracy is reported. Four goal proposals, four task decompositions, and three operator-definition proposals are sampled; a task counts as solved if at least one proposed-goal attempt passes verification. Thus the headline scores are best-of attempts after interactive task exposure, not single-shot held-out success.
Low-level search budgets are at most one thousand nodes per Minecraft subgoal and fifty per ALFRED subgoal. The ALFRED subset contains 223 tasks after manually removing 27 of an initial 250 whose language goals were judged completely misspecified. Baselines adapt goal-only planning, language-predicted subgoals, and a Voyager-like Python skill library. They are reimplementations within this setup, not a direct comparison to the original systems’ full benchmark results.
4.1 Results
With GPT-3.5 and three replications, Ada reports 100% on mining, crafting, and compositional Minecraft tasks. Skills for the compositional Minecraft test come from simpler mining/crafting training. On the selected ALFRED set, Ada reaches 79% versus 21% for low-level planning only and 2% each for the subgoal and code-policy baselines. The original table pairs 100% means with nonzero standard deviations of 7.5% and 4.1% in two Minecraft columns; this inconsistency is preserved and not reconciled into invented corrected values.
The learned household libraries recover the needed operator structure, with slicing sometimes split into knife-specific operators or restricted to one knife type. Remaining failures include incorrect goal interpretation, limited low-level geometric control, and overrestrictive operators. The true goal appears among the top four proposals about 92% of the time, which measures proposal coverage rather than successful execution.
The code-library baseline must also rely on a language model to sequence Python skills and grows a much larger library. The results therefore compare complete representation/planning designs, not just programming-language syntax. The appendix’s GPT-4 comparison again favors Ada: 100% across Minecraft and 70% on ALFRED versus 12/37/11% and 11% for the code baseline. GPT-4 does not improve Ada’s reported ALFRED score over the GPT-3.5 setting.
| Mini Minecraft (n=3) | LLM Predicts? | Library? | Mining | Crafting | Compositional |
| Low-level Planning Only | Goal | ✗ | 31% (=0.0%) | 9% (=0.0%) | 9% (=0.0%) |
| Subgoal Prediction | Sub-goals | ✗ | 33% (=1.6%) | 36% (=5.6%) | 6% (=1.7%) |
| Code Policy Prediction | Sub-policies | ✓ | 15% (=1.2%) | 39% (=3.2%) | 10% (=1.7%) |
| Ada (Ours) | Goal+Operators | ✓ | 100% (=0.0%) | 100% (=7.5%) | 100% (=4.1%) |
| ALFRED (n=3 replications) | LLM Predicts? | Library? | Original (Simple + Compositional Tasks) | ||
| Low-level Planning Only | Goal | ✗ | 21% (=1.0%) | ||
| Subgoal Prediction | Sub-goal | ✗ | 2% (=0.4%) | ||
| Code Policy Prediction | Sub-policies | ✓ | 2% (=0.9%) | ||
| Ada (Ours) | Goal+Operators | ✓ | 79% (=0.9%) | ||
5 Related Work
Prior work uses language models to predict plans, formal goals, executable code, or learned abstractions. Ada’s distinguishing choice is to learn reusable symbolic operators that can be searched by an established planner and connected to local control. It draws on hierarchical planning and program-library learning, while relying on a supplied symbolic state vocabulary and interaction-based validation.
6 Discussion and Future Work
The framework does not learn its initial predicates from perception or tackle detailed geometric motor planning. It also relies on a general-purpose language model and externally checkable goals. Proposed extensions include perceptual predicate acquisition and transferring the learned planning structure into faster models. The current evidence supports structured domain acquisition in the two simplified simulation settings, not autonomous robot deployment from raw inputs.
Appendix A Appendix
The appendix specifies prompting, syntax repair, local search, a GPT-4 comparison, and the complete example planning domains. The original source libraries omitted from the HTML are restored below.
A.1 Additional Methods Implementation Details
Implementation details explain the supplied examples, sampling choices, and memory of successful local trajectories that affect reproducibility.
A.1.1 LLM Prompting
Experiments use gpt-3.5-turbo-16k with temperature one. Decomposition and operator prompts include constructed examples that avoid the target learned skills, then add successful examples from later iterations. Goal prompting separately uses ground-truth goal definitions from a randomly chosen 10% of the training distribution as initial supervision; the approach is therefore not free of labeled goal examples.
To obtain diverse alternatives, prompts ask for several distinct definitions directly rather than relying only on repeated token sampling. Invalid predicates and arguments are removed or repaired using known domain typing, and empty effects/goals are rejected. Such repairs can erase necessary conditions, which is why subsequent environment validation remains essential. The exact goal- and operator-proposal budgets are those described in the main setup.
| Mini Minecraft | LLM Predicts? | Library? | Mining | Crafting | Compositional |
| Code Policy Prediction | Sub-policies | ✓ | 12% | 37% | 11% |
| Ours | Goal+Operators | ✓ | 100% | 100% | 100% |
| ALFRED (n=3 replications) | LLM Predicts? | Library? | Original (Simple + Compositional Tasks) | ||
| Code Policy Prediction | Sub-policies | ✓ | 11% | ||
| Ours | Goal+Operators | ✓ | 70% | ||
A.1.2 Policy Learning and Guided Low-level Search
A dictionary maps lifted subgoal descriptions to candidate action trajectories. Object names are replaced with variables so successful routines can transfer across instances. Matching stored trajectories are tried first and ranked by observed success counts; otherwise the method falls back to breadth-first search. Every explored trajectory can contribute a hindsight-labeled state-change example, even when it fails the current target.
A.2 Experiments
The complete original Mini Minecraft and ALFRED domain files are retained verbatim from the paper’s arXiv source archive. They include the supplied types, constants, predicates, and initial actions as well as the example learned operators. These are libraries from a sampled run, not a compact list containing only newly acquired skills.
The Minecraft file exposes inventory and hypothetical-object bookkeeping for mining and crafting, while the household file includes pickup/placement, rinsing, toggling, cooling, knife-specific slicing, and heating. Original names, duplicate variants, indentation, and syntax are preserved for inspection; restoration does not silently repair or revalidate the planners’ domains.
(define (domain crafting-world-v20230404-teleport)
(:requirements :strips)
(:types
tile
object
inventory
object-type
)
(:constants
Key - object-type
WorkStation - object-type
Pickaxe - object-type
IronOreVein - object-type
IronOre - object-type
IronIngot - object-type
CoalOreVein - object-type
Coal - object-type
GoldOreVein - object-type
GoldOre - object-type
GoldIngot - object-type
CobblestoneStash - object-type
Cobblestone - object-type
Axe - object-type
Tree - object-type
Wood - object-type
WoodPlank - object-type
Stick - object-type
Sword - object-type
Chicken - object-type
Feather - object-type
Arrow - object-type
Shears - object-type
Sheep - object-type
Wool - object-type
Bed - object-type
Boat - object-type
SugarCanePlant - object-type
SugarCane - object-type
Paper - object-type
Bowl - object-type
PotatoPlant - object-type
Potato - object-type
CookedPotato - object-type
BeetrootCrop - object-type
Beetroot - object-type
BeetrootSoup - object-type
Hypothetical - object-type
Trash - object-type
)
(:predicates
(tile-up ?t1 - tile ?t2 - tile)
(tile-down ?t1 - tile ?t2 - tile)
(tile-left ?t1 - tile ?t2 - tile)
(tile-right ?t1 - tile ?t2 - tile)
(agent-at ?t - tile)
(object-at ?x - object ?t - tile)
(inventory-holding ?i - inventory ?x - object)
(inventory-empty ?i - inventory)
(object-of-type ?x - object ?ot - object-type)
)
(:action move-to
:parameters (?t1 - tile ?t2 - tile)
:precondition (and (agent-at ?t1))
:effect (and (agent-at ?t2) (not (agent-at ?t1)))
)
(:action pick-up
:parameters (?i - inventory ?x - object ?t - tile)
:precondition (and (agent-at ?t) (object-at ?x ?t) (inventory-empty ?i))
:effect (and (inventory-holding ?i ?x) (not (object-at ?x ?t)) (not (inventory-empty ?i)))
)
(:action place-down
:parameters (?i - inventory ?x - object ?t - tile)
:precondition (and (agent-at ?t) (inventory-holding ?i ?x))
:effect (and (object-at ?x ?t) (not (inventory-holding ?i ?x)) (inventory-empty ?i))
)
(:action mine-iron-ore
:parameters (?toolinv - inventory ?targetinv - inventory ?x - object ?tool - object ?target - object ?t - tile)
:precondition (and
(agent-at ?t)
(object-at ?x ?t)
(object-of-type ?x IronOreVein)
(inventory-holding ?toolinv ?tool)
(object-of-type ?tool Pickaxe)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target IronOre)
)
)
(:action mine-wood_2
:parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?x ?t)
(object-of-type ?x Tree)
(inventory-holding ?toolinv ?tool)
(object-of-type ?tool Axe)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Wood)
)
)
(:action mine-wool1_0
:parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?x ?t)
(object-of-type ?x Sheep)
(inventory-holding ?toolinv ?tool)
(object-of-type ?tool Shears)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Wool)
)
)
(:action mine-potato_0
:parameters (?t - tile ?x - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?x ?t)
(object-of-type ?x PotatoPlant)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Potato)
)
)
(:action mine-sugar-cane_2
:parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?x ?t)
(object-of-type ?x SugarCanePlant)
(inventory-holding ?toolinv ?tool)
(object-of-type ?tool Axe)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target SugarCane)
)
)
(:action mine-beetroot_1
:parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?x ?t)
(object-of-type ?x BeetrootCrop)
(inventory-holding ?toolinv ?tool)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Beetroot)
)
)
(:action mine-feather_1
:parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?x ?t)
(object-of-type ?x Chicken)
(inventory-holding ?toolinv ?tool)
(object-of-type ?tool Sword)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Feather)
)
)
(:action mine-cobblestone_2
:parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?x ?t)
(object-of-type ?x CobblestoneStash)
(inventory-holding ?toolinv ?tool)
(object-of-type ?tool Pickaxe)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Cobblestone)
)
)
(:action mine-gold-ore1_2
:parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?x ?t)
(object-of-type ?x GoldOreVein)
(inventory-holding ?toolinv ?tool)
(object-of-type ?tool Pickaxe)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target GoldOre)
)
)
(:action mine-coal1_0
:parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?x ?t)
(object-of-type ?x CoalOreVein)
(inventory-holding ?toolinv ?tool)
(object-of-type ?tool Pickaxe)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Coal)
)
)
(:action mine-beetroot1_0
:parameters (?t - tile ?x - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?x ?t)
(object-of-type ?x BeetrootCrop)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Beetroot)
)
)
(:action craft-wood-plank
:parameters (?ingredientinv1 - inventory ?targetinv - inventory ?station - object ?ingredient1 - object ?target - object ?t - tile)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 Wood)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target WoodPlank)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 Wood))
(object-of-type ?ingredient1 Hypothetical)
)
)
(:action craft-arrow
:parameters (?ingredientinv1 - inventory ?ingredientinv2 - inventory ?targetinv - inventory ?station - object ?ingredient1 - object ?ingredient2 - object ?target - object ?t - tile)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 Stick)
(inventory-holding ?ingredientinv2 ?ingredient2)
(object-of-type ?ingredient2 Feather)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Arrow)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 Stick))
(object-of-type ?ingredient1 Hypothetical)
(not (inventory-holding ?ingredientinv2 ?ingredient2))
(inventory-empty ?ingredientinv2)
(not (object-of-type ?ingredient2 Feather))
(object-of-type ?ingredient2 Hypothetical)
)
)
(:action craft-beetroot-soup_0
:parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 Beetroot)
(inventory-holding ?ingredientinv2 ?ingredient2)
(object-of-type ?ingredient2 Bowl)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target BeetrootSoup)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 Beetroot))
(object-of-type ?ingredient1 Hypothetical)
(not (inventory-holding ?ingredientinv2 ?ingredient2))
(inventory-empty ?ingredientinv2)
(not (object-of-type ?ingredient2 Bowl))
(object-of-type ?ingredient2 Hypothetical)
)
)
(:action craft-paper_0
:parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 SugarCane)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Paper)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 SugarCane))
(object-of-type ?ingredient1 Hypothetical)
)
)
(:action craft-shears2_2
:parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 GoldIngot)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Shears)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 GoldIngot))
(object-of-type ?ingredient1 Hypothetical)
)
)
(:action craft-bowl_1
:parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 WoodPlank)
(inventory-holding ?ingredientinv2 ?ingredient2)
(object-of-type ?ingredient2 WoodPlank)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Bowl)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 WoodPlank))
(object-of-type ?ingredient1 Hypothetical)
(not (inventory-holding ?ingredientinv2 ?ingredient2))
(inventory-empty ?ingredientinv2)
(not (object-of-type ?ingredient2 WoodPlank))
(object-of-type ?ingredient2 Hypothetical)
)
)
(:action craft-boat_0
:parameters (?t - tile ?station - object ?ingredientinv - inventory ?ingredient - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv ?ingredient)
(object-of-type ?ingredient WoodPlank)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Boat)
(not (inventory-holding ?ingredientinv ?ingredient))
(inventory-empty ?ingredientinv)
(not (object-of-type ?ingredient WoodPlank))
(object-of-type ?ingredient Hypothetical)
)
)
(:action craft-cooked-potato_1
:parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 Potato)
(inventory-holding ?ingredientinv2 ?ingredient2)
(object-of-type ?ingredient2 Coal)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target CookedPotato)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 Potato))
(object-of-type ?ingredient1 Hypothetical)
(not (inventory-holding ?ingredientinv2 ?ingredient2))
(inventory-empty ?ingredientinv2)
(not (object-of-type ?ingredient2 Coal))
(object-of-type ?ingredient2 Hypothetical)
)
)
(:action craft-gold-ingot_1
:parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 GoldOre)
(inventory-holding ?ingredientinv2 ?ingredient2)
(object-of-type ?ingredient2 Coal)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target GoldIngot)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 GoldOre))
(object-of-type ?ingredient1 Hypothetical)
(not (inventory-holding ?ingredientinv2 ?ingredient2))
(inventory-empty ?ingredientinv2)
(not (object-of-type ?ingredient2 Coal))
(object-of-type ?ingredient2 Hypothetical)
)
)
(:action craft-stick_0
:parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 WoodPlank)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Stick)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 WoodPlank))
(object-of-type ?ingredient1 Hypothetical)
)
)
(:action craft-sword_0
:parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 Stick)
(inventory-holding ?ingredientinv2 ?ingredient2)
(object-of-type ?ingredient2 IronIngot)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Sword)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 Stick))
(object-of-type ?ingredient1 Hypothetical)
(not (inventory-holding ?ingredientinv2 ?ingredient2))
(inventory-empty ?ingredientinv2)
(not (object-of-type ?ingredient2 IronIngot))
(object-of-type ?ingredient2 Hypothetical)
)
)
(:action craft-bed_1
:parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 WoodPlank)
(inventory-holding ?ingredientinv2 ?ingredient2)
(object-of-type ?ingredient2 Wool)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target Bed)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 WoodPlank))
(object-of-type ?ingredient1 Hypothetical)
(not (inventory-holding ?ingredientinv2 ?ingredient2))
(inventory-empty ?ingredientinv2)
(not (object-of-type ?ingredient2 Wool))
(object-of-type ?ingredient2 Hypothetical)
)
)
(:action craft-iron-ingot_2
:parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)
:precondition (and
(agent-at ?t)
(object-at ?station ?t)
(object-of-type ?station WorkStation)
(inventory-holding ?ingredientinv1 ?ingredient1)
(object-of-type ?ingredient1 IronOre)
(inventory-holding ?ingredientinv2 ?ingredient2)
(object-of-type ?ingredient2 Coal)
(inventory-empty ?targetinv)
(object-of-type ?target Hypothetical)
)
:effect (and
(not (inventory-empty ?targetinv))
(inventory-holding ?targetinv ?target)
(not (object-of-type ?target Hypothetical))
(object-of-type ?target IronIngot)
(not (inventory-holding ?ingredientinv1 ?ingredient1))
(inventory-empty ?ingredientinv1)
(not (object-of-type ?ingredient1 IronOre))
(object-of-type ?ingredient1 Hypothetical)
(not (inventory-holding ?ingredientinv2 ?ingredient2))
(inventory-empty ?ingredientinv2)
(not (object-of-type ?ingredient2 Coal))
(object-of-type ?ingredient2 Hypothetical)
)
)
)
(define (domain alfred)
(:requirements :adl
)
(:types
agent location receptacle object rtype otype
)
(:constants
CandleType - otype
ShowerGlassType - otype
CDType - otype
TomatoType - otype
MirrorType - otype
ScrubBrushType - otype
MugType - otype
ToasterType - otype
PaintingType - otype
CellPhoneType - otype
LadleType - otype
BreadType - otype
PotType - otype
BookType - otype
TennisRacketType - otype
ButterKnifeType - otype
ShowerDoorType - otype
KeyChainType - otype
BaseballBatType - otype
EggType - otype
PenType - otype
ForkType - otype
VaseType - otype
ClothType - otype
WindowType - otype
PencilType - otype
StatueType - otype
LightSwitchType - otype
WatchType - otype
SpatulaType - otype
PaperTowelRollType - otype
FloorLampType - otype
KettleType - otype
SoapBottleType - otype
BootsType - otype
TowelType - otype
PillowType - otype
AlarmClockType - otype
PotatoType - otype
ChairType - otype
PlungerType - otype
SprayBottleType - otype
HandTowelType - otype
BathtubType - otype
RemoteControlType - otype
PepperShakerType - otype
PlateType - otype
BasketBallType - otype
DeskLampType - otype
FootstoolType - otype
GlassbottleType - otype
PaperTowelType - otype
CreditCardType - otype
PanType - otype
ToiletPaperType - otype
SaltShakerType - otype
PosterType - otype
ToiletPaperRollType - otype
LettuceType - otype
WineBottleType - otype
KnifeType - otype
LaundryHamperLidType - otype
SpoonType - otype
TissueBoxType - otype
BowlType - otype
BoxType - otype
SoapBarType - otype
HousePlantType - otype
NewspaperType - otype
CupType - otype
DishSpongeType - otype
LaptopType - otype
TelevisionType - otype
StoveKnobType - otype
CurtainsType - otype
BlindsType - otype
TeddyBearType - otype
AppleType - otype
WateringCanType - otype
SinkType - otype
ArmChairType - rtype
BedType - rtype
BathtubBasinType - rtype
DresserType - rtype
SafeType - rtype
DiningTableType - rtype
SofaType - rtype
HandTowelHolderType - rtype
StoveBurnerType - rtype
CartType - rtype
DeskType - rtype
CoffeeMachineType - rtype
MicrowaveType - rtype
ToiletType - rtype
CounterTopType - rtype
GarbageCanType - rtype
CoffeeTableType - rtype
CabinetType - rtype
SinkBasinType - rtype
OttomanType - rtype
ToiletPaperHangerType - rtype
TowelHolderType - rtype
FridgeType - rtype
DrawerType - rtype
SideTableType - rtype
ShelfType - rtype
LaundryHamperType - rtype
)
;; Predicates defined on this domain. Note the types for each predicate.
(:predicates
(atLocation ?a - agent ?l - location)
(receptacleAtLocation ?r - receptacle ?l - location)
(objectAtLocation ?o - object ?l - location)
(inReceptacle ?o - object ?r - receptacle)
(receptacleType ?r - receptacle ?t - rtype)
(objectType ?o - object ?t - otype)
(holds ?a - agent ?o - object)
(holdsAny ?a - agent)
(holdsAnyReceptacleObject ?a - agent)
(openable ?r - receptacle)
(opened ?r - receptacle)
(isClean ?o - object)
(cleanable ?o - object)
(isHot ?o - object)
(heatable ?o - object)
(isCool ?o - object)
(coolable ?o - object)
(toggleable ?o - object)
(isToggled ?o - object)
(sliceable ?o - object)
(isSliced ?o - object)
)
(:action PickupObjectNotInReceptacle
:parameters (?a - agent ?l - location ?o - object)
:precondition (and
(atLocation ?a ?l)
(objectAtLocation ?o ?l)
(not (holdsAny ?a))
(forall
(?re - receptacle)
(not (inReceptacle ?o ?re))
)
)
:effect (and
(not (objectAtLocation ?o ?l))
(holds ?a ?o)
(holdsAny ?a)
)
)
(:action PutObjectInReceptacle
:parameters (?a - agent ?l - location ?ot - otype ?o - object ?r - receptacle)
:precondition (and
(atLocation ?a ?l)
(receptacleAtLocation ?r ?l)
(objectType ?o ?ot)
(holds ?a ?o)
(not (holdsAnyReceptacleObject ?a))
)
:effect (and
(inReceptacle ?o ?r)
(not (holds ?a ?o))
(not (holdsAny ?a))
(objectAtLocation ?o ?l)
)
)
(:action PickupObjectInReceptacle
:parameters (?a - agent ?l - location ?o - object ?r - receptacle)
:precondition (and
(atLocation ?a ?l)
(objectAtLocation ?o ?l)
(inReceptacle ?o ?r)
(not (holdsAny ?a))
)
:effect (and
(not (objectAtLocation ?o ?l))
(not (inReceptacle ?o ?r))
(holds ?a ?o)
(holdsAny ?a)
)
)
(:action RinseObject_2
:parameters (?toolreceptacle - receptacle ?a - agent ?l - location ?o - object)
:precondition (and
(receptacleType ?toolreceptacle SinkBasinType)
(atLocation ?a ?l)
(receptacleAtLocation ?toolreceptacle ?l)
(objectAtLocation ?o ?l)
(cleanable ?o)
)
:effect (and
(isClean ?o)
)
)
(:action TurnOnObject_2
:parameters (?a - agent ?l - location ?o - object)
:precondition (and
(atLocation ?a ?l)
(objectAtLocation ?o ?l)
(toggleable ?o)
)
:effect (and
(isToggled ?o)
)
)
(:action CoolObject_0
:parameters (?toolreceptacle - receptacle ?a - agent ?l - location ?o - object)
:precondition (and
(receptacleType ?toolreceptacle FridgeType)
(atLocation ?a ?l)
(receptacleAtLocation ?toolreceptacle ?l)
(holds ?a ?o)
)
:effect (and
(isCool ?o)
)
)
(:action SliceObject_1
:parameters (?toolobject - object ?a - agent ?l - location ?o - object)
:precondition (and
(objectType ?toolobject ButterKnifeType)
(atLocation ?a ?l)
(objectAtLocation ?o ?l)
(sliceable ?o)
(holds ?a ?toolobject)
)
:effect (and
(isSliced ?o)
)
)
(:action SliceObject_0
:parameters (?toolobject - object ?a - agent ?l - location ?o - object)
:precondition (and
(objectType ?toolobject KnifeType)
(atLocation ?a ?l)
(objectAtLocation ?o ?l)
(sliceable ?o)
(holds ?a ?toolobject)
)
:effect (and
(isSliced ?o)
)
)
(:action MicrowaveObject_0
:parameters (?toolreceptacle - receptacle ?a - agent ?l - location ?o - object)
:precondition (and
(receptacleType ?toolreceptacle MicrowaveType)
(atLocation ?a ?l)
(receptacleAtLocation ?toolreceptacle ?l)
(holds ?a ?o)
)
:effect (and
(isHot ?o)
)
)
)