@DATABASE "Default"
@NODE "MAIN" "Deduce 1.10"
@TOC "MAIN"
            Deduce! version 1.10
             by James Williams

        @{"       Disclaimer        " LINK "Disclaimer"}
        @{"     What is Deduce?     " LINK "Whatis"}
        @{"     Getting Started     " LINK "Starting"}
        @{"      Using Deduce       " LINK "Using"}
        @{"        Commands         " LINK "Commands"}
        @{" Some notes about Deduce " LINK "Notes"}
        @{"        Examples         " LINK "Examples"}
        @{"         To Do           " LINK "ToDo"}
        @{"     Known problems      " LINK "Problems"}
        @{"        History          " LINK "History"}
        @{"  Contacting the author  " LINK "Author"}
        @{"    Acknowledgements     " LINK "Acknowledgements"}

@ENDNODE

@NODE "Disclaimer" "Disclaimer"
@TOC "MAIN"

This program is freeware.  It is being distributed with no warranty.
I can't be held responsible for any damages caused either directly or
indirectly by the use of this program.  Use it at your own risk.

This program cannot be sold for profit.  If you wish to use this program
in a commercial distribution, you must first obtain written permission from
@{"me" LINK "Author"}.
@ENDNODE

@NODE "Whatis" "What is Deduce?"
@TOC "MAIN"

Deduce is an experiment in artificial intelligence.  It attempts to simulate
deductive reasoning.  Consider the following example:

Spot is a dog.
A dog is an animal.
Therefore, Spot is an animal.

Deduce will accept input in the form of English sentences and upon request
will answer yes/no questions about what it has been taught.
@ENDNODE

@NODE "Starting" "Getting Started"
@TOC "MAIN"

Deduce must be run from the CLI.  Open a CLI or Shell window, cd to the
directory with Deduce, and type Deduce.  At this point, you should see
the program name, my name, and a prompt waiting for input.
@ENDNODE

@NODE "Using" "Using Deduce"
@TOC "MAIN"

Most of the time, you will probably be entering statements and asking
questions.  I line of input has the form:

subject [helping verb] [verb] predicate

You can also make a statement negative by including the word 'no'.  For
example, you could say "A dog is not a cat."  In fact, the only way
you can ever get a no response to a question is by entering negative
statements.

Deduce interprets any statement beginning with a "question" word to be
a question.  If Deduce is unable to find a definite answer to your question,
it will respond with "I don't know".  Sometimes it may seem like Deduce should
know the answer to a question, but it says it doesn't know.  Consider the
following example:

A liquid will evaporate.
A solid is not a liquid.
Will a solid evaporate?

It looks like Deduce should be able to figure out that since a solid is not
a liquid, it won't evaporate.  However, logically, there isn't enough
information given to make that conclusion.  Deduce doesn't know anything
about a solid, and so it doesn't know for sure that it can't evaporate.
Perhaps another example will make this clearer.

Water will evaporate.
Alcohol is not water.
Will Alcohol evaporate?

This time it should be clear that simply because alcohol is not water doesn't
mean it won't evaporate.

When you enter something, Deduce knows the opposite isn't necessarily true.
So if you enter "A cat is not a dog", Deduce won't automatically know that
a dog is not a cat.
@ENDNODE

@NODE "Commands" "Commands"
@TOC "MAIN"

Aside from entering statements and questions, you can also tell Deduce to
do something for you.  These are the commands it understands.

 @{"  Load   " LINK "Load"}
 @{"  Save   " LINK "Save"}
 @{"   Why   " LINK "Why"}
 @{"  Quit   " LINK "Quit"}
 @{" Divulge " LINK "Divulge"}
@ENDNODE

@NODE "Load" "Load"
@TOC "Commands"

Load:

Load will load in a previously saved session and add it to what's currently
in memory.  Load is entered on a line by itself, afterwhich you will be asked
for a filename.

Note : This doesn't clear the current memory.  If you need to erase what's
       already in memory, quit the program and restart.
@ENDNODE

@NODE "Save" "Save"
@TOC "Commands"

Save:

To save your work, type save, and when asked for a filename, enter the name
you wish to save your work as.

Save will create a text file containing all the statements you've entered.
If you want to change something you've entered, you can save your work and
edit the save file with any text editor or word processor than can load
and save plain ascii files.  An ampersand (&) marks the end of input, so
you can put comments after it.
@ENDNODE

@NODE "Why" "Why"
@TOC "Commands"

Why:

The why command is usually used to let you see the logic behind one of
Deduce's responses to a question.  You must first ask the question, then
enter "why" on a line by itself to see Deduce's reasoning.

You may also use the why command if you enter a statement and Deduce
responds with "Yeah, I know" or "That can't be right...".  These
messages mean you tried to enter something that Deduce already knows.
Typing "why" at the next prompt will show you how the information is
known.

@ENDNODE

@NODE "Quit" "Quit"
@TOC "Commands"

Quit:

When you get tired of playing with Deduce, type "quit" to leave the program.
It is synonymous with exit, bye, stop, and end.
@ENDNODE

@NODE "Divulge" "Divulge"
@TOC "Commands"

