The arrival Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The arrival Reference Manual

This is the arrival Reference Manual, version 0.1, generated automatically by Declt version 2.4 patchlevel 1 "Will Decker" on Fri May 24 07:46:49 2019 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction


* ArriVAL - Yet Another Classical planning plan validator written in *modern* Common Lisp

This is a library separated from ALIEN classical planner code base.

ARRIVAL provides a binary =arrival= that takes a PDDL problem file, a domain file and
a plan file, returns 0 when the plan is correct and returns 1 otherwise.

The implementation is intensively focused on clarity: The total LOC is just 941.
This is even shorter compared to [[https://github.com/patrikhaslum/INVAL][INVAL]] validator.

Unlike [[https://github.com/patrikhaslum/INVAL][INVAL]], the repository follows the *modern* Common Lisp repository
structure, is ASDF loadable, and is written in a clean functional style with
pattern matching.

ArriVAL ignores the =:requirement=. The following features are supported:

|                                  | detail                                                          |
|----------------------------------+-----------------------------------------------------------------|
| STRIPS                           | =and=                                                           |
| negative precondition            | =not=                                                           |
| disjunctive precondition         | =or= =imply=                                                    |
| universal precondition           | =forall=                                                        |
| existential preondition          | =exists=                                                        |
| conditional effects              | =when=                                                          |
| The =forall= in effects          | supported                                                       |
| ADL                              | supports =forall= =exists= =when= =or= =imply=                  |
| Axioms                           | supported, fixpoint calculation                                 |
| types                            | supported except =either=                                       |
| equality (===)                   | supported                                                       |
| duplicate args in actions/axioms | supported, imply equality constaints                            |
|----------------------------------+-----------------------------------------------------------------|
| fluents                          | supported (beta) (numeric, objects, action-cost)                |
|                                  | e.g. =assign=, =increase=, =decrease=, =scale-up=, =scale-down= |
|                                  | It accepts both integers and floats.                            |

Arrival currently has no plan to support scheduling problems.


** Installation

Step 1. Install Roswell (https://roswell.github.io/) (modern lisp equivalent of pyenv)

On Mac + homebrew or Linux + [[https://docs.brew.sh/Homebrew-on-Linux][linuxbrew]],

: brew install roswell

On Linux (without linuxbrew),

: sudo apt-get -y install git build-essential automake libcurl4-openssl-dev
: git clone -b release https://github.com/roswell/roswell.git
: cd roswell
: sh bootstrap
: ./configure --prefix=$HOME/.local
: make
: make install
: ~/.local/bin/ros setup   # expect ~5min

Step 2. Install arrival

#+begin_src
$ ~/.local/bin/ros install guicho271828/arrival
$ ~/.roswell/bin/arrival
Usage: [--notype] [-v[v[v]] | --verbose N] [-r|--relaxed] arrival domain problem planfile [trace-output]
     --notype    : The trace output will not contain the type predicates
-v | --verbose N : Specify the verbosity, from 0 to 3                   
-r | --relaxed   : Perform the relaxed planning instead                 
Got ARGV: NIL
            dynamic space size: 8388608000
      lisp implementation type: SBCL
   lisp implementation version: 1.4.12
              machine instance: masataro-ThinkPad-T460
                  machine type: X86-64
               machine version: Intel(R) Core(TM) i5-6300U CPU @ 2.40GHz
                 software type: Linux
              software version: 4.4.0-145-generic
#+end_src

** Usage

: arrival [-v|-vv|-vvv|--verbose N] DOMAINFILE PROBLEMFILE PLANFILE [TRACEFILE]

+ PLANFILE    :: a SEXP file containing plan traces as action signatures.
+ PROBLEMFILE :: a PDDL problem file.
+ DOMAINFILE  :: a PDDL domain file.
+ TRACEFILE   :: An optional output file. Unless specified, the same information
                 is written to the standard output.
+ -v | -vv | -vvv | --verbose N :: verbosity, from level 1 to 3. Default is 0.

** Dependencies
This library is at least tested on implementation listed below:

+ SBCL 1.4.12 on X86-64 Linux 4.4.0-142-generic (author's environment)

Also, it depends on the following libraries:

+ trivia by *Masataro Asai* :
    NON-optimized pattern matcher compatible with OPTIMA, with extensible optimizer interface and clean codebase
+ alexandria by *Nikodemus Siivola , and others.* :
    Alexandria is a collection of portable public domain utilities.
+ iterate by ** :
    Jonathan Amsterdam's iterator/gatherer/accumulator facility

** Author

Masataro Asai (guicho2.71828@gmail.com)

** Copyright

Copyright (c) 2019 Masataro Asai (guicho2.71828@gmail.com)

* License

Licensed under the LLGPL License.

[[arrival.svg]]



Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 arrival

Author

Masataro Asai

Contact

guicho2.71828@gmail.com

License

LLGPL

Description

Classical planning plan validator written in modern Common Lisp

Version

0.1

Dependencies
Source

arrival.asd (file)

Component

src (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 arrival/src

Parent

arrival (system)

Location

src/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 arrival.asd

Location

arrival.asd

Systems

arrival (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 arrival/src/0-package.lisp

Parent

src (module)

Location

src/0-package.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 arrival/src/1-fact-ordering.lisp

Parent

src (module)

Location

src/1-fact-ordering.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 arrival/src/1-flatten-types.lisp

Parent

src (module)

Location

src/1-flatten-types.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 arrival/src/2-simulate.lisp

Parent

src (module)

Location

src/2-simulate.lisp

Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.6 arrival/src/3-main.lisp

Parent

src (module)

Location

src/3-main.lisp

Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 arrival

Source

0-package.lisp (file)

Use List
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

5.2 arrival.pddl

The package for loading the symbols in the input

Source

0-package.lisp (file)

Used By List

arrival


Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Previous: , Up: Definitions   [Contents][Index]

6.1 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *actions*

A list of action definitions whose types are compiled away.

Package

arrival

Source

1-flatten-types.lisp (file)

Special Variable: *axiom-table*
Package

arrival

Source

2-simulate.lisp (file)

Special Variable: *axioms*

A list of axiom definitions whose types are compiled away.

Package

arrival

Source

1-flatten-types.lisp (file)

Special Variable: *exclude-type-predicates-in-trace*
Package

arrival

Source

2-simulate.lisp (file)

Special Variable: *fact-table*
Package

arrival

Source

2-simulate.lisp (file)

Special Variable: *fluents*

A list of fluent type signatures (head arg-types* result-type) , e.g. ((content envelope paper) ...).

Package

arrival

Source

1-flatten-types.lisp (file)

Special Variable: *goal*

Goal condition, whose types are compiled away. (types appears in forall/exists)

Package

arrival

Source

1-flatten-types.lisp (file)

Special Variable: *hold-level*
Package

arrival

Source

2-simulate.lisp (file)

Special Variable: *in-initialization*
Package

arrival

Source

2-simulate.lisp (file)

Special Variable: *init*

Initial state augmented with the type predicates for the objects.

Package

arrival

Source

1-flatten-types.lisp (file)

Special Variable: *new-fact-table*
Package

arrival

Source

2-simulate.lisp (file)

Special Variable: *next-action*
Package

arrival

Source

2-simulate.lisp (file)

Special Variable: *objects*

An alist of (name . type).

Package

arrival

Source

1-flatten-types.lisp (file)

Special Variable: *plan*
Package

arrival

Source

2-simulate.lisp (file)

Special Variable: *predicates*

A list of predicate type signatures (head arg-types*), e.g. ((next location location) ...)

Package

arrival

Source

1-flatten-types.lisp (file)

Special Variable: *previous-action*
Package

arrival

Source

2-simulate.lisp (file)

Special Variable: *proof-stack*

A special variable holding the proof stack as a list of axioms.
Whenever a new axiom is about to be proved/evaluated, it looks up this variable so that it avoids tautology/infinite loop.

Package

arrival

Source

2-simulate.lisp (file)

Special Variable: *relaxed-planning*
Package

arrival

Source

2-simulate.lisp (file)

Special Variable: *types*

An alist of (type . supertype).

Package

arrival

Source

1-flatten-types.lisp (file)

Special Variable: *verbosity*

Value 0 No output
Value >=1 Reports the basic progress / steps that it is checking / action effects Value >=2 Prints the predicates and the axioms being checked
Value 3 Prints the backtracking for proving axioms

Package

arrival

Source

2-simulate.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.1.2 Macros

Macro: in-fresh-binding &body BODY
Package

arrival

Source

2-simulate.lisp (file)

Macro: progv* VARS VALS &body BODY

progv + printing feature.

Package

arrival

Source

2-simulate.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

6.1.3 Functions

Function: %in-fresh-binding FN
Package

arrival

Source

2-simulate.lisp (file)

Function: apply-action ACTION

Checks the precondition and
applies an action of the form (name . args) to the current state.

Package

arrival

Source

2-simulate.lisp (file)

Function: apply-effect CONDITION

Applies the effect of the condition. It respects the conditional effect

Package

arrival

Source

2-simulate.lisp (file)

Function: evaluate FORM

Evaluate atoms, predicates and (object/numeric) fluents.

Package

arrival

Source

2-simulate.lisp (file)

Writer

(setf evaluate) (function)

Function: (setf evaluate) NEWVAL FORM

Evaluate the input into a form that is can be directly evaluated.

Package

arrival

Source

2-simulate.lisp (file)

Reader

evaluate (function)

Function: fact< ARG1 ARG2
Package

arrival

Source

1-fact-ordering.lisp (file)

Function: fact= ARG1 ARG2
Package

arrival

Source

1-fact-ordering.lisp (file)

Function: facts ()

Returns a list of facts that hold in the current state. Depending on the value of the *exclude-type-predicates-in-trace*, it includes the type predicates (true by default)

Package

arrival

Source

2-simulate.lisp (file)

Function: flatten-type TYPE

Returns the list of all parent types (including itself and OBJECT), handling the infinite loop.
Signals an error when the type is not connected to the root OBJECT type.

Package

arrival

Source

1-flatten-types.lisp (file)

Function: flatten-typed-def TYPED-DEF

Takes a typed-def L and returns three values:
1. the untyped version of L
2. a list of literals converted from the types of the parameters, including the parent types 3. alist of (arg . type)

Example: (?x - table) -> (?x), ((table ?x)), ((?x . table))

Package

arrival

Source

1-flatten-types.lisp (file)

Function: flatten-types/argument ARG TYPE

Returns a list of type predicates for each parent type of TYPE,
with ARG as the argument. The result does not contain the OBJECT type.

Example: (flatten-types/argument ’?x ’airport) -> ((airport ?x) (location ?x))

Package

arrival

Source

1-flatten-types.lisp (file)

Function: flatten-types/condition CONDITION
Package

arrival

Source

1-flatten-types.lisp (file)

Function: flatten-types/effect EFFECT
Package

arrival

Source

1-flatten-types.lisp (file)

Function: flatten-types/predicate PREDICATE &optional INCLUDE-PARENT-TYPES

PREDICATE is a predicate form (name args...).
Look up the *predicates* and returns a list that contains itself
and the type predicates implied by its arguments.
By default, the implied type predicates contain only those for the most specific types,
minus the obvious OBJECT type.

Example: (flatten-types/predicate ’(next ?x ?y)) -> ((next ?x ?y) (location ?x) (location ?y))

When the optional argument INCLUDE-PARENT-TYPES is true, the list also contains all the type predicates up in the type hierarchy, minus the OBJECT type.

Package

arrival

Source

1-flatten-types.lisp (file)

Function: grovel-actions DOMAIN
Package

arrival

Source

1-flatten-types.lisp (file)

Function: grovel-axioms DOMAIN
Package

arrival

Source

1-flatten-types.lisp (file)

Function: grovel-constants DOMAIN
Package

arrival

Source

1-flatten-types.lisp (file)

Function: grovel-fluents DOMAIN
Package

arrival

Source

1-flatten-types.lisp (file)

Function: grovel-goal PROBLEM
Package

arrival

Source

1-flatten-types.lisp (file)

Function: grovel-init PROBLEM
Package

arrival

Source

1-flatten-types.lisp (file)

Function: grovel-objects PROBLEM
Package

arrival

Source

1-flatten-types.lisp (file)

Function: grovel-predicates DOMAIN
Package

arrival

Source

1-flatten-types.lisp (file)

Function: grovel-types DOMAIN
Package

arrival

Source

1-flatten-types.lisp (file)

Function: holds CONDITION RESULT

Utility for printing the predicate test

Package

arrival

Source

2-simulate.lisp (file)

Function: initialize NEXT
Package

arrival

Source

2-simulate.lisp (file)

Function: new-variable ()

Interns a new symbol in ARRIVAL.PDDL

Package

arrival

Source

1-flatten-types.lisp (file)

Function: package< A B
Package

arrival

Source

1-fact-ordering.lisp (file)

Function: package= A B
Package

arrival

Source

1-fact-ordering.lisp (file)

Function: parse-arguments ARGV
Package

arrival

Source

3-main.lisp (file)

Function: parse-typed-def LIST

Parse a list of form [obj* - type]* .
Returns an alist of (obj . type).
Does not handle the type inheritance.
Untyped parameters are given the type OBJECT.
The order is preserved.
It does not care what the obj is. It can be a list, too.

Example: (parse-typed-def ’(airport1 - airport truck1 truck2 - truck banana))

-> ((airport1 . airport) (truck1 . truck) (truck2 . truck) (banana . object))

Example: (parse-typed-def ’((deposit ?p - person) - number (content ?e - envelope) - paper))

-> (((deposit ?p - person) . number) ((content ?e - envelope) . paper))

Package

arrival

Source

1-flatten-types.lisp (file)

Function: pprint-facts &optional S

Print the list of facts to the stream, inside the PDDL package.

Package

arrival

Source

2-simulate.lisp (file)

Function: pprint-pddl THING &optional S

Print THING to the stream, inside the PDDL package.

Package

arrival

Source

2-simulate.lisp (file)

Function: pprint-pddl-to-string THING

Print THING to the string, inside the PDDL package.

Package

arrival

Source

2-simulate.lisp (file)

Function: prove-axiom AXIOMS NAME ARGS

Prove that the axiom with the given arguments hold in the current state. This function is not responsible for caching the result.

Package

arrival

Source

2-simulate.lisp (file)

Function: prove-axiom1 AXIOM ARGS
Package

arrival

Source

2-simulate.lisp (file)

Function: simulate-main &rest ARGV
Package

arrival

Source

3-main.lisp (file)

Function: simulate-plan-from-file DOMAIN PROBLEM PLAN-INPUT-FILE CALLBACK

CALLBACK is a function with no argument, that is called after the initialization and after applying each action.

Package

arrival

Source

2-simulate.lisp (file)

Function: simulate1 DOMAIN PROBLEM *PLAN* CALLBACK
Package

arrival

Source

2-simulate.lisp (file)

Function: simulate2 DOMAIN PROBLEM CALLBACK
Package

arrival

Source

2-simulate.lisp (file)

Function: simulate3 CALLBACK
Package

arrival

Source

2-simulate.lisp (file)

Function: symbol< A B
Package

arrival

Source

1-fact-ordering.lisp (file)

Function: symbol= A B
Package

arrival

Source

1-fact-ordering.lisp (file)

Function: test CONDITION

Test the condition in the current state. Returns true when the condition holds.

Package

arrival

Source

2-simulate.lisp (file)

Function: unify-duplicates VARIABLES FN

If there are any duplicates in VARIABLES,
the second or later appearances are replaced with a new symbol. FN is called with two arguments; The new, unique variable list and a list of equality constraints.

Package

arrival

Source

1-flatten-types.lisp (file)

Function: variablep VARIABLE
Package

arrival

Source

1-flatten-types.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   A   F   L   M  
Index Entry  Section

A
arrival.asd: The arrival<dot>asd file
arrival/src: The arrival/src module
arrival/src/0-package.lisp: The arrival/src/0-package<dot>lisp file
arrival/src/1-fact-ordering.lisp: The arrival/src/1-fact-ordering<dot>lisp file
arrival/src/1-flatten-types.lisp: The arrival/src/1-flatten-types<dot>lisp file
arrival/src/2-simulate.lisp: The arrival/src/2-simulate<dot>lisp file
arrival/src/3-main.lisp: The arrival/src/3-main<dot>lisp file

F
File, Lisp, arrival.asd: The arrival<dot>asd file
File, Lisp, arrival/src/0-package.lisp: The arrival/src/0-package<dot>lisp file
File, Lisp, arrival/src/1-fact-ordering.lisp: The arrival/src/1-fact-ordering<dot>lisp file
File, Lisp, arrival/src/1-flatten-types.lisp: The arrival/src/1-flatten-types<dot>lisp file
File, Lisp, arrival/src/2-simulate.lisp: The arrival/src/2-simulate<dot>lisp file
File, Lisp, arrival/src/3-main.lisp: The arrival/src/3-main<dot>lisp file

L
Lisp File, arrival.asd: The arrival<dot>asd file
Lisp File, arrival/src/0-package.lisp: The arrival/src/0-package<dot>lisp file
Lisp File, arrival/src/1-fact-ordering.lisp: The arrival/src/1-fact-ordering<dot>lisp file
Lisp File, arrival/src/1-flatten-types.lisp: The arrival/src/1-flatten-types<dot>lisp file
Lisp File, arrival/src/2-simulate.lisp: The arrival/src/2-simulate<dot>lisp file
Lisp File, arrival/src/3-main.lisp: The arrival/src/3-main<dot>lisp file

M
Module, arrival/src: The arrival/src module

Jump to:   A   F   L   M  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
A   E   F   G   H   I   M   N   P   S   T   U   V  
Index Entry  Section

%
%in-fresh-binding: Internal functions

(
(setf evaluate): Internal functions

A
apply-action: Internal functions
apply-effect: Internal functions

E
evaluate: Internal functions

F
fact<: Internal functions
fact=: Internal functions
facts: Internal functions
flatten-type: Internal functions
flatten-typed-def: Internal functions
flatten-types/argument: Internal functions
flatten-types/condition: Internal functions
flatten-types/effect: Internal functions
flatten-types/predicate: Internal functions
Function, %in-fresh-binding: Internal functions
Function, (setf evaluate): Internal functions
Function, apply-action: Internal functions
Function, apply-effect: Internal functions
Function, evaluate: Internal functions
Function, fact<: Internal functions
Function, fact=: Internal functions
Function, facts: Internal functions
Function, flatten-type: Internal functions
Function, flatten-typed-def: Internal functions
Function, flatten-types/argument: Internal functions
Function, flatten-types/condition: Internal functions
Function, flatten-types/effect: Internal functions
Function, flatten-types/predicate: Internal functions
Function, grovel-actions: Internal functions
Function, grovel-axioms: Internal functions
Function, grovel-constants: Internal functions
Function, grovel-fluents: Internal functions
Function, grovel-goal: Internal functions
Function, grovel-init: Internal functions
Function, grovel-objects: Internal functions
Function, grovel-predicates: Internal functions
Function, grovel-types: Internal functions
Function, holds: Internal functions
Function, initialize: Internal functions
Function, new-variable: Internal functions
Function, package<: Internal functions
Function, package=: Internal functions
Function, parse-arguments: Internal functions
Function, parse-typed-def: Internal functions
Function, pprint-facts: Internal functions
Function, pprint-pddl: Internal functions
Function, pprint-pddl-to-string: Internal functions
Function, prove-axiom: Internal functions
Function, prove-axiom1: Internal functions
Function, simulate-main: Internal functions
Function, simulate-plan-from-file: Internal functions
Function, simulate1: Internal functions
Function, simulate2: Internal functions
Function, simulate3: Internal functions
Function, symbol<: Internal functions
Function, symbol=: Internal functions
Function, test: Internal functions
Function, unify-duplicates: Internal functions
Function, variablep: Internal functions

G
grovel-actions: Internal functions
grovel-axioms: Internal functions
grovel-constants: Internal functions
grovel-fluents: Internal functions
grovel-goal: Internal functions
grovel-init: Internal functions
grovel-objects: Internal functions
grovel-predicates: Internal functions
grovel-types: Internal functions

H
holds: Internal functions

I
in-fresh-binding: Internal macros
initialize: Internal functions

M
Macro, in-fresh-binding: Internal macros
Macro, progv*: Internal macros

N
new-variable: Internal functions

P
package<: Internal functions
package=: Internal functions
parse-arguments: Internal functions
parse-typed-def: Internal functions
pprint-facts: Internal functions
pprint-pddl: Internal functions
pprint-pddl-to-string: Internal functions
progv*: Internal macros
prove-axiom: Internal functions
prove-axiom1: Internal functions

S
simulate-main: Internal functions
simulate-plan-from-file: Internal functions
simulate1: Internal functions
simulate2: Internal functions
simulate3: Internal functions
symbol<: Internal functions
symbol=: Internal functions

T
test: Internal functions

U
unify-duplicates: Internal functions

V
variablep: Internal functions

Jump to:   %   (  
A   E   F   G   H   I   M   N   P   S   T   U   V  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
S  
Index Entry  Section

*
*actions*: Internal special variables
*axiom-table*: Internal special variables
*axioms*: Internal special variables
*exclude-type-predicates-in-trace*: Internal special variables
*fact-table*: Internal special variables
*fluents*: Internal special variables
*goal*: Internal special variables
*hold-level*: Internal special variables
*in-initialization*: Internal special variables
*init*: Internal special variables
*new-fact-table*: Internal special variables
*next-action*: Internal special variables
*objects*: Internal special variables
*plan*: Internal special variables
*predicates*: Internal special variables
*previous-action*: Internal special variables
*proof-stack*: Internal special variables
*relaxed-planning*: Internal special variables
*types*: Internal special variables
*verbosity*: Internal special variables

S
Special Variable, *actions*: Internal special variables
Special Variable, *axiom-table*: Internal special variables
Special Variable, *axioms*: Internal special variables
Special Variable, *exclude-type-predicates-in-trace*: Internal special variables
Special Variable, *fact-table*: Internal special variables
Special Variable, *fluents*: Internal special variables
Special Variable, *goal*: Internal special variables
Special Variable, *hold-level*: Internal special variables
Special Variable, *in-initialization*: Internal special variables
Special Variable, *init*: Internal special variables
Special Variable, *new-fact-table*: Internal special variables
Special Variable, *next-action*: Internal special variables
Special Variable, *objects*: Internal special variables
Special Variable, *plan*: Internal special variables
Special Variable, *predicates*: Internal special variables
Special Variable, *previous-action*: Internal special variables
Special Variable, *proof-stack*: Internal special variables
Special Variable, *relaxed-planning*: Internal special variables
Special Variable, *types*: Internal special variables
Special Variable, *verbosity*: Internal special variables

Jump to:   *  
S  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   P   S  
Index Entry  Section

A
arrival: The arrival system
arrival: The arrival package
arrival.pddl: The arrival<dot>pddl package

P
Package, arrival: The arrival package
Package, arrival.pddl: The arrival<dot>pddl package

S
System, arrival: The arrival system

Jump to:   A   P   S