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