2011-08-09
Help: Experimental automatically generated documentation.
heuristics
Additive heuristic
add(cost_type = NORMAL)
cost_type ({NORMAL, ONE, PLUSONE}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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 for non-goal states, 0 for goal states
blind(cost_type = NORMAL)
cost_type ({NORMAL, ONE, PLUSONE}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
Language features supported:
action costs: supported
conditional_effects: ignored
axioms: ignored
Properties:
admissible: yes for tasks without conditional effects or axioms
consistent: yes for tasks without conditional effects or axioms
safe: yes for tasks without conditional effects or axioms
preferred operators: no
Max heuristic
hmax(cost_type = NORMAL)
cost_type ({NORMAL, ONE, PLUSONE}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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 (see LandmarksDefinition).
admissible (bool): get admissible estimate
optimal (bool): use optimal (LP-based) cost sharing (only makes sense with admissible=true)
pref (bool): identify preferred operators
alm (bool): use action landmarks
cost_type ({NORMAL, ONE, PLUSONE}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
Note: to use optimal=true, you must build the planner with USE_LP=1. See LPBuildInstructions. Optimal search: when using landmarks for optimal search (admissible=true), you probably also want to enable the mpd option of the A* algorithm to improve heuristic estimates cost_type parameter: only used when admissible=true (see LandmarksDefinition) Language features supported:
action costs: supported
conditional_effects: supported if admissible=false
axioms: supported if admissible=false (but may behave stupidly and unsave
Properties:
admissible: yes if admissible=true and there are neither conditional 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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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, max_states_before_merge, 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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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
IPC-Max Heuristic
max(heuristics, cost_type = NORMAL)
heuristics (list of heuristic):
cost_type ({NORMAL, ONE, PLUSONE}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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
Alternation open list
alternates between several open lists.
alt(openlists, boost = 0)
openlists (list of openlist): sub open lists
boost (int): boost value for sub-open-lists that are restricted to preferred operator nodes
Preferred operators: Preferred operators are only taken from sub-open-lists that do not consider the evaluated state a dead end. Dead ends: A state is considered a dead end if either all alternated open lists agree that it is a dead end or at least one reliable open list considers is a dead end. A state is never inserted into a sub-open-list that considers it a dead end. Note: The treatment of dead ends is different from the one described in the [http://tr.informatik.uni-freiburg.de/reports/report258/report00258.ps.gz technical report] "The More, the Merrier: Combining Heuristic Estimators for Satisficing Planning (Extended Version)" (Department of Computer Science at Freiburg University, No. 258, 2010)
Pareto open list
Selects one of the Pareto-optimal (regarding the sub-evaluators) entries for removal.
pareto(evals, pref_only = false, state_uniform_selection = false)
evals (list of scalar evaluator): scalar evaluators
pref_only (bool): insert only nodes generated by preferred operators
state_uniform_selection (bool): When removing an entry, we select a non-dominated bucket and return its oldest entry. If this option is false, we select uniformly from the non-dominated buckets; if the option is true, we weight the buckets with the number of entries.
Standard open list
Standard open list that uses a single evaluator
single(eval, pref_only = false)
eval (scalar evaluator): scalar evaluator
pref_only (bool): insert only nodes generated by preferred operators
Bucket-based open list
Bucket-based open list implementation that uses a single evaluator
single_buckets(eval, pref_only = false)
eval (scalar evaluator): scalar evaluator
pref_only (bool): insert only nodes generated by preferred operators
Tie-breaking open list
tiebreaking(evals, pref_only = false, unsafe_pruning = true)
evals (list of scalar evaluator): scalar evaluators
pref_only (bool): insert only nodes generated by preferred operators
unsafe_pruning (bool): allow unsafe pruning when the main evaluator regards a state a dead end
search engines
A* search (eager)
A* is a special case of eager best first search that uses g+h as f-function. We break ties using the evaluator. Closed nodes are re-opened.
astar(eval, pathmax = false, mpd = false, cost_type = NORMAL, bound = 2147483647)
eval (scalar evaluator): evaluator for h-value
pathmax (bool): use pathmax correction
mpd (bool): use multi-path dependence (LM-A*)
cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type
bound (int): depth bound on g-values. Cutoffs are always performed according to the real cost, regardless of the cost_type parameter
mpd option: This option is currently only present for the A* algorithm and not for the more general eager search, because the current implementation of multi-path depedence does not support general open lists.
Eager best first search
eager(open, reopen_closed = false, pathmax = false, f_eval = 0, preferred = [], cost_type = NORMAL, bound = 2147483647)
open (openlist): open list
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): depth bound on g-values. Cutoffs are always performed according to the real cost, regardless of the cost_type parameter
Greedy search (eager)
eager_greedy(evals, preferred = [], boost = 0, cost_type = NORMAL, bound = 2147483647)
evals (list of scalar evaluator): scalar evaluators
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): depth bound on g-values. Cutoffs are always performed according to the real cost, regardless of the cost_type parameter
Open list: In most cases, eager greedy best first search uses an alternation open list with one queue for each evaluator. If preferred operator heuristics are used, it adds an extra queue for each of these evaluators that includes only the nodes that are generated with a preferred operator. If only one evaluator and no preferred operator heuristic is used, the search does not use an alternation open list but a standard open list with only one queue. Closed nodes: Closed node are not re-opened
Enforced hill-climbing
ehc(h, bfs_use_cost = false, preferred_usage = PRUNE_BY_PREFERRED, preferred = [], cost_type = NORMAL, bound = 2147483647)
h (heuristic): 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): depth bound on g-values. Cutoffs are always performed according to the real cost, regardless of the cost_type parameter
Iterated search
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.)): list of search engines for each phase
pass_bound (bool): use bound from previous search. The bound is the real cost of the plan found before, regardless of the cost_type parameter.
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 plan_counter + 1
cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type
bound (int): depth bound on g-values. Cutoffs are always performed according to the real cost, regardless of the cost_type parameter
Note 1: We do no cache values between search iterations at the moment. If you perform a LAMA-style iterative search, heuristic values will be computed multiple times. Adding heuristic caching is [http://issues.fast-downward.org/issue108 issue108]. Note 2: Use heuristic predefinition to avoid duplicate preprocessing (e.g. in the merge-and-shrink heuristic) when using the same heuristic multiple times. Note 3: If you reuse the same landmark count heuristic (using heuristic predefinition) between iterations, the path data (that is, landmark status for each visited state) will be saved between iterations.
Lazy best first search
lazy(open, reopen_closed = false, preferred = [], cost_type = NORMAL, bound = 2147483647)
open (openlist): open list
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): depth bound on g-values. Cutoffs are always performed according to the real cost, regardless of the cost_type parameter
Greedy search (lazy)
lazy_greedy(evals, preferred = [], reopen_closed = false, boost = 1000, cost_type = NORMAL, bound = 2147483647)
evals (list of scalar evaluator): scalar evaluators
preferred (list of heuristic): use preferred operators of these heuristics
reopen_closed (bool): reopen closed nodes
boost (int): boost value for alternation queues that are restricted to preferred operator nodes
cost_type ({NORMAL, ONE, PLUSONE}): operator cost adjustment type
bound (int): depth bound on g-values. Cutoffs are always performed according to the real cost, regardless of the cost_type parameter
Open lists: In most cases, lazy greedy best first search uses an alternation open list with one queue for each evaluator. If preferred operator heuristics are used, it adds an extra queue for each of these evaluators that includes only the nodes that are generated with a preferred operator. If only one evaluator and no preferred operator heuristic is used, the search does not use an alternation open list but a standard open list with only one queue.
(Weighted) A* search (lazy)
Weighted A* is a special case of lazy best first search.
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): depth bound on g-values. Cutoffs are always performed according to the real cost, regardless of the cost_type parameter
Open lists: In the general case, it uses an alternation open list with one queue for each evaluator h that ranks the nodes by g + w * h. If preferred operator heuristics are used, it adds for each of the evaluators another such queue that only inserts nodes that are generated by preferred operators. In the special case with only one evaluator and no preferred operator heuristics, it uses a single queue that is ranked by g + w * h.
scalar evaluators
g-value evaluator
Returns the current g-value of the search.
g()
Preference evaluator
Returns 0 if preferred is true and 1 otherwise.
pref()
Sum evaluator
Calculates the sum of the sub-evaluators.
sum(evalsat least one scalar evaluator)
evalsat least one scalar evaluator (list of scalar evaluator):
Weighted evaluator
Multiplies the value of the scalar evaluator with the given weight.
weight(eval, weight)
eval (scalar evaluator): scalar evaluator
weight (int): weight
landmarks graphs
Exhaustive Landmarks
Exhaustively checks for each fact if it is a landmark.This check is done using relaxed planning.
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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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
Relevant options: reasonable_orders, only_causal_landmarks
h^m Landmarks
The landmark generation method introduced by Keyder, Richter & Helmert (ECAI 2010).
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): subset size (if unsure, use the default of 2)
cost_type ({NORMAL, ONE, PLUSONE}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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
Relevant options: m, reasonable_orders, conjunctive_landmarks, no_orders
Merged Landmarks
Merges the landmarks and orderings from the parameter landmarks
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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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
Precedence: Fact landmarks take precedence over disjunctive landmarks, orderings take precedence in the usual manner (gn > nat > reas > o_reas). Relevant options: Depends on landmarks Note: Does not currently support conjunctive landmarks
RHW Landmarks
The landmark generation method introduced by Richter, Helmert and Westphal (AAAI 2008).
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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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
relevant_options: reasonable_orders, only_causal_landmarks, disjunctive_landmarks, no_orders
Zhu/Givan Landmarks
The landmark generation method introduced by Zhu & Givan (ICAPS 2003 Doctoral Consortium).
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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
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
Relevant options: reasonable_orders, no_orders
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}): Action cost adjustment type. No matter what this setting is, axioms will always be considered as actions of cost 0 by the heuristics that treat axioms as actions.
NORMAL: all actions are accounted for with their real cost
ONE: all actions are accounted for as unit cost
PLUSONE: all actions are accounted for as their real cost +1 (except if all actions have original cost 1, in which case cost 1 is used). This is the behaviour known from the LAMA planner.
Help output finished. Peak memory: 2500 KB