PDP-10.its/doc/shrdlu/manual.1

                             PROVISIONAL

                        SHRDLU USERS' MANUAL

                             (Version 0)



                   S. Card, A. Rubin, T. Winograd







                          For CMU-1 Version
                            10/50 Monitor


                           August 14, 1972
                     Carnegie-Mellon University
                        Pittsburgh, Pa 15213
îBRIEF DESCRIPTION OF SHRDLU
---------------------------


         SHRDLU IS A SYSTEM FOR THE  COMPUTER  UNDERSTANDING
    OF  ENGLISH.    THE  SYSTEM  ANSWERS QUESTIONS, EXECUTES
    COMMANDS, AND  ACCEPTS  INFORMATION  IN  NORMAL  ENGLISH
    DIALOG.    IT  USES  SEMANTIC INFORMATION AND CONTEXT TO
    UNDERSTAND DISCOURSE AND TO DISAMBIGUATE SENTENCES.   IT
    COMBINES  A COMPLETE SYNTACTIC ANALYSIS OF EACH SENTENCE
    WITH A "HEURISTIC  UNDERSTANDER"  WHICH  USES  DIFFERENT
    KINDS  OF  INFORMATION  ABOUT A SENTENCE, OTHER PARTS OF
    THE DISCOURSE, AND GENERAL INFORMATION ABOUT  THE  WORLD
    IN DECIDING WHAT THE SENTENCE MEANS.

         SHRDLU  IS  BASED  ON  THE  BELIEF  THAT A COMPUTER
    CANNOT DEAL  REASONABLY  WITH  LANGUAGE  UNLESS  IT  CAN
    "UNDERSTAND"  THE  SUBJECT IT IS DISCUSSING. THE PROGRAM
    IS GIVEN A DETAILED MODEL OF THE KNOWLEDGE NEEDED  BY  A
    SIMPLE  ROBOT  HAVING  ONLY A HAND AND AN EYE.  THE USER
    CAN GIVE IT  INSTRUCTIONS  TO  MANIPULATE  TOY  OBJECTS,
    INTERROGATE  IT ABOUT THE SCENE, AND GIVE IT INFORMATION
    IT WILL USE IN DEDUCTION.  IN ADDITION  TO  KNOWING  THE
    PROPERTIES  OF  TOY  OBJECTS,  THE  PROGRAM HAS A SIMPLE
    MODEL OF  ITS  OWN  MENTALITY.    IT  CAN  REMEMBER  AND
    DISCUSS ITS PLANS AND ACTIONS AS WELL AS CARRY THEM OUT.
    IT ENTERS INTO A DIALOG WITH  A  PERSON,  RESPONDING  TO
    ENGLISH  SENTENCES WITH ACTIONS AND ENGLISH REPLIES, AND
    ASKING FOR CLARIFICATION  WHEN  ITS  HEURISTIC  PROGRAMS
    CANNOT  UNDERSTAND A SENTENCE THROUGH USE OF CONTEXT AND
    PHYSICAL KNOWLEDGE.

         IN THE PROGRAMS, SYNTAX, SEMANTICS,  AND  INFERENCE
    ARE INTEGRATED IN A "VERTICAL" SYSTEM IN WHICH EACH PART
    IS CONSTANTLY COMMUNICATING WITH THE OTHERS. SHRDLU USES
    SYSTEMIC  GRAMMAR, A TYPE OF SYNTACTIC ANALYSIS WHICH IS
    DESIGNED  TO  DEAL  WITH   SEMANTICS.      RATHER   THAN
    CONCENTRATING  ON  THE EXACT FORM OF RULES FOR THE SHAPE
    OF LINGUISTIC  CONSTITUENTS,  IT  IS  STRUCTURED  AROUND
    CHOICES   FOR  CONVEYING  MEANING.    IT  ABSTRACTS  THE
    RELEVANT FEATURES OF THE LINGUISTIC STRUCTURES WHICH ARE
    IMPORTANT FOR INTERPRETING THEIR MEANING.

         IN  SHRDLU  MANY KINDS OF KNOWLEDGE ARE REPRESENTED
    IN THE FORM OF PROCEDURES RATHER THAN TABLES OF RULES OR
    LISTS  OF  PATTERNS.    BY DEVELOPING SPECIAL PROCEDURAL
    LANGUAGES FOR GRAMMAR, SEMANTICS, AND  DEDUCTIVE  LOGIC,
    THE  FLEXIBILITY  AND  POWER OF PROGRAMMING LANGUAGES IS
    GAINED    WHILE    RETAINING    THE    REGULARITY    AND
    UNDERSTANDABILITY  OF SIMPLER RULE FORMS.  EACH PIECE OF
    KNOWLEDGE CAN BE A PROCEDURE, AND CAN CALL ON ANY  OTHER
    PIECE OF KNOWLEDGE IN THE SYSTEM.
