OTTER How-To

1. Getting OTTER

    Unfortunately, OTTER is to GSAT as San Francisco is to Des Moines -- you can do more, but its even harder to find your way around if you're not familiar with it.  We tried to once again insulate you from the sea of options and endless powerful features by providing you with a Perl script that should make your lives much easier.  The procedure for getting the OTTER executable and the Perl script is given below.
    As before, you are welcome to toy around with the real thing if you are so inclined.  This handout assumes that you're using the script, but everything that we do below can be done scriptless if you're patient enough.  If you're interested in playing with OTTER without our protection, the straight executable is called 'otter' and you'll need the User's Guide from the OTTER web site to figure out syntax, etc.
    Both the program, 'otter', and the Perl script, 'simple_otter.pl', can both be found in the directory /export/Apps.  Pick your favorite directory name and substitute it for 'otter_dir' below.  Then just type in the following sequence of commands to copy OTTER into your directory:
 
mkdir otter_dir
cd otter_dir
ln -s /Apps/*otter* .
The rest of this handout assumes that you are in the directory that you just created; which will be the case if you faithfully type in all three lines above.

2. Input File

   As with GSAT, you'll want to use a text editor to create a file named 'input'.  Once you have translated the English sentences in the Mystery Problem into first-order logic, you just type them in using the following notation:
 

Standard	OTTER equivalent
" x, y, z	all x y z
$ x, y, z	exists x y z
AND, L	&
OR, V	|
NOT	-
Implication	->
Equivalence	<->

For example, here is a of first-order logic sentence and its translation into OTTER syntax:

FOL: " x (((Breath(x) L Take(you, x)) V (Move(x) L Make(you, x)) => Watching(i, you))
 OTTER: all x (((Breath(x) & Take(you, x)) | (Move(x) & Make(you, x)) -> Watching(i, you))

NOTE: Spaces are important to OTTER.  "P & Q" is legal; "P&Q" is not.
All you do is translate your logical sentences into this syntax and type them in one by one, with a period at the end of each one.  A few tips to make sure that you get it right:
 

1. Each sentence should get its own line.
2. When in doubt, parenthesize.  Precedence in OTTER is the same as first-order logic, but its easier to get confused with the slightly cryptic symbols.  The extra parentheses don't cost you anything and they'll help you to make sure that you are in fact proving what you think you're proving.
3. Make sure that you do not type any stray keystrokes -- a random '.' in the middle of your sentence will make OTTER complain.
4. Do not, however, forget the '.' at the end of each sentence, as this will also make OTTER complain.
5. Names can be any string of alphanumeric characters starting with a letter.  Otter decides if the name is a variable or a constant by context . . . anything that is quantified (i.e., follows an 'all' or an 'every') is considered a variable and everything else is considered a constant.  In the second example above, 'x' is a variable, 'i' and 'you' are constants, and 'Breath', 'Take', 'Move', 'Make', and 'Watching' are relations.
6. Relations are entered just as you would think they should be, just type the name of the relation followed immediately (i.e., NO WHITESPACE) by a left parenthesis, followed by a comma-separated list of arguments, followed by a right parenthesis.
Finally, after you have entered all of the background information, leave one blank line and type in the sentence that you want OTTER to try to refute.  Make sure that you do this -- because otherwise you'll just have OTTER trying to contradict your background information, which won't get you anywhere.  Here is a complete sample input file:
 
OtherSide(Grass) -> Greener(Grass).
Dead(Grass) -> -Greener(Grass).

Dead(Grass) & OtherSide(Grass).

3. Running OTTER

    OK, the rest is fairly simple.  Check to see that a file named 'input' was created as described above and is in the same directory as the files 'otter' and 'simple_otter.pl'.  Then just type in the following line:

perl  simple_otter.pl

Just like with GSAT.  And again, the answer should just pop out after OTTER has done its thing.  If OTTER was unable to find a contradiction in the sentences you gave it, it should report 'NO CONTRADICTION FOUND.'  If it was, however, able to find a contradiction, it will display a series of steps describing its proof that will look something like this (for the sample file given above):

1 [] -OtherSide(Grass)|Greener(Grass).
2 [] -Dead(Grass)| -Greener(Grass).
3 [] Dead(Grass).
4 [] OtherSide(Grass).
5 [1,4] Greener(Grass).
6 [2,3] -Greener(Grass).
7 [6,5] $F.

In order to interpret this output, you need to know a few things.  The numbers in the leftmost column are the proof steps, and the bracketed expression following each number is the justification for each step.  The justification '[]' means that the statement was given as input and the justification '[x,y]' means that OTTER resolved the lines 'x' and 'y' to give the deduction presented in this line.  Of course, if you're paying attention you'll have already noticed that the statements taken as given above are not actually the statements that we gave it in the input file.  This is because OTTER converts your input sentences into a clausal form before working with them -- and if you work through them, you should see that anything that OTTER claims to be given is nothing more than a rewriting of your input sentences.  Finally, the '$F' in the last step means that the 'x' and 'y' used to justify this step are contradictory.
    In case you missed it, a copy of the proof will be saved in a file named 'output' which you can examine at your convenience by typing:

more output

That should be everything.  Good luck.

Special Thanks: The simple_otter.pl script and the first draft of this documentation are by Samar Mehta, one of the best TAs I've ever worked with.  Thanks so much, Samar!