FlashPlanner 1.0.19

<p align="center"> <img src="https://github.com/kris701/FlashPlanner/assets/22596587/d3f387a6-e0b5-4118-9801-c125a4e64100" width="200" height="200" /> </p>

Flash Planner

This is a project that contains a simple planner, operating on a grounded representation. You can either use the planner as the C# code or use the CLI interface to get plans. The planner expects a grounded representation of a PDDL domain+problem, that can be obtained from the Translator.

The following is an example of how to use the CLI interface:

dotnet run -- --domain domain.pddl --problem p01.pddl --search "greedy(hGoal())"

The available search engines are:

• greedy: Greedy Search
• greedy_underaprox: Greedy Search with Under-Approximation Refinement (UAR)
• greedy_prefered: Greedy Search with Preferred Operators (PO)
• greedy_defered: Greedy Search with Deferred Heuristic Evaluation (DHE)
• greedy_bb: Black box greedy search
• greedy_bb_focused: Black box Greedy Search with Focused Macros.

Do note that the black box planners only support the hGoal heuristic.

The available heuristics are:

• hConstant(n): Returns a given constant all the time
• hDepth(): Simply returns a cost that is 1 lower than its parent
• hFF(): Returns a cost based on a solution to the relaxed planning graph for the problem
• hAdd(): Retuns the sum of actions needed to achive every goal fact
• hMax(): Returns the highest amount of actions needed to achive a goal fact.
• hGoal(): Returns the amount of goals that are achived in the given state, i.e. h = allGoals - achivedGoals
• hPath(): Returns the cost of the current branch being evaluated
• hWeighted(h,w): Takes one of the previously given heuristics, and weights its result from a constant.

This project is also available as a package on the NuGet Package Manager.

Examples

To find a plan using the Greedy Best First Search engine:

var decl = new PDDLDecl(...);
var translator = new PDDLToSASTranslator(true);
var sas = translator.Translate(decl);
using (var greedyBFS = new GreedyBFS(sas, new hFF(decl)))
{
   var plan = greedyBFS.Solve();
}

Supported PDDL Requirements

Here is the set of requirements that the planner supports.

• STRIPS (:strips)
• Typing (:typing)
• Disjunctive Preconditions (:disjunctive-preconditions)
• Equality (:equality)
• Quantified Preconditions (:quantified-preconditions)
  • Existential Preconditions (:existential-preconditions)
  • Universal Preconditions (:universal-preconditions)
• Conditional Effects (:conditional-effects)
• Domain Axioms (:domain-axioms)
  • Subgoals Through Axioms (:subgoals-through-axioms)
  • Expression Evaluation (:expression-evaluation)
• ADL (:adl)
• Fluents (:fluents)
• Durative Actions (:durative-actions)
  • Durative Inequalities (:durative-inequalities)
  • Continuous Effects (:continuous-effects)
• Negative Preconditions (:negative-preconditions)
• Derived Predicates (:derived-predicates)
• Timed Initial Literals (:timed-initial-literals)
• Action Expansions (:action-expansions)
• Foreach Expansions (:forach-expansions)
• DAG Expansions (:dag-expansions)
• Safety Constraints (:safety-constraints)
• Open World (:open-world)
• True Negation (:true-negation)
• UCPOP (:ucpop)
• Constraints (:constraints)
• Preferences (:preferences)

Performance

Here are some simple benchmarks to get an idea of the performance of this planner. It is compared against Fast Downward. Both are run with greedy best first search with hFF. Benchmarks are only run on the first 20 problems. The planners have a time limit of 60 seconds and a memory limit of 4GB.