TIM - version 1.1

Maria Fox and Derek Long, Department of Computer Science,
University of Durham, UK

Maria.Fox@dur.ac.uk    D.P.Long@dur.ac.uk
http://www.dur.ac.uk/~dcs0www/research/stanstuff/planpage.html

THIS CODE IS SUPPLIED ``AS IS'' WITHOUT WARRANTY OF ANY KIND,
AND ITS AUTHORS AND THE JOURNAL OF ARTIFICIAL INTELLIGENCE RESEARCH
(JAIR) AND JAIR'S PUBLISHERS AND DISTRIBUTORS, DISCLAIM ANY AND ALL
WARRANTIES, INCLUDING BUT NOT LIMITED TO ANY IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE,
AND ANY WARRANTIES OR NON INFRINGEMENT.  THE USER ASSUMES ALL LIABILITY
AND RESPONSIBILITY FOR USE OF THIS SOURCE CODE, AND NEITHER THE AUTHOR
NOR JAIR, NOR JAIR'S PUBLISHERS AND DISTRIBUTORS, WILL BE LIABLE FOR
DAMAGES OF ANY KIND RESULTING FROM ITS USE.  Without limiting the
generality of the foregoing, neither the authors, nor JAIR, nor JAIR's
publishers and distributors, warrant that the Code will be
error-free, will operate without interruption, or will meet the needs
of the user.


Introduction
------------

TIM is a preprocessing system for Strips planning domains and problems. 
It generates a collection of state invariants for the domain and a type
structure which enables planners to exploit more domain structure than
is explicitly described in the domain definition. 

This release contains executables only. Source code will be made available
as soon as it is ready for public release. A description of the algorithms
used by TIM is currently in preparation. 

TIM Input
---------

To run TIM it should be given two command line arguments: a domain file
and a problem file, both in strict PDDL format. This version of TIM will
only accept STRIPS domains (with equality).  Please let us know if you
encounter any problems or discover any bugs. If you wish to further
discuss this system, or to arrange for its output to be reformatted for
any purpose, please email us.

It should be emphasised:

  o 	TIM is very sensitive to the input it receives. It MUST be strict
	PDDL - some of the PDDL release domains are listed as strict, but
	include reversed goals and initial state conditions in the problem
	specification: check this if you encounter parser errors.

  o 	TIM will only accept :strips and/or :equality requirements - it cannot
	deal with any other ADL extensions in its current release, including
	conditional effects, quantified conditions and so on.

  o 	TIM's parser reports errors in a rather unforgiving way! All errors
	are reported as a line number which is counted from the start of the
	domain file (first line is line 0) and then on into the problem domain.
	

About TIM
---------

TIM was used in its first version as a preprocessor for STAN in the AIPS'98
competition. The main purpose it played in that version of STAN was to supply
types which restrict the possible instantiations of operators. In fact, since
in the competition domains all the types were supplied as explicit static 
preconditions to the operators, STAN derived little benefit from this aspect
of TIM's analysis. An interesting example illustrating the potential benefits
of this analysis is the following domain:

-----------------------------------------------------------------------------
(define (domain rocket)
	(:predicates 	(at ?x ?y)
			(in ?x ?y)
			(fuelled ?x)
			(unfuelled ?x)
			(loc ?x)
			(obj ?x)
			(container ?x))

	(:action fly 
		:parameters (?x ?y ?z)
		:precondition (and (at ?x ?y) (loc ?z) (fuelled ?x))
		:effect (and (not (at ?x ?y)) (at ?x ?z) (unfuelled ?x) 
			(not (fuelled ?x))))

	(:action load
		:parameters (?x ?y ?z)
		:precondition (and (obj ?x) (container ?y) (at ?x ?z) (at ?y ?z))
		:effect (and (in ?x ?y) (not (at ?x ?z))))

	(:action unload
		:parameters (?x ?y ?z)
		:precondition (and (at ?y ?z) (in ?x ?y))
		:effect (and (at ?x ?z) (not (in ?x ?y)))))

-------------------------------------------------------------------------------
with this problem:

-------------------------------------------------------------------------------
(define (problem rocket1)
	(:domain rocket)
	(:objects rocket a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 
			a11 a12 a13 a14 a15 a16 a17 a18
			a19 a20 a21 a22 a23 a24 a25 a26 
			a27 a28 a29 a30 a31 a32 a33 a34
			a35 a36 a37 a38 a39 a40
			Paris London)
	(:init 	(at rocket London)
		(container rocket)
		(at a1 London)
		(at a2 London)
		(at a3 London)
		(at a4 London)
		(at a5 London)
		(at a6 London)
		(at a7 London)
		(at a8 London)
		(at a9 London)
		(at a10 London)
		(at a11 London)
		(at a12 London)
		(at a13 London)
		(at a14 London)
		(at a15 London)
		(at a16 London)
		(at a17 London)
		(at a18 London)
		(at a19 London)
		(at a20 London)
		(at a21 London)
		(at a22 London)
		(at a23 London)
		(at a24 London)
		(at a25 London)
		(at a26 London)
		(at a27 London)
		(at a28 London)
		(at a29 London)
		(at a30 London)
		(at a31 London)
		(at a32 London)
		(at a33 London)
		(at a34 London)
		(at a35 London)
		(at a36 London)
		(at a37 London)
		(at a38 London)
		(at a39 London)
		(at a40 London)
		(obj a1)
		(obj a2)
		(obj a3)
		(obj a4)
		(obj a5)
		(obj a6)
		(obj a7)
		(obj a8)
		(obj a9)
		(obj a10)
		(obj a11)
		(obj a12)
		(obj a13)
		(obj a14)
		(obj a15)
		(obj a16)
		(obj a17)
		(obj a18)
		(obj a19)
		(obj a20)
		(obj a21)
		(obj a22)
		(obj a23)
		(obj a24)
		(obj a25)
		(obj a26)
		(obj a27)
		(obj a28)
		(obj a29)
		(obj a30)
		(obj a31)
		(obj a32)
		(obj a33)
		(obj a34)
		(obj a35)
		(obj a36)
		(obj a37)
		(obj a38)
		(obj a39)
		(obj a40)
		(loc London)
		(loc Paris)
		(fuelled rocket))
	(:goal (and (at a1 Paris)
		(at a2 Paris)
		(at a3 Paris)
		(at a4 Paris)
		(at a5 Paris)
		(at a6 Paris)
		(at a7 Paris)
		(at a8 Paris)
		(at a9 Paris)
		(at a10 Paris)
		(at a11 Paris)
		(at a12 Paris)
		(at a13 Paris)
		(at a14 Paris)
		(at a15 Paris)
		(at a16 Paris)
		(at a17 Paris)
		(at a18 Paris)
		(at a19 Paris)
		(at a20 Paris)
		(at a21 Paris)
		(at a22 Paris)
		(at a23 Paris)
		(at a24 Paris)
		(at a25 Paris)
		(at a26 Paris)
		(at a27 Paris)
		(at a28 Paris)
		(at a29 Paris)
		(at a30 Paris)
		(at a31 Paris)
		(at a32 Paris)
		(at a33 Paris)
		(at a34 Paris)
		(at a35 Paris)
		(at a36 Paris)
		(at a37 Paris)
		(at a38 Paris)
		(at a39 Paris)
		(at a40 Paris))))
---------------------------------------------------------------------------

STAN can solve this problem in as little as 90 millisecs using the type
analysis from TIM to restrict the operator instantiations. Other instantiation
based planners, such as IPP, are unable to cope with the immense demands on
space for the instantiation of the operators without type constraints.