îIMPLEMENTATION AND VERSION INFORMATION
--------------------------------------



	SHRDLU  WAS  PROGRAMMED  AT   THE   MIT   ARTIFICIAL
    INTELLIGENCE  LABORATORY  BY  T.   WINOGRAD AS PART OF A
    DOCTORAL DISSERTATION IN MATHEMATICS.

	THE PROGRAM WAS MODIFIED DURING THE LAST YEAR BY  T.
    WINOGRAD,  D.  MACDONALD, J. HILL, AND S. CARD TO CHANGE
    SOME OF ITS INTERNAL REPRESENTATIONS  AND  TO  MAKE  THE
    CODE  EASIER  TO UNDERSTAND FOR PERSONS WISHING TO STUDY
    THE PROGRAM.  NO MAJOR ATTEMPTS WERE  MADE  TO  INCREASE
    ITS POWER.

	THE PROGRAM RUNNING AT C-MU IS THE MODIFIED VERSION.
    THE DISPLAY FACILITIES OF  THE  PROGRAM  HAVE  NOT  BEEN
    IMPLEMENTED  AT  C-MU.  THE PROGRAM WAS COAXED AWAY FROM
    MIT'S  INCOMPATIBLE  TIME-SHARING   SYSTEM   (ITS)   AND
    CONVERTED  TO RUN UNDER THE DEC TOPS10 (10-50) OPERATING
    SYSTEM BY CONVERTING MACLISP ITSELF  (AND  TO  DO  THAT,
    CONVERTING  THE  MIDAS  ASSEMBLY LANGUAGE).  THE MACLISP
    CONVERSION WAS DONE BY GEORGE ROBERTSON.

THE VERSION OF SHRDLU BEING DISTRIBUTED FROM  CMU  IS  NAMED
    THE  C1  VERSION.  IT IS CURRENT WITH THE MIT VERSION TO
    JUNE 1972.  THE SHOW AND TELL USER INTERFACE AND VARIOUS
    CHANGES   WERE  ADDED  FOR  THE  C-MU  WORKSHOP  ON  NEW
    TECHNOLOGIES IN COGNITIVE RESEARCH IN JUNE 1972.

	SHRDLU IS  WRITTEN  IN  MACLISP  1.6  (VINTAGE  JUNE
    1972).  IT USES ABOUT 100 TO 140K 36-BIT WORDS OF MEMORY
    ON A PDP-10.
îTHE SHRDLU DISTRIBUTION PACKAGE
-------------------------------

	A  distribution  package  of  the C1 system has been
    make up containing basically

	1. a SAV copy of MACLSP which runs under a version
	of the DEC 10/50 monitor on a PDP-10. TRACE and GRIND
	files are also included.

	2.  a MICROPLANNER (EXPR version)

	3.  a SHRDLU, in two parts.

Together  these constitute a SHRDLU Kit from which it should
    be possible to fashion a full SHRDLU  or  a  parser-only
    system  or  a  MICROPLANNER.   It  is  thought  that the
    package has a good chance of running on any (unmodified)
    10/50  system  or  on  any  other  system  with  a fully
    compatible MACLISP (ha!).

The system currently running at C-mu uses 134K of core,  but
    with  hand  editing this should go down to 100k.  Please
    note that a SAVE file of the system occupies between 800
    and  1000  blocks  of  disk  space.  A SAVE file is not,
    therefor, even remotely close to fitting onto a DECTAPE.

MACLISP:
	MACLISP  has  not been completely implemented.  This
    version is, however, sufficient to run SHRDLU.  A couple
    perversities:

	1. most LISP control characters don't work.  To
	do a <control g> type (IOC G).

	2. Because of an incompatibility problem, UWRITE files
	and (IOC B) printer output are double spaced.

	3. occasionally the garbage collector fails.
	(IOC D) makes it print out every time it is garbage-
	collecting so you can usually figure out what 
	happened.  (IOC C) turns off this printout.  To
	get around the garbage collector's always failing 
	in the same place in your program, try forcing
	a garbage collect with (GC) so that it gets to
	garbage collect in some other part of your program. 

