AbstractionGenerator

Create abstractions for cost partitioning heuristics.

Cartesian abstraction generator

cartesian(subtasks=[landmarks(order=random), goals(order=random)], max_states=infinity, max_transitions=1M, max_time=infinity, pick_flawed_abstract_state=batch_min_h, pick_split=max_cover, tiebreak_split=max_refined, memory_padding=500, dot_graph_verbosity=silent, random_seed=-1, max_concrete_states_per_abstract_state=infinity, max_state_expansions=1M, verbosity=normal)

• subtasks (list of SubtaskGenerator): subtask generators
• max_states (int [1, infinity]): maximum sum of abstract states over all abstractions
• max_transitions (int [0, infinity]): maximum sum of state-changing transitions (excluding self-loops) over all abstractions
• max_time (double [0.0, infinity]): maximum time in seconds for building abstractions
• pick_flawed_abstract_state ({first, first_on_shortest_path, random, min_h, max_h, batch_min_h}): flaw-selection strategy
  • first: Consider first encountered flawed abstract state and a random concrete state.
  • first_on_shortest_path: Follow the arbitrary solution in the shortest path tree (no flaw search). Consider first encountered flawed abstract state and a random concrete state.
  • random: Collect all flawed abstract states and then consider a random abstract state and a random concrete state.
  • min_h: Collect all flawed abstract states and then consider a random abstract state with minimum h value and a random concrete state.
  • max_h: Collect all flawed abstract states and then consider a random abstract state with maximum h value and a random concrete state.
  • batch_min_h: Collect all flawed abstract states and iteratively refine them (by increasing h value). Only start a new flaw search once all remaining flawed abstract states are refined. For each abstract state consider all concrete states.
• pick_split ({random, min_unwanted, max_unwanted, min_refined, max_refined, min_hadd, max_hadd, min_cg, max_cg, max_cover}): split-selection strategy
  • random: select a random variable (among all eligible variables)
  • min_unwanted: select an eligible variable which has the least unwanted values (number of values of v that land in the abstract state whose h-value will probably be raised) in the flaw state
  • max_unwanted: select an eligible variable which has the most unwanted values (number of values of v that land in the abstract state whose h-value will probably be raised) in the flaw state
  • min_refined: select an eligible variable which is the least refined (-1 * (remaining_values(v) / original_domain_size(v))) in the flaw state
  • max_refined: select an eligible variable which is the most refined (-1 * (remaining_values(v) / original_domain_size(v))) in the flaw state
  • min_hadd: select an eligible variable with minimal h^add(s_0) value over all facts that need to be removed from the flaw state
  • max_hadd: select an eligible variable with maximal h^add(s_0) value over all facts that need to be removed from the flaw state
  • min_cg: order by increasing position in partial ordering of causal graph
  • max_cg: order by decreasing position in partial ordering of causal graph
  • max_cover: compute split that covers the maximum number of flaws for several concrete states.
• tiebreak_split ({random, min_unwanted, max_unwanted, min_refined, max_refined, min_hadd, max_hadd, min_cg, max_cg, max_cover}): split-selection strategy for breaking ties
  • random: select a random variable (among all eligible variables)
  • min_unwanted: select an eligible variable which has the least unwanted values (number of values of v that land in the abstract state whose h-value will probably be raised) in the flaw state
  • max_unwanted: select an eligible variable which has the most unwanted values (number of values of v that land in the abstract state whose h-value will probably be raised) in the flaw state
  • min_refined: select an eligible variable which is the least refined (-1 * (remaining_values(v) / original_domain_size(v))) in the flaw state
  • max_refined: select an eligible variable which is the most refined (-1 * (remaining_values(v) / original_domain_size(v))) in the flaw state
  • min_hadd: select an eligible variable with minimal h^add(s_0) value over all facts that need to be removed from the flaw state
  • max_hadd: select an eligible variable with maximal h^add(s_0) value over all facts that need to be removed from the flaw state
  • min_cg: order by increasing position in partial ordering of causal graph
  • max_cg: order by decreasing position in partial ordering of causal graph
  • max_cover: compute split that covers the maximum number of flaws for several concrete states.
• memory_padding (int [0, infinity]): amount of extra memory in MB to reserve for recovering from out-of-memory situations gracefully. When the memory runs out, we stop refining and start the search. Due to memory fragmentation, the memory used for building the abstraction (states, transitions, etc.) often can't be reused for things that require big continuous blocks of memory. It is for this reason that we require a rather large amount of memory padding by default.
• dot_graph_verbosity ({silent, write_to_console, write_to_file}): verbosity of printing/writing dot graphs
  • silent:
  • write_to_console:
  • write_to_file:
• random_seed (int [-1, infinity]): Set to -1 (default) to use the global random number generator. Set to any other value to use a local random number generator with the given seed.
• max_concrete_states_per_abstract_state (int [1, infinity]): maximum number of flawed concrete states stored per abstract state
• max_state_expansions (int [1, infinity]): maximum number of state expansions per flaw search
• verbosity ({silent, normal, verbose, debug}): Option to specify the verbosity level.
  • silent: only the most basic output
  • normal: relevant information to monitor progress
  • verbose: full output
  • debug: like verbose with additional debug output

projections

Projection generator

projections(patterns=<none>, dominance_pruning=false, combine_labels=true, create_complete_transition_system=false, verbosity=normal)

• patterns (PatternCollectionGenerator): pattern generation method
• dominance_pruning (bool): prune dominated patterns
• combine_labels (bool): group labels that only induce parallel transitions
• create_complete_transition_system (bool): create explicit transition system
• verbosity ({silent, normal, verbose, debug}): Option to specify the verbosity level.
  • silent: only the most basic output
  • normal: relevant information to monitor progress
  • verbose: full output
  • debug: like verbose with additional debug output