PDDL.jl

A Julia parser and interpreter for the Planning Domain Definition Language (PDDL). Planners not included.

Installation

Press ] at the Julia REPL to enter the package manager, then run:

add https://github.com/JuliaPlanners/PDDL.jl.git

Features

• Parsing of PDDL domain and problem files
• Execution of PDDL actions and plans
• Support for the following PDDL requirements:
  • :strips - the most restricted functionality
  • :typing - (hierarchically) typed objects
  • :equality - comparing equality = of objects
  • :quantified-preconditions - forall and exists
  • :disjunctive-preconditions - or predicates
  • :conditional-effects - when and forall effects
  • :adl - shorthand for the above 6 requirements
  • :fluents - numeric fluents
  • :derived-predicates - a.k.a. domain axioms / Horn clauses

PDDL.jl does not include any planning algorithms. Rather, it aims to provide an interface so that planners for PDDL domains can easily be written in Julia, as in SymbolicPlanners.jl.

Example

PDDL.jl can be used to parse domains and planning problems written in PDDL. For example, the following file describes a world of square tiles which are either white or black, arranged in a grid. To change the color of the tiles one can flip either a row of tiles or a column of tiles.

;; Grid flipping domain with conditional effects and universal quantifiers
(define (domain flip)
  (:requirements :adl :typing)
  (:types row column)
  (:predicates (white ?r - row ?c - column))
  (:action flip_row
    :parameters (?r - row)
    :effect (forall (?c - column)
                    (and (when (white ?r ?c) (not (white ?r ?c)))
                         (when (not (white ?r ?c)) (white ?r ?c))))
  )
  (:action flip_column
    :parameters (?c - column)
    :effect (forall (?r - row)
                    (and (when (white ?r ?c) (not (white ?r ?c)))
                         (when (not (white ?r ?c)) (white ?r ?c))))
  )
)

A corresponding problem in this domain might be to make all the tiles white, when the initial state is an alternating pattern of black and white tiles in a 3x3 grid:

;; Grid flipping problem
(define (problem flip-problem)
  (:domain flip)
  (:objects r1 r2 r3 - row c1 c2 c3 - column)
  (:init (white r1 c2)
         (white r2 c1)
         (white r2 c3)
         (white r3 c2))
  (:goal (forall (?r - row ?c - column) (white ?r ?c)))
)

With PDDL.jl, we can parse each of these files into Julia constructs:

domain = load_domain("flip-domain.pddl"))
problem = load_problem("flip-problem.pddl"))

Actions defined by the domain can be executed to solve the problem:

state = initialize(problem)
state = execute(pddl"(flip_column c1)", state, domain)
state = execute(pddl"(flip_column c3)", state, domain)
state = execute(pddl"(flip_row r2)", state, domain)

We can then check that the problem is successfully solved in the final state:

@assert satisfy(problem.goal, state, domain)[1] == true

More examples can be found in the test directory.