It is possible to obtain a version of MICROPLANNER which has
    been  compliled  into  LAP  in which case you need a LAP
    loader (which comes in both LAP and EXPR versions).  The
    LISP  compiler does work in 10-50 MACLISP so if you want
    to roll your own that is available too.   All of this is
    another good couple of DECTAPES.

SHRDLU is distributed as 2 large files to prevent parts from
    falling off and for ease  in  loading.   The  boundaries
    between  the  traditional  SHRDLU files used for editing
    are indicate by (e.g.)  ;;;[S->GLOBAL]  which  indicates
    the  Start  of a subfile called GLOBAL.  TECO buffs take
    note.

CAVEAT EMPTOR
-------------

This  set  of  probrams  is  distributed  in  the  cause  of
    dissemination of research.  There is no warranty  either
    expressed  or  implied  for  labor, parts, or servicing.
    Various bugs are known to lurk in  the  systems:  SHRDLU
    bugs  +  MICROPLANNER bugs + MACLISP bugs + MIDAS bugs +
    conversion  bugs   +   Monitor   bugs   +   installation
    incompatability  bugs  +  hardware bugs. Furthermore the
    system is presently in a state  of  development  (active
    and  suspended)  with various uncompleted projects here,
    notes to friends there, etc.

îASSEMBLING YOUR SHRDLU KIT
--------------------------

Before you begin assembling a SHRDLU it is probably wise  to
    get a listing of all of files (except MACLSP!!!).  Start
    by listing this one.  It is also helpful to transfer all
    of  the  files  to  dsk.  The names are designed so that
    this  can  be  done  with  pip  in   few   instructions.
    BEWARE!!!!  when  moving MACLSP around with PIP remember
    to use the /B switch.

Also note that the alt-mode which MACLSP looks for  to  tell
    it  that  you are through doing allocation is an 033 and
    not a 175 or 176.  The MACLISP editor also  requires  an
    033.   If  you  don't  have one type <space> after every
    allocation opportunity when entering MACLSP.  And  don't
    type (EDIT) or you'll get stuck.

Below  is  the  TTY listing for building a SHRDLU.  What you
    type is indicated in lower case letters, what  it  types
    in capitals.


..........STEP 1: Reading in and allocating MACLSP
.run dsk:maclsp

BIG NUMBER LISP 229
ALLOC? y
CORE = 26       170
FXS = 2000      $

*

..........STEP 2: Reading in MICROPLANNER

(uread plnr c1)
(DSK +)
(ioc q)
T

COMMENT

C1

DECLARE

    .
    .
    .
   etc


..........STEP 3: Reading in Trace and GRIND files

(uread trace c1)
(DSK +)
(ioc q)
T

TRACE 16, LOADING:
(? ?? REMTRACE UNTRACE TRACE)
FOR EXPLANATION, TYPE
(?)
(uread grind c1)
(DSK +)
(ioc q)
T
LOADING GRIND C1
*
(uread grinit c1)
(DSK +)
(ioc q)
T

BUILD

(ERT ERTSTOP ERTERR GLOBAL-ERR BUG SAY)

PDEFINE

DEFS

(OBJECT RELATION)

(thinit)

((PRINT (QUOTE MICRO-PLANNER)) (PRINC THVERSION) (COND ((ERRSET (APPLY
 (QUOTE UREAD) (APPEND (QUOTE (/.PLNR/. /(INIT/))) (CRUNIT))) NIL) (SE
TQ ERRLIST (CDDDDR ERRLIST)) (SETQ THTREE NIL) (SETQ THLEVEL NIL) (THE
RT TH%0% READING /.PLNR/. /(INIT/)))) (SETQ ERRLIST (CDDDDR ERRLIST)) 
(SETQ THINF NIL) (SETQ THTREE NIL) (SETQ THLEVEL NIL) (THERT TOP LEVEL
))

..........STEP3-1/2: Arming MICROPLANNER - This MUST be done to
           activate Macro-characters for subsequent readins

(ioc q)QUIT
MICRO-PLANNER C1
>>>  TOP-LEVEL
LISTENING  THVAL
..........STEP 3-3/4: (OPTIONAL) This is a good place to do a 
           SAVE to hedge against subsequent disaster.

^C
.sav dsk:shrdlu
JOB SAVED

.start


>>>  TOP LEVEL
LISTENING  THVAL

..........STEP 4: Reading first SHRDLU file

(uread shrdl1 c1)
DSK ")
(ioc q)
T

ERT

ERTEX

PRINT2

   .
   .
   .
  ETC


