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

moin code generated by txt2tags 2.6b (http://txt2tags.sf.net) cmdline: txt2tags