Planning with meta-actions

Intelligent Systems for Robotics · Week 7

This week

  • You author a composition of skills in the knowledge graph
  • You derive its preconditions and effects from its steps, rather than declaring them
  • You hand it to the planner as one more action, and measure what changes

Week 6 varied the search with the domain fixed. This week varies the domain with the search fixed.

The six skills the planner sees

SkillPreconditionsAddsDeletes
navigate-to ?from ?to(at ?from) (reachable ?from ?to)(at ?to)(at ?from) (base-placed) (arm-placed)
place-base-for ?obj ?place(at ?place) (object-at ?obj ?place)(base-placed-for ?obj) (base-placed)
reach-to ?obj(base-placed-for ?obj) (base-placed) (gripper-empty)(gripper-at ?obj) (arm-placed)
grasp ?obj ?place(gripper-at ?obj) (arm-placed) (gripper-empty) (at ?place) (object-at ?obj ?place)(holding ?obj)(gripper-empty) (gripper-at ?obj) (base-placed-for ?obj) (object-at ?obj ?place)
release ?obj(holding ?obj)(gripper-empty)(holding ?obj)
hand-over ?obj ?person ?place(holding ?obj) (at ?place) (person-at ?person ?place)(has ?person ?obj) (gripper-empty)(holding ?obj)

From isfr/skills/catalogue.py. Fikes & Nilsson (1971), section 3.2, for the operator. Poole & Mackworth (2023), section 6.1, is where to revise it.

Two new atoms since week 6

(base-placed) and (arm-placed) take no arguments. Four skills use them.

  • place-base-for adds (base-placed), and reach-to needs it
  • reach-to adds (arm-placed), and grasp needs it
  • navigate-to deletes both. A base that drives away is no longer placed, and neither is its arm.
  • Without them, the planner reached for a drink, drove away and back, and grasped it, a plan no robot can carry out
  • Now a plan grasps where it placed the base, except at a place holding two drinks

What the flat domain costs

Task a asks for one drink delivered to one person. Task d asks for two.

TaskEnginePlan lengthExpansions
afast-downward-opt69
afast-downward711
dfast-downward-opt1253
dfast-downward1333

The optimal engine returns six steps and twelve. The satisficing engine returns seven and thirteen, since it guarantees nothing about length.

Both are Fast Downward. pyperplan, three of week 6's four configurations, cannot parse this week's action costs.

Six steps, and none of them a choice


(navigate-to sofa2_place worktop_place)
(place-base-for worktop_place-bottle-1 worktop_place)
(reach-to worktop_place-bottle-1)
(grasp worktop_place-bottle-1 worktop_place)
(navigate-to worktop_place sofa_place)
(hand-over worktop_place-bottle-1 ann sofa_place)
					

Task a's optimal plan. The object names are the local names of the graph's IRIs.

  • Once the planner has committed to one drink for one person, the order of the six is forced by their preconditions
  • The planner rediscovers that order on every task, and task d pays for it twice

One action in place of six

flat domain navigate-to place-base-for reach-to grasp navigate-to hand-over six points in the search, each with every ground action to choose from with fetch fetch ?from ?src ?drink ?dst ?person one point in the search and six skill calls the search never looked at

The meta-action

What it is

A composition of skills, authored in the knowledge graph, fixed in length, whose preconditions and effects are derived from its steps and never declared.

It is one more action in the planning domain.

D3, the knowledge-graph design.

It lives in the graph

In the same Turtle files as the map and the beliefs.

On the nodeWhat it carries
rdfs:labelThe name the domain uses
isfr:parameterIts parameters, each with an isfr:parameterIndex
isfr:stepIts steps, each with an isfr:stepIndex
  • A parameter carries an isfr:variable, the name the steps use, and an isfr:parameterClass, the ontology class its argument must belong to
  • A step carries an isfr:call, one skill name and its arguments in PDDL shape

fetch has five parameters

IndexVariableisfr:parameterClass
0?fromisfr:Place
1?srcisfr:Place
2?drinkisfr:Drink
3?dstisfr:Place
4?personisfr:Person

Where the robot starts, where the drink is, which drink, where the person is, and who.

The parameter types come from the graph

The generator types a skill's parameter by its name. A meta-action's parameters are named by whoever authors it, so isfr:parameterClass gives the PDDL type instead.