Divulge:

Divulge will print the entire contents of Deduce's database.  This was
originally put in for debugging purposes, but I decided to leave it in.
@ENDNODE

@NODE "Notes" "Some notes about the program"
@TOC "MAIN"

Deduce tries to interpret your sentence by looking at the position of the
words.  Therefore, it is important to follow a few rules when teaching
Deduce new information.  Your subject and predicate nouns need to be
one word.  If you have to use more that one word (for an adjective or
whatever) put an underscore character between the words.  This doesn't apply
to articles (a, an, the) and other known words (all, every, ever, of).
Deduce understands negative contractions (don't, doesn't, isn't, aren't,
won't, can't, wasn't, weren't, ain't) as well as no and not.  Deduce isn't
case sensitive, so don't worry about matching case on everything.  Deduce
automatically strips out all punctuation from a sentence.  Words are limited
to 20 characters, and sentences are limited to 20 words and 100 characters.
Anything more will be stripped off.
@ENDNODE

@NODE "Examples" "Examples to get you started"
@TOC "MAIN"

Here are some examples you can try to get you started.

Spot is a dog.
A dog is an animal.
A dog will eat dog_food.
Chunkies is a dog_food.
A cat is an animal.
A dog is not a cat.
Will Spot eat Chunkies?
why
A horse is an animal.
A horse will eat hay.
A horse will drink water.
A horse will not eat meat.
A square is a rectangle.
A rectangle is a polygon.
A liquid will evaporate.
Water is a liquid.
Alcohol is a liquid.
@ENDNODE

@NODE "ToDo" "To Do"
@TOC "MAIN"

- I will probably make the program store records more efficiently.  Right
  now it uses fixed length records chewing up over 120 bytes of memory
  per entry.  I figure a variable length record structure would reduce
  this to an average of 30-40 bytes per record.

- The parser needs to be rewritten to more accurately detect errors in
  the input.  It should also be possible to allow multiple word subjects
  and predicates without the need for the underscore.

- Online help.  (Shouldn't be a problem - I've already got the code in there
  to detect the command "help")

- Sooner or later I will probably have to build a GUI for this program.
  I can't do right now because my compiler refuses to compile the GUI
  code (I'm using an ancient version of DICE)

- Add a ReqTools interface for loading and saving.  The current method is
  appauling.

- Buy an 030 + MMU + memory expansion for my 1200 and a decent C compiler
  so I can not only compile the GUI code, but can also run enforcer to
  check my program.  (If anyone finds that this program causes enforcer
  hits, be sure to let me know)

- Make a crippled version for PCs and make 'em pay a handsome shareware fee
  to get the full version ;)  (I'm sure I'll be getting flamed for this one)
@ENDNODE

@NODE "Problems" "Known Problems"
@TOC "MAIN"

- The parse relies on the position of words to determine their part of
  speech, and can therefore easily misinterpret your input.
  e.g. "Green is a good color" <- good will be interpreted as a verb
  (good color should have been written as good_color)

- Memory is allocated in small chunks.  This can lead to memory fragmentation
  (fragmentation should be minimal unless you build a huge database)

- When asking a question, negative words are ignored, so if you entered
  "Is a dog not a cat", it would be interpreted as "Is a dog a cat".
@ENDNODE

@NODE "History" "History"
@TOC "MAIN"

History:

Jan 31, 1995 : version 1.00
    First release

Feb 3, 1995 :  version 1.10
  * Added load and save commands
  * Made an AmigaGuide version of the documentation
@ENDNODE

@NODE "Author" "Contacting the Author"
@TOC "MAIN"

If you need to contact me (for comments, questions, suggestions, bug
reports, etc), my email address is :

    williamj@griffon.mwsc.edu

If you don't have email, my address is:

    James Williams
    209 Thomas
    Weston, MO  64098  USA

And, if you're lucky, you may even catch me on the #amiga channel on IRC
with the name JamesW.
@ENDNODE

@NODE "Acknowledgements" "Acknowledgements"
@TOC "MAIN"

I would like to thank the following people who helped make Deduce a reality:

 Everyone who helped with the Mind.rexx (util/rexx/Mindrx.lha on Aminet).
 It was what inspired me to write Deduce.  I wrote Deduce not to replace
 Mind.rexx, but instead to complement it.  Although they appear similar,
 Deduce and Mind.rexx are actually very different programs, and I believe
 Mind.rexx has more potential.  I wish the best of luck to everyone
 contributing the project. (PS I couldn't find the names of any of the
 programmers in the archive.  That's why I didn't mention any names)

 Ronald Carnell, author of "Smart Alec" (Compute! Sept. 1987).  He supplied
 the basic algorithm used in "Smart Alec", which I took and expanded upon
 to create Deduce.

 Everyone who has uploaded programs to the Aminet, as well as Urban Mueller
 for creating the Aminet.  Without such a large source for Amiga software,
 the Amiga would most likely have faded away a long time ago.

 And everyone who owns and supports our beloved Amiga computer.  I hope to
 see Amiga business pick up after this #$%?! bidding is over.  Keep up the
 good work, everyone!
@ENDNODE
ÿ