Help: Experimental automatically generated documentation.

heuristics

Additive heuristic

add(cost_type = NORMAL)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: supported

• conditional_effects: supported

• axioms: supported (in the sense that the planner won't complain -- handling of axioms might be very stupid and even render the heuristic unsafe)

Properties:

• admissible: no

• consistent: no

• safe: yes for tasks without axioms

• preferred operators: yes

Blind heuristic

Returns cost of cheapest action fornon-goal states, 0 for goal states

blind(cost_type = NORMAL)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: supported

• conditional_effects: supported

• axioms: supported

Properties:

• admissible: yes

• consistent: yes

• safe: yes

• preferred operators: no

Context-enhanced additive heuristic

cea(cost_type = NORMAL)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: supported

• conditional_effects: supported

• axioms: supported (in the sense that the planner won't complain -- handling of axioms might be very stupid and even render the heuristic unsafe)

Properties:

• admissible: no

• consistent: no

• safe: no

• preferred operators: yes

Causal graph heuristic

cg(cost_type = NORMAL)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: supported

• conditional_effects: supported

• axioms: supported (in the sense that the planner won't complain -- handling of axioms might be very stupid and even render the heuristic unsafe)

Properties:

• admissible: no

• consistent: no

• safe: no

• preferred operators: yes

FF heuristic

See also LAMA-FF synergy.

ff(cost_type = NORMAL)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: supported

• conditional_effects: supported

• axioms: supported (in the sense that the planner won't complain -- handling of axioms might be very stupid and even render the heuristic unsafe)

Properties:

• admissible: no

• consistent: no

• safe: yes for tasks without axioms

• preferred operators: yes

Goal count heuristic

goalcount(cost_type = NORMAL)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: ignored by design

• conditional_effects: supported

• axioms: supported

Properties:

• admissible: no

• consistent: no

• safe: yes

• preferred operators: no

h^m heuristic

hm(m = 2, cost_type = NORMAL)

• m (int): subset size

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: supported

• conditional_effects: ignored

• axioms: ignored

Properties:

• admissible: yes for tasks without conditionaleffects or axioms

• consistent: yes for tasks without conditionaleffects or axioms

• safe: yes for tasks without conditionaleffects or axioms

• preferred operators: no

Max heuristic

hmax(cost_type = NORMAL)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: supported

• conditional_effects: supported

• axioms: supported (in the sense that the planner won't complain -- handling of axioms might be very stupid and even render the heuristic unsafe)

Properties:

• admissible: yes for tasks without axioms

• consistent: yes for tasks without axioms

• safe: yes for tasks without axioms

• preferred operators: no

Landmark count heuristic

See also Lama-FF synergy

lmcount(lm_graph, admissible = false, optimal = false, pref = false, alm = true, cost_type = NORMAL)

• lm_graph (landmarks graph): the set of landmarks to use for this heuristic.The set of landmarks can be specified here, or predefined.

• admissible (bool): get admissible estimate

• optimal (bool): use optimal cost sharing(only makes sense with admissible=true).You need to build the planner with USE_LP=1to use this.

• pref (bool): identify preferred operators

• alm (bool): use action landmarks

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: supported

• conditional_effects: supported if admissible=false

• axioms: supported if admissible=false (but may behave stupidly and be unsafe

Properties:

• admissible: yes if admissible=true and there are neitherconditional effects nor axioms

• consistent: no

• safe: yes (except maybe on tasks with axioms or when using admissible=true on tasks with conditional effects)

• preferred operators: yes (if enabled; see pref_ops option)

Landmark-cut heuristic

lmcut(cost_type = NORMAL)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: supported

• conditional_effects: not supported

• axioms: not supported

Properties:

• admissible: yes

• consistent: no

• safe: yes

• preferred operators: no

Merge-and-shrink heuristic

Note: The numbering of the composition and collapsing options has changed in July 2010. Please adapt them when using old experiment scripts (reduce old value by 1).

mas(max_states = -1, max_states_before_merge = -1, count = 1, merge_strategy = MERGE_LINEAR_CG_GOAL_LEVEL, shrink_strategy = SHRINK_HIGH_F_LOW_H, simplify_labels = true, expensive_statistics = false, merge_mixing_parameter = -1, cost_type = NORMAL)

• max_states (int): maximum abstraction size

• max_states_before_merge (int): maximum abstraction size for factors of synchronized product

• count (int): nr of abstractions to build

• merge_strategy ({MERGE_LINEAR_CG_GOAL_LEVEL, MERGE_LINEAR_CG_GOAL_RANDOM, MERGE_LINEAR_GOAL_CG_LEVEL, MERGE_LINEAR_RANDOM, MERGE_DFP, MERGE_LINEAR_LEVEL, MERGE_LINEAR_REVERSE_LEVEL, MERGE_LEVEL_THEN_INVERSE, MERGE_INVERSE_THEN_LEVEL}): merge strategy

• shrink_strategy ({SHRINK_HIGH_F_LOW_H, SHRINK_LOW_F_LOW_H, SHRINK_HIGH_F_HIGH_H, SHRINK_RANDOM, SHRINK_DFP, SHRINK_BISIMULATION, SHRINK_BISIMULATION_NO_MEMORY_LIMIT, SHRINK_DFP_ENABLE_GREEDY_BISIMULATION, SHRINK_DFP_ENABLE_FURTHER_LABEL_REDUCTION, SHRINK_DFP_ENABLE_GREEDY_THEN_LABEL_REDUCTION, SHRINK_DFP_ENABLE_LABEL_REDUCTION_THEN_GREEDY, SHRINK_DFP_ENABLE_LABEL_REDUCTION_AND_GREEDY_CHOOSE_MAX, SHRINK_GREEDY_BISIMULATION_NO_MEMORY_LIMIT, SHRINK_BISIMULATION_REDUCING_ALL_LABELS_NO_MEMORY_LIMIT, SHRINK_GREEDY_BISIMULATION_REDUCING_ALL_LABELS_NO_MEMORY_LIMIT}): shrink strategy

• simplify_labels (bool): enable label simplification

• expensive_statistics (bool): show statistics on "unique unlabeled edges" (WARNING: these are *very* slow -- check the warning in the output)

• merge_mixing_parameter (double): merge mixing parameter

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: supported for SHRINK_DFP, SHRINK_BISIMULATION_NO_MEMORY_LIMIT, SHRINK_DFP_ENABLE_GREEDY_BISIMULATION_NO_MEMORY_LIMIT

• conditional_effects: not supported

• axioms: not supported

Properties:

• admissible: yes

• consistent: yes

• safe: yes

• preferred operators: no

Selective-max heuristic

selmax(heuristics, alpha = 1, classifier = NB, conf_threshold = 0.6, training_set = 100, eval_always = 0, random_sel = false, retime = false, sample = Probe, uniform = false, zero_threshold = false, cost_type = NORMAL)

• heuristics (list of heuristic): heuristics

• alpha (double): alpha

• classifier ({NB, AODE}): classifier type

• conf_threshold (double): confidence threshold

• training_set (int): minimum size of training set

• eval_always (int): number of heuristics that should always be evaluated

• random_sel (bool): random selection

• retime (bool): retime heuristics

• sample ({Probe, ProbAStar, PDB}): state space sample type

• uniform (bool): uniform sampling

• zero_threshold (bool): set threshold constant 0

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

Language features supported:

• action costs: if supported by all component heuristics

• conditional_effects: if supported by all component heuristics

• axioms: if supported by all component heuristics

Properties:

• admissible: if all component heuristics are admissible

• consistent: no

• safe: if all component heuristics are safe

• preferred operators: no (not yet)

openlists

alt

alt(sublists, boost = 0)

• sublists (list of openlist):

• boost (int): boost value for preferred operator open lists

pareto

pareto(evals, pref_only = false, state_uniform_selection = false)

• evals (list of scalar evaluator):

• pref_only (bool): insert only preferred operators

• state_uniform_selection (bool): select uniformly from the candidate *states*

single

single(evaluators, pref_only = false)

• evaluators (list of scalar evaluator):

• pref_only (bool): insert only preferred operators

single_buckets

single_buckets(evals, pref_only = false)

• evals (list of scalar evaluator):

• pref_only (bool): insert only preferred operators

tiebreaking

tiebreaking(evals, pref_only = false, unsafe_pruning = true)

• evals (list of scalar evaluator):

• pref_only (bool): insert only preferred operators

• unsafe_pruning (bool): allow unsafe pruning when the main evaluator regards a state a dead end

search engines

astar

astar(eval, pathmax = false, mpd = false, cost_type = NORMAL, bound = 2147483647)

• eval (scalar evaluator):

• pathmax (bool): use pathmax correction

• mpd (bool): use multi-path dependence (LM-A*)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• bound (int): bound on plan cost

eager

eager(open, reopen_closed = false, pathmax = false, f_eval = 0, preferred = [], cost_type = NORMAL, bound = 2147483647)

• open (openlist):

• reopen_closed (bool): reopen closed nodes

• pathmax (bool): use pathmax correction

• f_eval (scalar evaluator): set evaluator for jump statistics

• preferred (list of heuristic): use preferred operators of these heuristics

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• bound (int): bound on plan cost

eager_greedy

eager_greedy(evals, preferred = [], boost = 0, cost_type = NORMAL, bound = 2147483647)

• evals (list of scalar evaluator):

• preferred (list of heuristic): use preferred operators of these heuristics

• boost (int): boost value for preferred operator open lists

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• bound (int): bound on plan cost

ehc

ehc(h, bfs_use_cost = false, preferred_usage = PRUNE_BY_PREFERRED, preferred = [], cost_type = NORMAL, bound = 2147483647)

• h (heuristic):

• bfs_use_cost (bool): use cost for bfs

• preferred_usage ({PRUNE_BY_PREFERRED, RANK_PREFERRED_FIRST}): preferred operator usage

• preferred (list of heuristic): use preferred operators of these heuristics

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• bound (int): bound on plan cost

iterated

iterated(engine_configs, pass_bound = true, repeat_last = false, continue_on_fail = false, continue_on_solve = true, plan_counter = 0, cost_type = NORMAL, bound = 2147483647)

• engine_configs (list of parse tree (this just means the input is parsed at a later point. The real type is probably a search engine.)):

• pass_bound (bool): use bound from previous search

• repeat_last (bool): repeat last phase of search

• continue_on_fail (bool): continue search after no solution found

• continue_on_solve (bool): continue search after solution found

• plan_counter (int): start enumerating plans with this number

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• bound (int): bound on plan cost

lazy

lazy(open, reopen_closed = false, preferred = [], cost_type = NORMAL, bound = 2147483647)

• open (openlist):

• reopen_closed (bool): reopen closed nodes

• preferred (list of heuristic): use preferred operators of these heuristics

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• bound (int): bound on plan cost

lazy_greedy

lazy_greedy(evals, preferred = [], reopen_closed = false, boost = 1000, cost_type = NORMAL, bound = 2147483647)

• evals (list of scalar evaluator):

• preferred (list of heuristic): use preferred operators of these heuristics

• reopen_closed (bool): reopen closed nodes

• boost (int): boost value for preferred operator open lists

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• bound (int): bound on plan cost

lazy_wastar

lazy_wastar(evals, preferred = [], reopen_closed = true, boost = 1000, w = 1, cost_type = NORMAL, bound = 2147483647)

• evals (list of scalar evaluator):

• preferred (list of heuristic): use preferred operators of these heuristics

• reopen_closed (bool): reopen closed nodes

• boost (int): boost value for preferred operator open lists

• w (int): heuristic weight

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• bound (int): bound on plan cost

scalar evaluators

g

g()

max

max(heuristics, cost_type = NORMAL)

• heuristics (list of heuristic):

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

pref

pref()

sum

sum(evals)

• evals (list of scalar evaluator):

weight

weight(evals, weight)

• evals (list of scalar evaluator):

• weight (int):

landmarks graphs

lm_exhaust

lm_exhaust(cost_type = NORMAL, reasonable_orders = false, only_causal_landmarks = false, disjunctive_landmarks = true, conjunctive_landmarks = true, no_orders = false, lm_cost_type = NORMAL)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• reasonable_orders (bool): generate reasonable orders

• only_causal_landmarks (bool): keep only causal landmarks

• disjunctive_landmarks (bool): keep disjunctive landmarks

• conjunctive_landmarks (bool): keep conjunctive landmarks

• no_orders (bool): discard all orderings

• lm_cost_type ({NORMAL, ONE, PLUSONE}): landmark action cost adjustment

lm_hm

lm_hm(m = 2, cost_type = NORMAL, reasonable_orders = false, only_causal_landmarks = false, disjunctive_landmarks = true, conjunctive_landmarks = true, no_orders = false, lm_cost_type = NORMAL)

• m (int): m (as in h^m)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• reasonable_orders (bool): generate reasonable orders

• only_causal_landmarks (bool): keep only causal landmarks

• disjunctive_landmarks (bool): keep disjunctive landmarks

• conjunctive_landmarks (bool): keep conjunctive landmarks

• no_orders (bool): discard all orderings

• lm_cost_type ({NORMAL, ONE, PLUSONE}): landmark action cost adjustment

lm_merged

lm_merged(lm_graphs, cost_type = NORMAL, reasonable_orders = false, only_causal_landmarks = false, disjunctive_landmarks = true, conjunctive_landmarks = true, no_orders = false, lm_cost_type = NORMAL)

• lm_graphs (list of landmarks graph):

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• reasonable_orders (bool): generate reasonable orders

• only_causal_landmarks (bool): keep only causal landmarks

• disjunctive_landmarks (bool): keep disjunctive landmarks

• conjunctive_landmarks (bool): keep conjunctive landmarks

• no_orders (bool): discard all orderings

• lm_cost_type ({NORMAL, ONE, PLUSONE}): landmark action cost adjustment

lm_rhw

lm_rhw(cost_type = NORMAL, reasonable_orders = false, only_causal_landmarks = false, disjunctive_landmarks = true, conjunctive_landmarks = true, no_orders = false, lm_cost_type = NORMAL)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• reasonable_orders (bool): generate reasonable orders

• only_causal_landmarks (bool): keep only causal landmarks

• disjunctive_landmarks (bool): keep disjunctive landmarks

• conjunctive_landmarks (bool): keep conjunctive landmarks

• no_orders (bool): discard all orderings

• lm_cost_type ({NORMAL, ONE, PLUSONE}): landmark action cost adjustment

lm_search

lm_search(max_depth = 10, num_tries = 10, uniform_sampling = false, cost_type = NORMAL, reasonable_orders = false, only_causal_landmarks = false, disjunctive_landmarks = true, conjunctive_landmarks = true, no_orders = false, lm_cost_type = NORMAL)

• max_depth (int): max depth

• num_tries (int): max number of tries

• uniform_sampling (bool): uniform sampling

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• reasonable_orders (bool): generate reasonable orders

• only_causal_landmarks (bool): keep only causal landmarks

• disjunctive_landmarks (bool): keep disjunctive landmarks

• conjunctive_landmarks (bool): keep conjunctive landmarks

• no_orders (bool): discard all orderings

• lm_cost_type ({NORMAL, ONE, PLUSONE}): landmark action cost adjustment

lm_zg

lm_zg(cost_type = NORMAL, reasonable_orders = false, only_causal_landmarks = false, disjunctive_landmarks = true, conjunctive_landmarks = true, no_orders = false, lm_cost_type = NORMAL)

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type

• reasonable_orders (bool): generate reasonable orders

• only_causal_landmarks (bool): keep only causal landmarks

• disjunctive_landmarks (bool): keep disjunctive landmarks

• conjunctive_landmarks (bool): keep conjunctive landmarks

• no_orders (bool): discard all orderings

• lm_cost_type ({NORMAL, ONE, PLUSONE}): landmark action cost adjustment

synergys

lm_ff_syn

lm_ff_syn(lm_graph, admissible = false, optimal = false, alm = true, cost_type = NORMAL)

• lm_graph (landmarks graph):

• admissible (bool): get admissible estimate

• optimal (bool): optimal cost sharing

• alm (bool): use action landmarks

• cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type