isfr:parameterClassPDDL type
isfr:Placeplace
isfr:Drinkdrink
isfr:Containerdrink
isfr:Personperson

A parameter with no class, or with a class outside that table, is an error that names the meta-action and the variable.

And six steps


0  (navigate-to ?from ?src)
1  (place-base-for ?drink ?src)
2  (reach-to ?drink)
3  (grasp ?drink ?src)
4  (navigate-to ?src ?dst)
5  (hand-over ?drink ?person ?dst)
					

Every variable a step uses is one of the five parameters.

The parameters, threaded through

?from ?src ?drink ?dst ?person 0 (navigate-to ?from ?src) 1 (place-base-for ?drink ?src) 2 (reach-to ?drink) 3 (grasp ?drink ?src) 4 (navigate-to ?src ?dst) 5 (hand-over ?drink ?person ?dst)

What the validator checks

  1. Every variable a step uses is a parameter of the meta-action
  2. Every step calls a registered skill, with as many arguments as that skill takes

A step that mentioned ?place would be rejected by the first rule, because nothing in the domain could bind it.

What it is not

A hierarchical task network (HTN) planner is given tasks and methods for decomposing them, and it chooses a decomposition during the search.

  • A meta-action is not a task the planner breaks open during search
  • It is not a task the robot breaks open while it runs
  • Its steps are decided when it is authored, and they never change

Poole & Mackworth (2023), section 6.8, name the approach in one sentence and point at a book for it. The course goes no further.

Why the length is fixed

  • The planner needs a single action with a single annotation
  • A composition that could be any length would need its preconditions worked out during the search, for each length
  • That is a second planner inside the first

With the length fixed, the annotation is computed once, when the graph is loaded. From then on fetch is an action like any other.

The price

fetch fetches one drink for one person and nothing else.

Two deliveries take two fetch steps.

That is what task d shows, and block 7 returns to it.

Deriving the annotations

A meta-action declares nothing

Its preconditions and effects are derived from its steps.

That derivation is the whole of part 1 of this week's micro-project.

The loader enforces it

The third rule of D3 is that a meta-action's preconditions and effects are always derived and never declared.

A meta-action that states a precondition of its own is rejected by the loader, before your derive ever sees it.

Two sources of truth can disagree

  • If an author could declare the annotation and also give the steps, an edit to a step would leave a stale declaration behind
  • The planner would reason about a meta-action that no longer matches what the robot would do
  • Deriving makes the steps the only thing an author can get wrong

The rule is enforced in the loader rather than in your validate, because the type your derive returns has no field for a declaration.

The walk

Walk the steps in index order. Keep two sets, both empty at the start.

Made true

The atoms earlier steps have made true

Made false

The atoms earlier steps have made false

For each precondition of each step, there are three cases.

Three cases

The precondition isWhat it meansWhat you do
In the made-true setAn earlier step established itNothing. It costs the meta-action nothing.
In the made-false setAn earlier step made it false, and nothing since made it true againReject. The composition is inconsistent.
In neitherNothing inside the meta-action supplies itAdd it to the preconditions of the whole

Then the step's own effects

  • An effect that makes an atom true adds it to the made-true set and removes it from the made-false set
  • An effect that makes an atom false does the reverse

Within one step, the deletes apply first:

