### gNiall-0.7.1 README file

    gNiall -- The GNOME Non-Intelligent AMOS Language Learner
    Gary Benson <rat@spunge.org>        http://rat.spunge.org
    =========================================================

         gNiall attempts to learn whatever language you try to teach it by
    breaking down the sentences and remembering the connections between words.
    See `How it works' for more details, or see `How to use it' to find that
    out. It is a complete rewrite of an Amiga program, Niall, that was written
    by Matthew Peck in 1990.

    Contents
    --------

    	Installation
    	No GNOME?
    	How to use it
    	History
    	How it works

    Installation
    ------------

         To install gNiall on your system you need GNOME installed, and of
    course all the things that GNOME needs. See http://www.gnome.org for
    details about that.

    Once you have untarred the sources, cd into the gNiall directory and type:
    	./configure
    	make
    	su
    	make install

    Then, you can type gNiall anywhere and it will run. If you get fed up of
    it, then you can remove it by typing:

    	su
    	make uninstall

    from the directory containing the source.

         The file INSTALL contains generic instructions for using the
    configure script, or you can type ./configure --help to see a list of
    options.

    No GNOME?
    ---------

         If you don't have GNOME, there is a console-only version. Inside the
    gNiall directory, type:

    	mv otherStuff/console.c .
    	gcc niall.c console.c -o cNiall

    And you will have a console-only version to play with. There are some
    commands to do various things:

    	#new	 - Clear the dictionary
    	#load	 - Load a dictionary
    	#save	 - Save the dictionary
    	#list	 - List the dictionary
    	#correct - Correct a spelling
    	#exit	 - Quit

    But it isn't nearly as pretty or easy to use as the GNOME version.

    How to use it
    -------------

         This is simplicity itself.  At the bottom of the window is a box into
    which you can type sentences. It is not necessary to finish your sentence
    with a full stop if you only type one sentence, but you can type more than
    one in at once, separated by full stops. It is perfectly legal to type:

    	The cat sat on the mat. The cat was called George.

    Niall treats commas as if they were full stops, so it is probably better
    to just omit them.

    Once you press return, Niall will then reply and you can enter another
    sentence. If you just press return without entering anything, Niall will
    say something anyway. If you just press return when Niall has no
    vocabulary, the message "I cannot speak yet!" will be displayed.

         After a while, you can build up huge dictionaries of words, and it
    will merrily talk rubbish at you. What fun! The dictionaries can be saved and
    loaded using the entries in the file menu, and there is also the facility to
    correct mis-spelt words. Selecting `View Dictionary' from the File menu will
    produce a representation of the dictionary, which is explained in more detail
    in the `How it works' section below.

    History
    -------

         The original Niall was written in AMOS, a kind of BASIC for Amigas,
    but it could only cope with about 500 words and, of course, could only be
    used if you had an Amiga (or an emulator). So I rewrote it in C, mainly
    to learn how to write GNOME programs, and to find out how automake/
    autoconf works. If you are interested, the original AMOS source is in
    the otherStuff directory, as is its original documentation. The functional
    enhancements made in gNiall are:

        * The number of words that Niall can remember are now limited only by
           the amount of memory that you have.
        * Mis-spelt words may be corrected in a more wholesome way than before.

    How it works (nearly verbatim from the original manual)
    ------------------------------------------------------

    Niall attempts to learn English, or whatever language you care to teach it,
    by breaking down the sentences you type in, remembering words, connections
    between words, the number of times a particular connection has occurred, and
    start/end sentence markers.
         The best was to explain is by example.  Suppose the first sentence you
    typed was:

    	  The large green tree was next to the old red shed

         Niall would split the sentence into separate words and store any new
    words it found (Niall's vocabulary is initially blank!).
    It would then store the following information:

    1.....The word THE can begin a sentence.
    2.....The word LARGE can follow the word THE.
    3.....The word GREEN can follow the word LARGE...etc
    4.....The word SHED can end a sentence.

    Therefore after analysing this sentence, NIALL has learnt 10 new words
    and knows that the word THE can not only start a sentence by also
    join onto both LARGE and OLD. This can be expressed as
    follows:

           /----------<---------------<----------------<----------\
    (Start)\-THE --- LARGE -- GREEN -- TREE -- WAS -- NEXT -- TO--/
    	    \
    	     \--- OLD --- RED --- SHED(End)

    Niall then replies to your sentence by picking a random word which can begin
    the sentence, followed by one of the words which can join onto it selected
    at random, then one which can join onto it, and so on until the end of
    sentence marker is reached.  Therefore, NIALL may reply to your first
    sentence like so:

    			The old red shed.

    The more sentences you type in the more words Niall will learn, the more
    connections it will make and the more original the replies will seem.
      Replies must be taken with a pinch of salt since the grammar will be
    anything but perfect.  A semi intelligent version which attempts to learn
    grammar too, may appear at a later date.

    Niall also remember the number of times a particular connection is made in
    order to weight the replies and make them sound more realistic. For example,
    if the second sentence you type is:

    		The old garden gate was blue

    Niall now knows that the word THE joins onto the word OLD more
    often than it joins to LARGE.  The table above now looks like this:

           /----------<---------------<----------------<----------\
    (Start)\-THE --- LARGE -- GREEN -- TREE -- WAS -- NEXT -- TO -/
    	   \\                            /  /
    	     === OLD - RED - SHED (End) /  -BLUE (End)
    		     \                 /
    		      - GARDEN - GATE-/

    Niall could now reply:
    	The old garden gate was next to the old red shed.

          To look at the vocabulary that Niall has built up, select `View
    Dictionary' from the File menu. If you had typed in the two sentences above,
    then the output would look like this:

       0: > 2| 1(2)
       1: the 3| 8(2) 2(1)
       2: large 1| 3(1)
       3: green 1| 4(1)
       4: tree 1| 5(1)
       5: was 2| 13(1) 6(1)
       6: next 1| 7(1)
       7: to 1| 1(1)
       8: old 2| 11(1) 9(1)
       9: red 1| 10(1)
      10: shed 1| -1(1)
      11: garden 1| 12(1)
      12: gate 1| 5(1)
      13: blue 1| -1(1)

    Word 0 (>) is an empty word which is used to start the sentence. The 2| means
    that there are 2 possible next words, and the 1(2) means that both those
    possibilities are word 1 (The). The word -1 (as in `13: blue 1| -1(1)') means
    end-of-sentence.

    =========================================================
    Gary Benson <rat@spunge.org>        http://rat.spunge.org