Class PostInstantiatedProblem

All Implemented Interfaces:
AtomicFormulaSimplifier<Integer>, Problem, Serializable
Direct Known Subclasses:
FinalizedProblem

public abstract class PostInstantiatedProblem extends InstantiatedProblem
This class contains all the methods needed to the postinstantiation treatment. In particular, all the methods to simplify actions and methods that cannot be triggered. These simplifications are based on the construction of the planning graph of the problem and on the concept of inertia introduced by J. Koehler.
See Also:
Serialized Form
  • Constructor Details

    • PostInstantiatedProblem

      public PostInstantiatedProblem(DefaultParsedProblem problem)
      Creates a new problem from a domain and problem.
      Parameters:
      problem - the problem.
  • Method Details

    • getGroundInertia

      protected Map<Expression<Integer>,​Inertia> getGroundInertia()
      Return the list of ground inertia of the problem.
      Returns:
      the list of ground inertia of the problem.
    • getGroundNumericInertia

      protected Map<Expression<Integer>,​Inertia> getGroundNumericInertia()
      Return the list of numeric ground inertia of the problem.
      Returns:
      the list of numeric ground inertia of the problem.
    • extractGroundInertia

      protected void extractGroundInertia()
      Do a pass over the effects of a specified list of instantiated actions and update the ground inertia table.
    • simplifyGoalWithGroundInertia

      protected void simplifyGoalWithGroundInertia()
      AtomicFormulaSimplifier a specified goal expression based on the ground inertia information.
    • extractGroundNumericInertia

      protected void extractGroundNumericInertia()
      Do a pass over the effects of a specified list of instantiated actions and update the ground inertia table.
    • simplyActionsWithGroundInertia

      protected void simplyActionsWithGroundInertia()
      Do a pass over the preconditions and the effects of all the instantiated actions and update the ground inertia table. Then, simplify the actions according to the extracted ground inertia.*
    • simplifyWithGroundInertia

      protected void simplifyWithGroundInertia(Expression<Integer> exp)
      AtomicFormulaSimplifier a specified expression based on the ground inertia information.

      Definition: A ground fact is a positive ground inertia iff it does not occur positively in an unconditional effect or the consequent of a conditional effect of an action.

      Definition: A ground fact is a negative ground inertia iff it does not occur negatively in an unconditional effect or the consequent of a conditional effect of an action.

      An initial fact, which is a negative ground inertia, is never made FALSE and thus always satisfied in all reachable world states. It can be removed from the state description. All its occurrences in the preconditions of actions and in the antecedents of conditional effects can be simplified to TRUE. A fact, which is a positive ground inertia and not contained in the initial state, is never satisfied in any reachable world state. All its occurrences in the preconditions of actions and in the antecedents of conditional effects can be simplified to FALSE. The remaining facts are fluents that, roughly speaking, can possibly change their truth value during the planning process. They are therefore relevant to the representation of the planning problem.
      Parameters:
      exp - the expression to simply.
    • simplyMethodsWithGroundInertia

      protected void simplyMethodsWithGroundInertia()
      Do a pass over the preconditions of all the instantiated methods and update the ground inertia table. Then, simplify the methods according to the extracted ground inertia.
    • toString

      protected String toString(AbstractProblem.Data data)
      Returns a string representation of the internal data structure used during instantiation process.
      Overrides:
      toString in class PreInstantiatedProblem
      Parameters:
      data - the internal data structure.
      Returns:
      a string representation of the internal data structure used during instantiation process.