\[ s' = (s \setminus \mathit{Del}(a)) \cup \mathit{Add}(a) \]

Fox & Long (2003), Definition 13, section 7.1, Journal of Artificial Intelligence Research 20, 61–124. Week 6's slide 22.

The walk over fetch

step supplied inside not supplied inside preconditions of fetch 012 345 navigate-to place-base-for reach-to grasp navigate-to hand-over (at ?src) (base-placed-for ?drink) (base-placed) (gripper-at ?drink) (arm-placed) (at ?src) (at ?src) (holding ?drink) (at ?dst) (at ?from) (reachable ?from ?src) (object-at ?drink ?src) (gripper-empty) (gripper-empty) (object-at ?drink ?src) (reachable ?src ?dst) (person-at ?person ?dst) (at ?from) (reachable ?from ?src) (object-at ?drink ?src) (gripper-empty) (reachable ?src ?dst) (person-at ?person ?dst) An arrow from an earlier step means that step made the atom true. A dashed arrow means the set already holds the atom, so the step adds nothing.

The same walk as a table

StepCallNew precondition of the wholeAlready supplied inside
0(navigate-to ?from ?src)(at ?from), (reachable ?from ?src)nothing yet
1(place-base-for ?drink ?src)(object-at ?drink ?src)(at ?src), from step 0
2(reach-to ?drink)(gripper-empty)(base-placed-for ?drink) and (base-placed), from step 1
3(grasp ?drink ?src)none(gripper-at ?drink) and (arm-placed) from 2, (at ?src) from 0
4(navigate-to ?src ?dst)(reachable ?src ?dst)(at ?src), from step 0
5(hand-over ?drink ?person ?dst)(person-at ?person ?dst)(holding ?drink) from 3, (at ?dst) from 4

The skills' own declarations are in isfr/skills/catalogue.py.

Step 3, read twice

  • grasp has five preconditions and not one of them is new
  • Three were established inside the meta-action, two by step 2 and one by step 0
  • Two were already collected at earlier steps, so asking for them again changes nothing

Preconditions form a set, and a set does not care how often an atom is put into it.

The effect ledger

after step 012 345 (at ?from) (at ?src) (base-placed) (base-placed-for ?drink) (arm-placed) (gripper-at ?drink) (gripper-empty) (object-at ?drink ?src) (holding ?drink) (at ?dst) (has ?person ?drink) Upper level: in the made-true set. Lower level: in the made-false set. Dashed: in neither yet. The shaded column is the effect of fetch.

Two atoms worth watching

  • (gripper-empty) is made false at step 3, because grasp deletes it, and true again at step 5, because hand-over ends by letting go
  • So it is a positive effect of fetch and also one of its preconditions
  • (at ?src) is made true at step 0 and false at step 4, and the final sets hold it only as a negated effect

The ledger holds the last word on each atom rather than its history.

Six and eleven


preconditions
  (at ?from)   (reachable ?from ?src)   (object-at ?drink ?src)
  (gripper-empty)   (reachable ?src ?dst)   (person-at ?person ?dst)

effects
  (at ?dst)   (has ?person ?drink)   (gripper-empty)
  (not (at ?from))   (not (gripper-at ?drink))   (not (base-placed-for ?drink))
  (not (object-at ?drink ?src))   (not (at ?src))   (not (base-placed))
  (not (arm-placed))   (not (holding ?drink))
					

Nothing about those two numbers was chosen. They follow from the six skill declarations and the order of the steps.

When the derivation rejects

grasp-twice

The micro-project ships a second meta-action, with two parameters and two steps that are both (grasp ?obj ?place).

You leave it as it is. A correct derivation rejects it, and that rejection is the first thing your code has to get right.

Step 0

  • None of grasp's five preconditions is supplied by an earlier step, so all five become preconditions of the whole
  • Then step 0's effects run. It makes (holding ?obj) true.
  • And it makes (gripper-empty), (gripper-at ?obj), (base-placed-for ?obj) and (object-at ?obj ?place) false.

Step 1 asks for an atom step 0 destroyed

0 grasp ?obj ?place none is supplied inside, so all five become preconditions of grasp-twice (gripper-at ?obj) (arm-placed) (gripper-empty) (at ?place) (object-at ?obj ?place) made true, after step 0 made false, after step 0 (holding ?obj) (gripper-empty) (gripper-at ?obj) (base-placed-for ?obj) (object-at ?obj ?place) 1 grasp ?obj ?place (gripper-at ?obj) the atom it needs was made false at step 0 Nothing between the two steps puts it back, so the composition is rejected.

The report names the step and the atom


grasp-twice: rejected: grasp-twice: step 1 (grasp ?obj ?place)
needs (gripper-at ?obj), which an earlier step made false
					
  • (gripper-empty) is false at that point too, and so is (object-at ?obj ?place)
  • One failed precondition is enough to reject, so which one your walk reports depends on the order you check them in

What matters is that the rejection happens at all.

Caught when the graph loads

Before any planning, and long before any driving.

  • An author who had written the preconditions of grasp-twice by hand would have written something plausible
  • The planner would have used it
  • The robot would have discovered the problem by trying to grasp an object it was already holding

The derivation caught a real mistake

  • While this course's fetch was first derived, the catalogue's grasp took one parameter and deleted one atom
  • The derivation left (gripper-at ?drink) and (base-placed-for ?drink) among fetch's positive effects, and never touched (object-at ?drink ?src)
  • So after a fetch, the planner believed the drink was still on the worktop, with the gripper at it and the base parked for it

One delete where four were needed

grasp, as it was grasp, now grasp ?obj adds (holding ?obj) deletes (gripper-empty) grasp ?obj ?place adds (holding ?obj) deletes (gripper-empty) (gripper-at ?obj) (base-placed-for ?obj) (object-at ?obj ?place) what fetch then derived what fetch derives now (gripper-at ?drink) (base-placed-for ?drink) (object-at ?drink ?src) (not (gripper-at ?drink)) (not (base-placed-for ?drink)) (not (object-at ?drink ?src)) still true still true never touched Only the object-at delete needed the new parameter. The other two were left out.

What that makes the derivation

  • It saves you from writing an annotation for every composition
  • It also checks the annotations you already wrote by hand, on the skills

A skill's declaration is only ever read one skill at a time. A derivation reads six of them in order and shows what the sequence leaves behind.

Binding and nesting

Distinct parameters may bind to one object

  • The derivation treats ?from, ?src and ?dst as three different things
  • A planner is under no such obligation. It binds each parameter to an object, and nothing stops it binding two of them to the same object.

The robot already stands where the drink is

Bind ?from and ?src to one place. Derive fetch again with both replaced by ?p.

  • The composition stays consistent
  • There are still six preconditions, and one of them is now (reachable ?p ?p)
  • That holds, because week 6 made reachability reflexive

Week 6's lecture notes said this week was the reason.

Eleven effects become ten

three distinct places ?from and ?src both bound to ?p (at ?dst) (has ?person ?drink) (gripper-empty) (not (at ?from)) (not (gripper-at ?drink)) (not (base-placed-for ?drink)) (not (object-at ?drink ?src)) (not (at ?src)) (not (base-placed)) (not (arm-placed)) (not (holding ?drink)) (at ?dst) (has ?person ?drink) (gripper-empty) (not (at ?p)) (not (gripper-at ?drink)) (not (base-placed-for ?drink)) (not (object-at ?drink ?p)) (not (base-placed)) (not (arm-placed)) (not (holding ?drink)) Eleven effects, three positive and eight negated. Ten. The two drives share one atom.

And step 0 drives nowhere

A reflexive navigate-to is harmless, for the reason week 6 gave.

Its add list is \( \{(\mathit{at}\ p)\} \). Its delete list \( \mathit{Del} \) holds \( (\mathit{at}\ p) \), (base-placed) and (arm-placed). The deletes apply first.

\[ (s \setminus \mathit{Del}) \cup \{(\mathit{at}\ p)\} \ni (\mathit{at}\ p) \]

The robot stays where it was. The two placement atoms become false, and steps 1 and 2 make them true again.

Nesting, and the validator's third rule

  • A step may call another meta-action instead of a skill. It expands to the inner one's steps, recursively, until only registered skills are left
  • To walk such a step, the derivation needs the inner meta-action's annotation, so it derives the inner one first
  • If a calls b and b calls a, neither can be derived first, and the recursion runs until the interpreter stops it

So the validator has a third rule: the calls between meta-actions form no cycle. A meta-action that calls itself is the shortest cycle.

Meta-actions in the domain

fetch, as the generator writes it


(:action fetch
  :parameters (?from - place ?src - place ?drink - drink ?dst - place ?person - person)
  :precondition (and (at ?from) (reachable ?from ?src) (object-at ?drink ?src)
                     (gripper-empty) (reachable ?src ?dst) (person-at ?person ?dst))
  :effect (and (at ?dst) (has ?person ?drink) (gripper-empty)
               (not (at ?from)) (not (gripper-at ?drink))
               (not (base-placed-for ?drink)) (not (object-at ?drink ?src))
               (not (at ?src)) (not (base-placed)) (not (arm-placed))
               (not (holding ?drink))))
					

No difference in kind

Read it beside the release action of week 6.


(:action release
  :parameters (?obj - drink)
  :precondition (holding ?obj)
  :effect (and (gripper-empty) (not (holding ?obj))))
					

Same syntax, same predicates, same grounding. The planner has no way of telling that one of them is six skills.

What an action costs

  • Every action in week 6's domain cost 1, because the generator set no metric
  • Leave it that way and fetch costs 1 against the six skills it replaces
  • The macro domain then wins on plan cost for a reason that has nothing to do with planning

So a meta-action costs the number of primitive steps in its full expansion, and a skill costs 1. fetch costs 6.

fast-downward-opt honours that price. fast-downward reads it and then searches as if every action cost 1, so to it fetch is one cheap step whatever it is priced at.

Break the rule and you change the problem

This week's example prices its macro below the cost of its steps and plans again.

The optimal engine returns a plan that costs less than any flat plan, because you have changed the problem rather than the search.

Expansion, before anything runs

  • A plan that holds fetch is not a plan the robot can run. The executive knows skills, and fetch is not one.
  • So a plan is expanded before it is executed, and before it is replayed. One fetch becomes six skill calls with their arguments bound.

Expansion is also what makes the comparison honest. A one-step plan holding fetch is not less work than a six-step plan of skills.

Every row of this week's table carries both the length as returned and the length after expansion.

Then the plan is replayed

  • Every expanded plan is replayed against the skills' own preconditions and effects, step by step, deletes before adds
  • The replay checks the plan against the catalogue rather than against your derivation
  • A replay against your own annotations would check the plan against the very preconditions that let it through

A wrong derivation shows up in one of three ways. The plan fails the replay, the plan is longer than it should be, or there is no plan at all.

Does it pay

The apartment, measured

TaskEngineDomainLengthExpandedExpansions
afast-downward-optflat669
afast-downward-optmacro163
afast-downwardflat7711
afast-downwardmacro162
dfast-downward-optflat121253
dfast-downward-optmacro21222
dfast-downwardflat131333
dfast-downwardmacro2123

expanded is the plan length after every meta-action is replaced by its steps. expansions is the number of search nodes the engine expanded. They count different things.

Reading it

  • The macro domain expands fewer nodes in all four cells. Nine become three and fifty-three become twenty-two under the optimal engine, eleven become two and thirty-three become three under the satisficing one.
  • The expanded lengths are equal under the optimal engine, 6 against 6 and 12 against 12, which is what the cost metric guarantees
  • Under the satisficing engine the macro plans are shorter once expanded, 6 against 7 and 12 against 13, because that engine's flat plans were not shortest to begin with

What comes back

The returned plan is one fetch on task a and two on task d, one per delivery.

A meta-action of fixed length cannot do anything else.

That is the price of a fixed length, from block 2, in the table.

The same macro, the opposite verdict

  • On the apartment, the macro cuts expansions under both engines
  • How far that result travels is a separate question, and this week's example answers it on a second domain

It runs the Gripper domain of week 6, flat and with carry-two, a macro that picks two balls, moves, and drops them both.

Expansions against the number of balls

1 10 100 1000 10 000 100 000 1 000 000 234 567 8910 1112 balls states expanded, log scale fast-downward-opt fast-downward Thick grey: the flat domain. Thin black: the macro domain.

Eleven balls

EngineDomainLengthExpandedStatesSeconds
fast-downward-optflat33331613551.32
fast-downward-optmacro13331613553.97
fast-downwardflat3333490.09
fast-downwardmacro1333190.12

The macro buys the optimal engine nothing at all, and costs about three times the wall clock for the same search.

From examples/07-planning-with-meta-actions/README.md, whose states column counts what the apartment table calls expansions. State counts are the same on every machine. Seconds vary.

The likely mechanism

  • A macro adds to a node's successor list states that would normally be reached in several steps
  • So it can reduce the maximal depth of a search
  • And it pays for that reduction with a larger branching factor

Botea, Enzenberger, Müller & Schaeffer (2005), section 3.4.1, Journal of Artificial Intelligence Research 24, 581–621.

What the macro adds: estimate first

Adding an action schema adds ground actions, one for each way of substituting objects of the right type for its parameters.

  • How many does fetch add to the apartment problems?
  • Five parameters over the problem's places, drinks and people run to the order of \( 10^{5} \) substitutions. That is the estimate this week started from.

Then measure

TaskFlat domainfetch adds
a519 ground actions154
d526 ground actions308

On the apartment problems, with the reference encoding.

More than two orders of magnitude below the estimate. The planner plainly does not keep every combination, so estimate the grounding of a schema and then measure it.

Why the seconds are not in the table

  • The macro does not save time on the apartment. Every search in its table takes under 5 ms, and the macro domain is slower end to end in all four cells.
  • The likely reason is the grounding just counted. Building those ground actions costs more than the shorter search saves.
  • Expansions come out the same on every machine. Seconds at this size are mostly the cost of translating the problem.

Read your own seconds column for whether the macro row is slower, and not by how much.

Why the two domains differ

The apartment

fetch's six steps are a chain the search walks one step at a time, and fetch grounds narrowly, so the depth it removes is worth more in node expansions than the actions it adds.

Gripper

The optimal engine must prove that no cheaper plan exists, over a state space the macro does not shrink. carry-two adds edges to it and no shortcut through it, since going the long way costs what the macro costs.

That is the likely reason, and not a measured cause.

The utility problem

  • Control knowledge has a hidden cost that can defeat its purpose, the cost of testing whether the knowledge applies as the search is carried out. For it to improve efficiency, its benefits must outweigh its costs.
  • Minton reports that it is harder to improve performance over a population of examples than on isolated examples
  • PRODIGY measured a rule's utility as its average saving times how often it applied, minus its average matching cost, and discarded a rule whose utility was negative

Minton (1988), pages 564 and 567, Proceedings of AAAI-88, 564–569. His subject is search control rules in PRODIGY.

The same problem, for macros

  • The overhead of poor macros can outweigh their benefit. Adding operators to a domain raises both the preprocessing cost and the cost per node in the search.
  • If all instantiations of a macro are considered, the branching factor can increase significantly, and the induced overhead can be larger than the savings achieved by the useful instantiations

So the question a meta-action has to answer is a quantitative one. Is the depth it removes worth the ground actions it adds, for the engine you plan with, on the problems you solve?

Botea et al. (2005), sections 2.2.2 and 3.3, citing Minton for the utility problem.

Learned macros, and week 8

fetch is authored

Someone decided its six steps and wrote them into the graph.

The alternative is to learn macros from plans the planner has already found, and that idea is as old as the triangle table.

Your walk is older than PDDL

  • Fikes, Hart and Nilsson store a plan in a triangle table, a lower triangular array whose rows and columns correspond to the operators of the plan
  • Column i holds the add list of operator i at the top, and below it the part of that add list which survives each later operator
  • So cell (i, j) holds the clauses added by operator j that are still true when operator i applies

Fikes, Hart & Nilsson (1972), section 3, page 258, Artificial Intelligence 3, 251–288.

What the table gives you

  • The conjunction of the formulas in the row to the left of an action is the precondition for executing that action
  • The formulas in the column beneath an action are those on its add list that are also preconditions of later actions or effects in the last row
  • Preconditions not realised by any action in the table must hold before it is executed, and are the initial preconditions of the table
  • Any literal needed by an action and provided by a previous action must survive the intervening actions

Nilsson (1990), Triangle-table trees, section B, page 4. The union of the bottom row is the plan's add list and the left-most column its precondition formula (Fikes, Hart & Nilsson, 1972, pages 258 and 261).

Shakey learned them

  • A plan STRIPS had produced was stored as a triangle table, then generalised by replacing every constant in the left-most column with a new parameter
  • Multiple occurrences of one constant become distinct parameters, which is block 5's binding problem
  • The lifted table is constrained so that each row still supports its operator's preconditions
  • The generalised plan was stored as a macro operator, a MACROP, and was available to later problems

Fikes, Hart & Nilsson (1972), section 4.2, page 262, and section 4.3, page 268. Fikes & Nilsson (1993), pages 227 and 228, is the authors' own account of the period. Botea et al. (2005) is the modern form, with macros learned automatically.

This course does not learn them

  • The thesis stated in week 1 is that only what classical methods do badly is learned
  • The three things on that list are navigation, base placement and collision-free reaching
  • Composing skills is not on it

fetch is authored instead, which also means a person can say why its six steps are those six.

Next week the plan runs

  • A plan is a sequence of skill calls that the planner believed would have their declared effects
  • On the robot, any call can terminate in failure
  • Week 8 compiles a plan into a tree of guarded steps, checks each guard against the graph and the robot before the step runs, and replans when a step fails

That monitor has an ancestor too. PLANEX used triangle tables to monitor the execution of plans, checking what was still true before it carried on.

Fikes, Hart & Nilsson (1972), section 5.1, page 268.

Before week 8

  • Run the example
  • Read Fikes, Hart and Nilsson (1972), section 3
  • Finish part 1 of the micro-project, the derivation

PYTHONPATH=. python3 examples/07-planning-with-meta-actions/main.py
					

In exercises/07-planning-with-meta-actions/. Nothing in it needs Webots, and it runs from the inputs it provides.