..........STEP 5: Reading 2nd SHRDLU file

(uread shrdl2 c1)
(DSK ")
(ioc q)
T
ABSVAL

   .
   .
   .
  etc

..........STEP 6: Arming SHRDLU 

(ioc g)
(ioc g)QUIT

..........STEP 7: INITIAL switch settings. Don't you dare.

      At this point SHRDLU will print out a list of some
      its internal switches and invite you to change them.
      The first time you run the program you should probably
      leave them as they are (type space after each arrow).
      Within SHRDLU these same switches can be changed
      with the TELL command.  Or, if you insist, this same
      display can be brought back by evaluating (SW).

      Then SHRDLU will print
READY

..........STEP 8: Saving SHRDLU


      Save immediately before you mung up the nice clean
      core image inside by playing with it.

^C
.sav dsk:shrdlu
JOB SAVED


..........STEP 9: Playing with SHRDLU.


.start



READY
      Now SHRDLU wants to eat a sentence.  And please don't
      forget the proper punctuation, especially the terminal
      punctuation mark at the end. Type sentences in
      upper case.  A capitalization is indicated by (e.g.) =A.
      This is useful for getting proper nouns across to
      the program.  The beginning of a sentence need not be capitalized.

      See Appendices 2 through 6 for examples
 To see if program is running try
      doing

<control x>
LISTENING---> tell parsing node on
*
LISTENING---> <CONTROL X>
READY
PICK UP A BIG RED BLOCK.

      The parser should start happily spewing forth 
      trace messages.





îINSTRUCTIONS FOR RUNNING SHRDLU
-------------------------------

     SHRDLU can be in 4 basic states, COMMAND, READY, RUN,
and REQUEST.  It is initially in COMMAND when loaded.
***
******COMMAND STATE
***
     In this state, SHRDLU expects the user to type a command.
It lets you know this by typing "LISTENING-->".
A command is a line containing one or more words, separated by 
spaces and terminated by a carriage return (<CR>).  The first
word must be one of the three words SHOW, TELL, or GO.  The
SHOW command is used to ask the system to show such things
as definitions, structures it is building, and the states of various
parameters and switches.  TELL is used to tell the system new
definitions and settings.
     After executing a COMMAND, the system is ready for
another one, and prompts by saying LISTENING-->.
You can leave COMMAND state by typing <CONTROL X>
instead of a command.  This will cause the program to continue
whatever it was doing before it entered COMMAND
state, or to go to READY state if it was not already in the
process of analyzing a sentence.  If instead, you type the
command "GO", it will drop the sentence it is working on, and go 
into READY state for a new one.
****
******COMMAND FORMATS
****
     The SHOW and TELL commands are based on a ZOG-like tree
(one tree for each).  The first word of the command is SHOW
or TELL, the second names a node in the corresponding tree,
and the rest are any arguments appropriate to the action
at that node.
For example, the command:

SHOW FUNCTION MEET

will display the contents of the LISP function "MEET".

SHOW SHOW

displays the "SHOW" tree, while for the "TELL" tree, you type

SHOW TELL

     If all of the arguments are not specified, the system will
request more.  For example, typing:
SHOW FUNCTION
would cause it to type out:
FUNCTION:
requesting the name of a function from the user.  It is then
in REQUEST state (see below.)
     Non-terminal nodes of the tree may or may not have corresponding
actions.  For example, the command

TELL PLANNER OFF

causes the entire batch of PLANNER tracing devices to be turned off
at once, even though there are subnodes of the PLANNER node which
can be used to turn individual features on and off selectively.
If there is no action associated with such a node, the system will
ask the user to select one of its subnodes.
     If you type "SHOW" or "HELP" followed by a carriage return,
it will guide you through the choices, using REQUESTS
(see below).
*****
*****REQUEST STATE
*****
     SHRDLU can request two kinds of information from
the user.  If it wants him to CHOOSE between a set of alternatives,
it will end the request with a ?.  If it wants him to SPECIFY 
a name or list of names, it will end it with a :.
     For a CHOOSE, all it needs is enough information to decide
between the alternatives.  Begin typing your choice, and when it
is complete enough, type a <control x>.  If you type fewer
letters than necessary (e.g. typing just a P, when PLANNER
and PARSING are among the choices) it will ring the bell and wait
for you to continue.  If you type more than necessary it doesn't
matter.
     For a SPECIFY, type the required response, terminated by a
<CR>.  If you type a <CR> with nothing else, it will take some
default response which is appropriate to the action (For exa