Utilities

Abstract type for PDDL simulators.

simulate([sim=StateRecorder()], domain::Domain, state::State, actions)

Simulates the evolution of a PDDL domain as a sequence of actions are executed from an initial state. The type of simulator, sim, specifies what information is collected and returned.

By default, sim is a StateRecorder, which records and returns the state trajectory.

StateRecorder(max_steps::Union{Int,Nothing} = nothing)

Simulator that records the state trajectory, including the start state.

EndStateSimulator(max_steps::Union{Int,Nothing} = nothing)

Simulator that returns the end state of simulation.

GroundAction(name, term, preconds, effect)

Ground action definition, represented by the name of its corresponding action schema, a term with grounded arguments, a list of preconds, and an effect, represented as a PDDL.GenericDiff or PDDL.ConditionalDiff.

groundactions(domain::Domain, state::State, action::Action)

Returns ground actions for a lifted action in a domain and initial state.

groundactions(domain::Domain, state::State)

Returns all ground actions for a domain and initial state.

groundaxioms(domain::Domain, state::State, axiom::Clause)

Converts a PDDL axiom to a set of ground actions.

groundaxioms(domain::Domain, state::State)

Convert all axioms into ground actions for a domain and initial state.

ground(domain::Domain, state::State, action::Action, args)

Return ground action given a lifted action and action args. If the action is never satisfiable given the domain and state, return nothing.

ground(domain::Domain, state::State, action::Action)

Grounds a lifted action in a domain and initial state, returning a group of grounded actions.

ground(domain::Domain, state::State)
ground(domain::Domain, problem::Problem)

Grounds a lifted domain with respect to a initial state or problem.

GroundDomain(name, source, actions)

Ground PDDL domain, constructed from a lifted source domain, with a dictionary of ground actions.

CachedDomain{D, Ks, Vs}

Wraps an existing domain of type D, caching the outputs of calls to a subset of interface methods. Ks is a tuple of method identifiers, and Vs is a a tuple of corresponding cache types.

CachedDomain(source::Domain)
CachedDomain(source::Domain, method_keys)

Construct a CachedDomain from a source domain, along with the associated caches for each cached method. A list of method_keys can be provided, where each key is a Symbol specifying the method to be cached.

By default, the following methods are cached: [:available, :relevant, :infer_static_fluents, :infer_affected_fluents, :infer_axiom_hierarchy].

infer_static_fluents(domain)

Infer fluents that are never modified by some action in a domain.

infer_affected_fluents(domain)

Infer fluents that are modified by some action in a domain.

infer_relevant_fluents(domain)

Infer fluents that are relevant to some action precondition.

infer_relevant_fluents(domain, goals)
infer_relevant_fluents(domain, goals, axiom_parents)

Infer fluents that are relevant to achieving a set of goal fluents.

infer_axiom_hierarchy(domain)

Infer dependency structure between axioms.

is_static(term, domain)
is_static(term, domain, statics)

Check if term is static or composed of static subterms.

is_affected(term, domain)
is_affected(term, domain, affected)

Check if term is affected by some action or composed of affected subterms.

Simplify away static fluents within a term.

substitute_axioms(term, domain; ignore)

Substitute derived predicates in a term with their axiom bodies.

is_pred(term, domain)

Check if term is a predicate.

is_derived(term, domain)

Check if term is a derived predicate

is_global_pred(name)

Return whether a symbol refers to global predicate.

is_global_pred(term)

Check if term is a global predicate (comparison, equality, etc.).

is_func(term, domain)

Check if term is a non-Boolean fluent (i.e. function).

is_global_func(name)

Return whether a symbol refers to global function.

is_global_func(term)

Check if term is a global function, including global predicates.

is_attached_func(term, domain)

Check if term is an external function attached to a domain.

is_external_func(term, domain)

Check if term is an external function (attached or global).

is_fluent(term, domain)

Check if term is a (non-external) domain fluent.

is_literal(term)

Check if term is a literal (an atomic formula or its negation.)

is_logical_op(term)

Check if term is a logical operator.

is_negation(term)

Check if term is a negation of another term.

is_quantifier(term)

Check if term is a universal or existential quantifier.

is_type(term, domain)

Check if term is a type predicate.

has_subtypes(term, domain)

Check if term is a type predicate with subtypes.

Check if term has a (sub-term with a) name in names.

has_pred(term, domain)

Check if term contains a predicate.

has_derived(term, domain)

Check if term contains a derived predicate

has_global_pred(term)

Check if term contains a global predicate.

has_func(term, domain)

Check if term contains a non-Boolean fluent (i.e. function).

has_global_func(term)

Check if term contains a global function.

has_attached_func(term, domain)

Check if term contains an external function attached to a domain.

has_fluent(term, domain)

Check if term contains a fluent name.

has_logical_op(term)

Check if term contains a logical operator.

has_negation(term)

Check if term contains a negated literal.

has_quantifier(term)

Check if term contains a universal or existential quantifier.

has_type(term, domain)

Check if term contains a type predicate.

constituents(term, domain)

Returns list of constituent fluents.