
                      +--------------------------------+
                      |                                |
                      |  TURING PROGRAM TUTORIAL FILE  |
                      |                                |
                      +--------------------------------+


The purpose of this file is to provide a tutorial lesson on some of the basic
features of the program called TURING.  While it is possible to learn how to
use the program by reading all the built-in help screens contained within
each menu, if you are a first-time user, we suggest you read this tutorial
while first running the program, and then later you can digest all the
information contained in the help functions within each menu in the program.
You can import this file, TURING.TXT, into any word processor and then print
it so you can read the hard copy output while you run the program.

To begin the tutorial you must have the program file TURING.EXE and the three
corresponding demonstration program files called TDEMO1.TXT, TDEMO2.TXT, and
TDEMO3.TXT.  We assume these four files are in the current directory on the
currently selected disk drive.


PRELIMINARIES
=============


KEYBOARD CONVENTIONS
--------------------

As part of this tutorial we need to give directions on which keys to press on
your keyboard.  We will enclose in angle brackets single keystrokes that you
should type.  For example, if we ask you to type the first three letters
of the alphabet we will show <A> <B> <C>.  If we ask you to press the control
key, the alternate key, the backspace key, the space bar, or the enter (or
return) key, we will show <CTRL>, <ALT>, <BACKSPACE>, <SPACE> or <ENTER>.

Each enclosure in angle brackets should refer to exactly one keystroke or one
character.  On most keyboards, to type in a left or right parenthesis requires
using a <SHIFT> key in conjunction with another key.  We will NOT show the
shift key as a separate keystroke in this tutorial because we consider
entering a parenthesis as entering a single character.  Other characters like
<+> or <*> can be entered in two different ways on some keyboards, one way
uses the <SHIFT> key, the other way does not.  In general, we would only show
the single character in angle brackets and we leave it up to you to decide
whether or not the <SHIFT> is needed to enter the character.

These keyboard conventions should make clear exactly how many and which keys
you press.  If it is necessary to press two keys simultaneously we will show
a connecting plus sign between the keystrokes.  This is done primarily with
the Control key <CTRL>, and the Alternate key <ALT>.  For example, when we
show <ALT>+<X> it means you should press both the Alternate key and key X at
the same time.  <ALT>+<X> is used in the Main Menu to exit from the program.


ADVICE FOR NOVICES AND EXPERTS
------------------------------

This tutorial file assumes you have the mathematical background required to
understand the features that will be demonstrated.  You may find some sections
more applicable to novices than experts, or vice versa, depending on your
background and experience.  If you encounter an example that is beyond your
understanding, you can either skip that example, or you can press the keys and
view the results, even though you may not fully comprehend the output.  This
tutorial does not discuss techniques on how to best use or apply the available
features.  It only serves to demonstrate the basic features and capabilities
which you can learn to apply to solve problems that are of interest to you.



GETTING STARTED
===============

To begin running the TURING program type the command:

                       <T> <U> <R> <I> <N> <G> <ENTER>



The program called TURING simulates what is called a Turing Machine.  Such a
machine is an abstract model used to study the fundamental aspects of digital
(logical) computations.  A simple Turing machine is all that is required to
model any digital computation on any computer, past, present, or future!

Alan Turing was a British mathematician who conceived the idea in 1935, long
before computers were established.  Turing also helped design and build the
machines which were used to break the secret German Enigma spy codes in World
War II.  Turing committed suicide in 1954 after having been exposed as a
homosexual.

There are three major components in the Main Menu screen.

At the top of the screen is a representation of a recording tape which has
numbers recorded on it.  Initially all the numbers are 0 and each position on
the tape is delineated by a little box.  The boxes are numbered from 1 to 999
and only a portion of the middle of the tape is shown.  The only two numbers
that are allowed to be recorded on the tape are 0 and 1.  The tape used in
the abstract model of a Turing machine is infinite in length in both the
left and right directions, but we will find it convenient to label (number)
each position on the tape.  This recording tape is the first major component
of the Turing machine.

Numbers are read or written on the tape at the position marked by what we call
the Read/Write Head.  This appears as a solid-white rectangle which covers the
tape.  The number which is on the tape under the Read/Write Head can also
be seen.  Any number which is read or written must pass through the Read/Write
Head.  The Read/Write Head is the second major part of the Turing machine.

The third major component is what is called the State Transition Table.
Essentially this table contains the directions for telling the machine how
to operate, much like a paper roll is used to control a player piano.
To understand how this table operates in conjunction with the recording tape
is to completely understand a Turing Machine.  If you have never seen a
Turing Machine before, when you finish reading this tutorial you may still
not completely understand everything, but hopefully you will gain some
appreciation of the concept.


A FIRST PROGRAM
===============

The first program we will run is the default program that has already been
loaded into the State Transition Table.  This is a very simple program that
increments a number by 1.


HOW UNARY NUMBERS ARE REPRESENTED ON THE TAPE
---------------------------------------------

First we have to explain that numbers written on a Turing machine tape have
a very simple representation.  These numbers are NOT BINARY, in fact they
are sometimes called unary.  Everyone should be familiar with making
tallies by writing vertical slashes on a piece of paper.  Unary numbers are
loosely analogous to tallies.  For example, four consecutive vertical marks
written like

                                   | | | |
                                   | | | |
                                   | | | |

could represent the number 4.

In traditional tallying, when you mark a fifth tally you draw it across the
previous four tallies.  So a stick representation of five tallies might
look something like this

                                    | | | |
                                   -+-+-+-+-
                                    | | | |


Well the analogy breaks down here.  On a Turing machine tape each unary number
is represented by a series of consecutive 1's.  The number 4 would be
represented by four consecutive ones like

                                    1 1 1 1

but a number like 7 would be represented by seven consecutive ones like

                                 1 1 1 1 1 1 1


In traditional tallying a number like 7 would be represented by a group of
five, plus two additional tallies.


                               | | | |   | |
                              -+-+-+-+-  | |
                               | | | |   | |


On a Turing machine tape, there is no crossing allowed.  Just count
consecutive 1's and you know what the number is.


READING THE STATE TRANSITION TABLE
----------------------------------

The initial State Transition Table should appear as follows:

                         +----+---++---+---+----+
                         | S# | R || W | M | N# |
                         +----+---++---+---+----+
                         |  1 | 0 || 0 | R |  1 |
                         |  1 | 1 || 1 | R |  2 |
                         |  2 | 0 || 1 | R |  3 |
                         |  2 | 1 || 1 | R |  2 |
                         |  3 | 0 || 0 | H |  3 |
                         |  3 | 1 || 0 | H |  3 |
                         +----+---++---+---+----+

The five column headings represent the following.

  S# = the current State number
  R  = the symbol which is Read from the tape (must match table R-value)
  W  = the symbol which is Written back on the tape
  M  = the direction of Movement. R=right L=left H=halt
  N# = the New state number


Each line in the table has an interpretation.  For example, the first two
lines in the table can be interpreted as saying:

  If you are in state 1 and a 0 is read from the tape, then write a 0 back
  on the tape, move the tape to the right and remain in state 1.

  If you are in state 1 and a 1 is read from the tape, then write a 1 back
  on the tape, move the tape to the right and enter into state 2.

The double vertical line in the table serves the purpose of separating the
input (S# R) in the two left columns from the output (W M N#) in the last
three columns.

The following shows the same table with comments to the right of each line.
This format corresponds to how you would write a program file in an ASCII
text file.  The curly braces are used to delimit comments in the file.


{ S# R  :  W  M  N# }

  1  0  :  0  R  1  { if a 0 is read; write 0, shift right, stay in state 1. }
  1  1  :  1  R  2  { if a 1 is read; write 1, shift right, go to state 2.   }

  2  0  :  1  R  3  { if a 0 is read; write 1, shift right, go to state 3.   }
  2  1  :  1  R  2  { if a 1 is read; write 1, shift right, stay in state 2. }

  3  0  :  0  H  3  { if a 0 is read; write 0, halt.                         }
  3  1  :  0  H  3  { if a 1 is read; write 0, halt.                         }


Although the above comments accurately describe the table contents, they do
not explain why the entire table represents a program for incrementing a
unary number by 1.  To get that understanding we will first watch the program
run.


RUNNING A FIRST EXAMPLE
=======================

Type                                  <I>

to initialize the tape.

You will be prompted and asked if you want to clear the tape first.  Type

                                      <Y>

to clear the tape to all 0's.

The next prompt asks you to enter a number which will be the input data for
this program.  Type

                             <1> <1> <1> <ENTER>

to store three consecutive 1's on the tape.

After you press the ENTER key you should see the three 1's have been stored
on the tape just to the left of the Read/Write Head.

Next we will start the program running.

Press                                 <R>

and watch the animations on the screen.


This first program will take a little over 20 seconds to run to completion.

The first thing to notice when the program stops is that there are four 1's
to the right of the Read/Write Head.  So in fact, the program has added 1 to
the number 3.

All inputs to a program are normally stored to the left of the Read/Write Head
while all answers are returned in numbers to the right of the Read/Write Head.


DO IT AGAIN
===========

If the animations went by a little fast, try running the program again.

You may notice certain sections of the State Transition Table are highlighted
and then unhighlighted as the program runs.

Type                                  <I>

to initialize the tape.

When prompted to clear the tape type

                                      <Y>

and then enter the number 3 by typing


                            <1> <1> <1> <ENTER>

The tape will be positioned so that the starting position box is under the
Read/Write Head.  The starting position is set at 500.

Finally press                         <R>

to begin running the program.

This simple program has only three states.  The first state is used to start
reading the input data to the left of the Read/Write Head.  When state 2 is
entered you are already in the process of reading the number.

Note that the instruction

                                  2 1 : 1 R 2

represents a program loop which directs the machine to keep reading and
passing data under the Read/Write Head, so long as the data read is always
a 1.  This will be the case when the data consists of a string of consecutive
1's that represent a single integer.  This one instruction can be interpreted
as saying, keep scanning left (the tape moves Right) along the tape until you
hit a 0 which represents the left end of the input number.


The instruction                   2 0 : 1 R 3

acts as both a loop terminator (it forces the machine into state 3) and an
answer maker since the 1 that it writes is the 1 that gets appended to the
string of 1's that have just passed under the Read/Write Head.

State 3 acts as the terminating state, since once this state is reached the
program will halt.

                                  3 0 : 0 H 3
                                  3 1 : 0 H 3

You might also note that initially there are only 0's to the left of the
initial string of 1's.  Thus the instruction

                                  3 1 : 0 H 3

should never be executed in practice because state 3 should never see a 1 as
input that comes in from the left of the Read/Write Head.


LOADING IN A SECOND PROGRAM FROM DISK
=====================================

The next program we want to run is in the file TDEMO2.TXT.  Press

                                      <F>

to go to the File Menu.

We first need to enter the name of the file we want to read in.  Press

                                      <I>

to change the Input Filename and when prompted type

               <T> <D> <E> <M> <O> <2> <.> <T> <X> <T> <ENTER>

You should see the input filename has been entered in the appropriate edit
box.

Now press                              <R>

to initiate the file read command and further press

                                      <Y>

to confirm that you want the read the file with the Input Filename name.

The bottom of the screen will count the file lines as they are read and you
will remain in the File Menu.  Press

                                    <ENTER>

to return back to the Main Menu from the File Menu.

You should see a new State Transition Table as follows:

                         +----+---++---+---+----+
                         | S# | R || W | M | N# |
                         +----+---++---+---+----+
                         |  1 | 0 || 0 | R |  1 |
                         |  1 | 1 || 0 | R |  2 |
                         |  2 | 0 || 0 | R |  4 |
                         |  2 | 1 || 0 | R |  3 |
                         |  3 | 0 || 1 | R |  4 |
                         |  3 | 1 || 0 | R |  2 |
                         |  4 | 0 || 1 | R |  5 |
                         |  4 | 1 || 1 | R |  5 |
                         |  5 | 0 || 0 | H |  5 |
                         |  5 | 1 || 0 | H |  5 |
                         +----+---++---+---+----+


This table represents a program to determine if a number is even or odd.
If the number input is even, this program will write 11 as its output.  If
the number input is odd this program will just write 1 as its output.  We
will analyze this program in detail after we run it for a couple of examples.


A SAMPLE RUN TO SHOW 4 IS EVEN
==============================

Type                                  <I>

to initialize the tape.

When prompted to clear the tape type

                                      <Y>

and then enter the number 4 by typing


                            <1> <1> <1> <1> <ENTER>

Finally press                         <R>

to begin running the program.  This example will take just over 1/2 a minute
to run to completion.

When the program terminates you should see two 1's just to the right of the
Read/Write Head.  This output means the program found the number 4 was even.


A SAMPLE RUN TO SHOW 3 IS ODD
=============================

Type                                  <I>

to initialize the tape.

When prompted to clear the tape type

                                      <Y>

and then enter the number 3 by typing


                              <1> <1> <1> <ENTER>

Finally press                         <R>

to begin running the program.  This will take about 1/2 minute to run.

When the program terminates you should see just one 1 to the right of the
Read/Write Head.  This output means the program found the number 3 was odd.


ANALYZING THE EVEN/ODD PROGRAM
==============================

If you look down the column labeled W, which represents the write actions,
you will note that there are mostly 0's in that column.  In fact, only states
3 and 4 write 1's as output, and even at that, state 3 does so only half the
time.  State 4 always writes a 1 and always enters the terminating state which
is state 5.

So it is a safe bet that the program will terminate after it enters state 4.

Note that state 4 is entered only after a 0 has been read in either state 2
or state 3.

You might also note that all the movement directions in the entire program
are always to the right.  So the input number gets scanned from its right-
most digits through to its left-most digits.

So what are states 2 and 3?

When the machine is in state 2 the number that has been scanned up to that
point is an odd number.  If no more digits remain, then the next digit read
will be a 0 and state 2 will kick into state 4 which will write a 1 and then
the program will go to state 5 and terminate.

If the machine is in state 2 and there are more digits to be read, then the
machine will read the next 1 digit and kick up to state 3 which represents
the case of an even number of 1's.  When you start state 3 you have read an
even number of 1's and then the only question is whether or not more digits
remain to be read.

If in state 3 and you read a 0, then you write the first 1 in the answer and
you kick into state 4 which always writes a 1 no matter what it reads.  So
in this case the 1 written by state 4 is the second 1 and thus the output
11 represents an even number.

If in state 3 and you read a 1, then the number has more digits so you kick
back to state 2 which is the odd state and you would continue scanning the
input number until no more 1 digits get read.

By now you should have a fair understanding of the entire State Transition
Table for this example.  Just remember state 2 symbolizes the odd state and
state 3 symbolizes the even state.  While a number is being scanned you
alternate between being in states 2 and 3 until no more 1 digits appear.
Both states 2 and 3 go to state 4 when the first 0 to the left of the input
number gets read.  Once you are in state 4 you never go back.  State 4 writes
the final 1 (in some cases the only 1) in the output.


A PROGRAM WHICH DOES MORE THAN JUST SCAN IN ONE DIRECTION
=========================================================

The above two programs were intended to be simple introductions to help you
understand some of the basic workings of a Turing machine.  The simplicity
of both examples derives from the fact that both programs scanned a single
input number and kept moving in one direction only.

The next example program is more complex in that it needs to store temporary
information on the tape and this requires moving both left and right on the
tape.  To load in the program press

                                      <F>

to get to the File Menu.  Then press  <I>

to change the Input Filename.  When prompted type in the name

                <T> <D> <E> <M> <O> <3> <.> <T> <X> <T> <ENTER>

Finally, press                      <R> <Y>

to read the file whose name you just entered.

After the file is read in, press      <ENTER>

to get back to the Main Menu.

This program has 9 states.  The State Transition Table can hold up to 99
states, and it will automatically scroll its contents so that the current
state is always within view from the Main Menu.  Since the program was just
loaded, the current state is number 1, and only the first six states now
show in the Main Menu.

The TDEMO3.TXT program performs the seemingly simple task of doubling a unary
number.  The first example we will run will double the number 3 to make 6.

Press                               <I> <Y>

to initialize and clear the tape and then enter the number 3 by further
typing

                              <1> <1> <1> <ENTER>

You should see three 1's just to the left of the Read/Write Head.

Press                                 <R>

to run the program.  This should take over a minute and a half to finish.
As the program runs you might note that the tape contents shift both left
and right at various times.

Also note how the current instructions in the State Transition Table are
highlighted and note the Instructions Completed counter at the upper right
side of the screen.  It takes 48 instructions before the program stops
running.

When the program finishes there will be six 1's to the right of the
Read/Write Head.  You may not be able to confirm there are no more than six
1's because you see only a limited part of the tape.  To see the tape parts
that are off the right edge of the screen, press the right cursor arrow key
on your keyboard to view more of the tape in the direction corresponding to
the arrow key.  If you scroll just one more position you should see the six
consecutive 1's.  The left and right cursor arrow keys can be used to scroll
the tape back and forth so you can view any parts that are off the screen.

The number of instructions that get executed when you double the number 3
is 48.  We will not explain the workings of the State Transition Table for
this particular program, but below we show a trace of the program steps that
you should have just executed.

In the representation below, the number under the Read/Write Head is written
between the square bracket symbols [*].  As you read the lines below you can
imagine the tape contents are scrolling back and forth.  The right-most column
of numbers below counts the instructions that are executed.  Each current
state is also indicated in the second to the right-most column.  The left-most
column indicates what is to be done with the preceding line.  For example, the
first instructions  W=0 M=R S=1 mean: write a 0 on the tape, overwriting
whatever is currently under the Read/Write Head, then move Right, and enter
State 1.

When the program starts execution there are three 1's just to the left of the
Read/Write Head.  The lower case x's delineate the relevant portions of the
tape.  The parts of the tape outside the x range are not used by this program.


              x 0 0 0 0 0 0 0 0 1 1 1 [0] x                         S=1    0.

W=0 M=R S=1     x 0 0 0 0 0 0 0 0 1 1 [1] 0 x                       S=1    1.

W=0 M=R S=2       x 0 0 0 0 0 0 0 0 1 [1] 0 0 x                     S=2    2.

W=1 M=R S=2         x 0 0 0 0 0 0 0 0 [1] 1 0 0 x                   S=2    3.

W=1 M=R S=2           x 0 0 0 0 0 0 0 [0] 1 1 0 0 x                 S=2    4.

W=0 M=R S=3             x 0 0 0 0 0 0 [0] 0 1 1 0 0 x               S=3    5.

W=1 M=R S=4               x 0 0 0 0 0 [0] 1 0 1 1 0 0 x             S=4    6.

W=1 M=L S=5             x 0 0 0 0 0 1 [1] 0 1 1 0 0 x               S=5    7.

W=1 M=L S=5           x 0 0 0 0 0 1 1 [0] 1 1 0 0 x                 S=5    8.

W=0 M=L S=6         x 0 0 0 0 0 1 1 0 [1] 1 0 0 x                   S=6    9.

W=1 M=L S=7       x 0 0 0 0 0 1 1 0 1 [1] 0 0 x                     S=7   10.

W=1 M=L S=7     x 0 0 0 0 0 1 1 0 1 1 [0] 0 x                       S=7   11.

W=0 M=R S=1       x 0 0 0 0 0 1 1 0 1 [1] 0 0 x                     S=1   12.

W=0 M=R S=2         x 0 0 0 0 0 1 1 0 [1] 0 0 0 x                   S=2   13.

W=1 M=R S=2           x 0 0 0 0 0 1 1 [0] 1 0 0 0 x                 S=2   14.

W=0 M=R S=3             x 0 0 0 0 0 1 [1] 0 1 0 0 0 x               S=3   15.

W=1 M=R S=3               x 0 0 0 0 0 [1] 1 0 1 0 0 0 x             S=3   16.

W=1 M=R S=3                 x 0 0 0 0 [0] 1 1 0 1 0 0 0 x           S=3   17.

W=1 M=R S=4                   x 0 0 0 [0] 1 1 1 0 1 0 0 0 x         S=4   18.

W=1 M=L S=5                 x 0 0 0 1 [1] 1 1 0 1 0 0 0 x           S=5   19.

W=1 M=L S=5               x 0 0 0 1 1 [1] 1 0 1 0 0 0 x             S=5   20.

W=1 M=L S=5             x 0 0 0 1 1 1 [1] 0 1 0 0 0 x               S=5   21.

W=1 M=L S=5           x 0 0 0 1 1 1 1 [0] 1 0 0 0 x                 S=5   22.

W=0 M=L S=6         x 0 0 0 1 1 1 1 0 [1] 0 0 0 x                   S=6   23.

W=1 M=L S=7       x 0 0 0 1 1 1 1 0 1 [0] 0 0 x                     S=7   24.

W=0 M=R S=1         x 0 0 0 1 1 1 1 0 [1] 0 0 0 x                   S=1   25.

W=0 M=R S=2           x 0 0 0 1 1 1 1 [0] 0 0 0 0 x                 S=2   26.

W=0 M=R S=3             x 0 0 0 1 1 1 [1] 0 0 0 0 0 x               S=3   27.

W=1 M=R S=3               x 0 0 0 1 1 [1] 1 0 0 0 0 0 x             S=3   28.

W=1 M=R S=3                 x 0 0 0 1 [1] 1 1 0 0 0 0 0 x           S=3   29.

W=1 M=R S=3                   x 0 0 0 [1] 1 1 1 0 0 0 0 0 x         S=3   30.

W=1 M=R S=3                     x 0 0 [0] 1 1 1 1 0 0 0 0 0 x       S=3   31.

W=1 M=R S=4                       x 0 [0] 1 1 1 1 0 0 0 0 0 0 x     S=4   32.

W=1 M=L S=5                     x 0 1 [1] 1 1 1 1 0 0 0 0 0 x       S=5   33.

W=1 M=L S=5                   x 0 1 1 [1] 1 1 1 0 0 0 0 0 x         S=5   34.

W=1 M=L S=5                 x 0 1 1 1 [1] 1 1 0 0 0 0 0 x           S=5   35.

W=1 M=L S=5               x 0 1 1 1 1 [1] 1 0 0 0 0 0 x             S=5   36.

W=1 M=L S=5             x 0 1 1 1 1 1 [1] 0 0 0 0 0 x               S=5   37.

W=1 M=L S=5           x 0 1 1 1 1 1 1 [0] 0 0 0 0 x                 S=5   38.

W=0 M=L S=6         x 0 1 1 1 1 1 1 0 [0] 0 0 0 x                   S=6   39.

W=0 M=R S=8           x 0 1 1 1 1 1 1 [0] 0 0 0 0 x                 S=8   40.

W=0 M=R S=9             x 0 1 1 1 1 1 [1] 0 0 0 0 0 x               S=9   41.

W=1 M=R S=9               x 0 1 1 1 1 [1] 1 0 0 0 0 0 x             S=9   42.

W=1 M=R S=9                 x 0 1 1 1 [1] 1 1 0 0 0 0 0 x           S=9   43.

W=1 M=R S=9                   x 0 1 1 [1] 1 1 1 0 0 0 0 0 x         S=9   44.

W=1 M=R S=9                     x 0 1 [1] 1 1 1 1 0 0 0 0 0 x       S=9   45.

W=1 M=R S=9                       x 0 [1] 1 1 1 1 1 0 0 0 0 0 x     S=9   46.

W=1 M=R S=9                         x [0] 1 1 1 1 1 1 0 0 0 0 0 x   S=9   47.

W=0 M=H S=9                         x [0] 1 1 1 1 1 1 0 0 0 0 0 x   S=9   48.


Note that there are now six 1's to the right of the Read/Write Head.

After reading the above you will gain an appreciation for just how primitive
a Turing Machine is.  It takes 48 instructions just to double the number 3.
If you scroll the above lines up and down in a word processor you can almost
animate how the program runs.

When the program changes from step 1. to step 2. it consumes the right-most
1 digit.  At step 7. the program has written the first two 1's in the answer.
These two 1's represent a doubling of the first digit consumed.

When the program changes from step 12. to step 13. it consumes the second
digit of the initial three digit number.  At step 19. the program has written
two more 1's in the answer that double the second digit consumed.

When the program changes from step 25. to step 26. it consumes the last 1
digit of the initial three digit number.  At step 33. the program has written
the final two 1's in the answer that double the second digit read.

From steps 39. to 48. the program is simply right-shifting the answer so that
its final resting place is just the right of the Read/Write Head.


READING AND WRITING PROGRAM FILES
=================================

This program provides two Main Menu items that help you work with files.  The
File Menu is used to enter filenames for reading and writing program files.
The file contents are read into an area that can be viewed and edited.  Use
the Edit Screen to edit the contents of files.  When you save a file, the
contents written to the file come from the Edit Screen.  The Edit Screen acts
as a full-screen editor for any programs you may wish to write.

Read all the help information from the Main Menu to learn about the file
formats.


THE AUTOMATIC AND SINGLE STEP MODES
===================================

The default mode of TURING runs programs in what is called an Automatic Mode.
But sometimes you may want to pause the action so you can analyze and think
about what is going on.  When that is the case, you can press key S to
temporarily stop the running action of a program.  You will then be in what
is called the Single-Step Mode, and to continue the action in this mode you
can repeatedly press the ENTER key to perform the next significant action.
After single-stepping through a few actions you can return to the Automatic
Mode at any time by pressing key A.  Thus you can press keys A and S at any
time to switch between the Automatic and Single-Step modes.


CHANGING THE SPEED OF ANIMATION
===============================

You can change the speed at which programs run by changing the value called
the Time Delay.  The Time Delay must be between 0 and 300, and the default
value is 30.  Enter a lower number for faster action.  Enter a larger value
for slower action.


CONCLUSION
==========

This concludes the TURING program tutorial.  If you haven't done so already,
you can now read the help information contained within each main program menu
item.  Most of the basic features have been covered here, but you may gain
more insight by reading all the help information available to you.  If after
all this you still have questions, you can contact the author at the address
given below.


Press
                                   <ALT>+<X>

to quit and exit the TURING program.


The TURING program is periodically updated to make improvements, add new
features, (and sometimes to correct bugs!).  You may also wish to contact the
author to check if you have the latest version of the program.  The author
also invites your comments about how you liked the program and will consider
any suggestions you may wish to offer for making the program even more useful.



OTHER PROGRAMS
==============

If you enjoy using the TURING program you may be interested to know there is
a whole suite of mathematical programs made by the author of TURING.  These
programs are intended to help motivate an interest in mathematics and computer
science.  Some of the titles of these programs and a brief description of each
is given below.

 1. MATRIX - a program that teaches row operations with matrices.  Features
    include fraction mode, decimal mode, solves linear systems, inverses,
    determinants, sets of basis vectors, eigenvectors and eigenvalues,
    Gram-Schmidt orthogonalization, and the simplex algorithm.


 2. YFUNX - a program for graphing and analyzing functions in rectangular
    form, Y=F(X).  Includes coordinate trace and tangent/normal line modes,
    zooming in and out, scalable axes, graph parameter variable. Numerical
    integration features standard algorithms plus Gaussian Quadrature and the
    Romberg algorithm.  Animation features include plane areas, plane arc
    length, 3D volumes (disks & cylindrical shells) and 3D surface areas.
    Newton's method and the method of successive bisections are for solving
    F(X)=0.  Automatically finds maximum/minimum extrema.  All algorithms
    may be demonstrated in either graphics or text modes.


 3. POLAR - a program for graphing and analyzing functions in polar form,
    R=F(@) or R^2=F(@).  Similar to YFUNX, includes coordinate trace and
    tangent/normal line modes, zooming in and out, scalable axes, and a graph
    parameter variable.  Numerical integration for polar areas and arc length.
    Automatically finds maximum/minimum extrema over any section of a curve.


 4. PARAM - a program for graphing and analyzing functions in parametric form,
    X=F(T) and Y=G(T).  Similar to YFUNX, includes coordinate trace and
    tangent/normal line modes, zooming in and out, scalable axes, and a graph
    parameter variable.  Numerical integration calculates plane areas and arc
    length.  Automatically finds maximum/minimum extrema over any section of
    a curve.


 5. POLPM - a program for graphing and analyzing functions in polar
    coordinates, but that have been parametrized, say R=F(T) and @=G(T).
    Similar to the POLAR and PARAM programs, this program includes coordinate
    trace and tangent/normal line modes, zooming in and out, scalable axes,
    and a graph parameter variable.  Numerical integration for plane areas
    and arc length.  Automatically finds maximum/minimum extrema over any
    section of a curve.


 6. DIFEQ - a program related to 1st order differential equations.  Includes
    graphing the direction field and solves initial value problems using
    Euler methods and a 4th order Runge-Kutta method.  Includes coordinate
    trace mode, zooming in and out, and scalable axes.  Algorithms may be
    demonstrated in either graphics or text modes.


 7. CURVE3D - a program for making 3D graphs of curves given in the parametric
    form X=f(t), Y=g(t), and Z=h(t).  The resulting curve may be viewed from
    any position, and the drawing is a true-perspective 3D picture.


 8. SURF3D - a program to graph 3-dimensional surfaces of the form Z=F(X,Y).
    The resulting surface may be viewed from any position, and the drawing is
    a true-perspective 3D picture.  The surface may be displayed using lines
    of constant x, or constant y, or a fishnet.  Included is a hidden line
    algorithm for more realistic pictures.


 9. CFIT - a program which performs curve fits to data.  Includes linear
    regression for linear, exponential, logarithmic, and power functions.
    Graphs scatter diagrams and the fitted function curves and performs
    a statistical analysis, including an automatic best fit selection.  Data
    may be saved to or read from disk files.


10. GALTON - simulates coin tossing experiments related to probabilities and
    demonstrates graphically how the binomial distribution is related to the
    standard normal Gaussian bell-shaped curve.  Also compares stack counts
    with the numbers generated in Pascal's Triangle.  Either coins or
    ping-pong balls may be used in simulated experiments.  Variable number of
    rows of pegs, variable number of objects, variable left-right probability
    for generating skewed distributions.  Includes a single-step mode under
    full user control.


11. BUFFON - simulates needle dropping experiments related to probabilities
    used to approximate the number Pi.  Needles are randomly dropped on a
    grid of equally spaced parallel lines.  The length of each needle is 1/2
    that of the distance between the lines.  After dropping a large number
    of needles a count is made of the needles which cross a line.  Most
    needles do not touch or cross any line, but the ratio of the total
    number of needles dropped divided by the number of needles which cross
    a line approximates Pi.


12. PROPC - a symbolic logic program that calculates truth tables, analyzes
    tautologies, parses infix formulas and displays their Polish notation
    form, and generates Karnaugh maps from either tables or formulas.


13. RPNDEMO - a program which simulates how a calculator with RPN logic works.
    This program includes its own language and is similar in power to the
    HP-41 calculator.  Programs may be animated to show the internal workings
    of the machine.  Can also be used to teach assembly language concepts.


14. CALC - a reverse Polish logic calculator that operates on 5 data types.
    Included are real and complex numbers, fractions, binary integers and
    polynomials.  Special features include factoring integers and
    polynomials, analyzing repeating decimals and working with continued
    fractions.


15. LOAN - a finance program that handles the two standard cases of compound
    interest.  Uses the 5 standard financial variables n i PV PMT FV found
    on most financial calculators.  Can determine payment schedules for
    loans and annuities and can print amortization schedules for loans and
    interest earning schedules for lump sums and periodic payments.


16. FCARD - simple flash card type of program that can be used to memorize
    any simple series of facts, with one item per line of text.  Items can
    be presented in a random order with timing if desired.


17. THANOI - a game known as the Towers of Hanoi.  The game solution uses
    a recursive algorithm and the purpose of the program is to demonstrate
    the validity and simplicity of a recursive solution to a complex problem
    that would otherwise overwhelm a normal human being.


18. TRIANGLE - a simple program which solves triangle problems in which one
    is given 3 facts about a triangle and must solve for all the remaining
    parts.  Handles all 19 cases of triangle inputs and includes the Law of
    Cosines and the ambiguous case of the Law of Sines.  Can automatically
    determine when two valid triangle solutions exist.  Draws all triangle
    solutions to scale on a graphics screen and computes the perimeter and
    and the area in addition to finding and labeling all the sides and angles.


19. EXPMCON - a utility type of program that works with the above MATRIX
    program and the commercial scientific word processor called EXP.  This
    program converts MATRIX files from an ASCII format to the EXP format.


20. BMPLOT - a utility program that makes high resolution monochrome bitmap
    function plots, identical to the kinds of graphs made by the programs
    YFUNX, POLAR, PARAM, and POLPM.  The bitmaps may be read into other
    programs such as paint or drawing or desktop publishing programs which
    can be used to add labels and titles.  The monochrome bitmaps may be of
    any size or resolution so the output is compatible with virtually every
    printer and/or graphics environment.  The file formats supported include
    PCX, TIFF, and BMP.  The HP-GL/2 plotter language is an optional output
    to either a file or any HP-compatible plotter or PCL 5 LaserJet compatible
    printer.


21. XPRES - a program which computes integers with up to 20,000 digits per
    integer.  This RPN calculator is useful for computing exact values of
    factorials, permutations, combinations, and powers of integers.  For
    example, you can compute the exact value of numbers like 1000! or the
    exact value of 2 raised to the 5,000th power.  Integers may be saved to
    or read from ASCII text disk files.


22. TURING - a program which simulates the operation of a Turing Machine
    which is an abstract model of a primitive digital computer.  In fact,
    the model is fundamental to all digital (logical) computations.  Such a
    machine was conceived by the British mathematician Alan Turing in 1935,
    long before digital computers became established.  Turing also worked on
    machines to break codes used by the German Enigma spy machine in World
    War II.  Three sample demonstration programs are included.


For more information about any of these programs feel free to contact the
author.

   John Kennedy                   Voice Phone/Messages any time of day or
   Mathematics Department         night: (310) 450-5150  Extension 9721.
   Santa Monica College
   1900 Pico Blvd.                Internet E-Mail: jkennedy@smc.edu
   Santa Monica, CA  90405
   U.S.A.                         CompuServe User ID: 71514,751


