Both a car and a bicycle provide an example
of a machine. There is a difference between
them: a car has a component, called "engine",
which accepts non-kinetic energy from a not
animated source, i.e. not from humans nor from
animals, and it turns it into kinetic energy.

Now you understand the diff (Tom Wachtel's
abbr of "difference") between a machine and
an engine, at least in the regular language.

Another example of a machine: typewriter.

********

Now let's switch to mathematics and
the Information Theory (Computer Science).

Let's start with an example of a finite
automaton, called ADD1.

It has its input alphabet:

IA := {0 1}

output alphabet:

OA := {0 1}

and the set of internal states:

S := {0 1}

This automaton ADD1, like any automaton,
has also two functions:

out : IA x S -- OA

trn : IA x S -- S

defined as follows:

out(0 0) := 0, out(0 1) := 1
out(1 0) := 1, out(1 1) := 0

and

trn(0 0) := 0, trn(0 1) := 0
trn(1 0) := 0, trn(1 1) := 1

Automaton ADD1 adds 1 to the non-negative
integers as follows. Say, you want to add 1
to decimal 11, which is binary x = 01011 -- yes,
ADD1 works in binary. This automaton always
starts with the internal state 1. You feed it the
least significant digit of x, i.e. 1. Then the least
significant digit of the answer is:

out(1 1) = 0 == guys, remember this

and the new internal state is:

trn(1 1) = 1

The next digit of x is 1 again. Thus the next
output digit is:

out(1 1) = 0 == guys, remember this

and the new internal state is:

trn(1 1) = 1

The next digit of x is 0. Thus the next
output digit is:

out(0 1) = 1 == guys, remember this

and the new internal state is:

trn(0 1) = 0

The next digit of x is 1. Thus the next
output digit is:

out(1 0) = 1 == guys, remember this

and the new internal state is:

trn(1 0) = 0

The next digit of x is 0. Thus the next
output digit is:

out(0 0) = 0 == guys, remember this

and we don't care about the new internal
state, since the calculation is over. Just
collect the five outputs, which you ("guys")
were supposed to remember (look up):

01100

We see that the answer is 12.

***********

Now I'll provide one of the possible definitions
of a Turing Machine (TM).

A Turing Machine consists of two
components: a finite automaton,
and a tape, which is like a train track
(a tape divided into a lane of squares).
It is either potentially infinite (finite but you
add squares as needed) or it's simply
infinite. Mathematically, the tape is the
set of integers: Z := { ... -2 -1 0 1 2 3 ... }.

The automaton, as we know already,
has its input alphabet IA, output
alphabet OA, the set of internal states S,
and functions out and trn. In the case
of TM, the two alphabets are the same:

A := IA = OA

We also assume that star * is one of
the elements (characters) of the input
alphabet IA, and that S has at least four
different states i s.

Let us also introduce an auxiliary position
variable, called pos, which attains integer
values. Variable pos assists out bookkeeping
-- it is not a part of the Turing Machine
(unless you insist -- the TM does not care :-).

Turing Machine works as follows.
At the beginning of a computation
the tape is filled up with the input,
i.e. we start with a function:

f : Z -- A

For classical considerations, it is assumed
that the input is finite, meaning that f(n) = *
for all n but a finite number of cases (i.e.
there is a natural number M such that
f(n) = * when |n| M).

Also, at the beginning we set pos :=0
and the initial state is set to i.

That's the situation at the initial
moment t=0.

Now, with the time passing,

t = 0 1 2 3 4 5 6 ...

the tape gets rewritten, each time at the
position pos, and the internal automaton
state gets changing (which we know already,
because that's a part of being an automaton).
The time parameter t is hidden in the notation,
in order to avoid clutter, except that we write

g(t n)

for the value of the tape at position n,
at the time t. Thus

g(0 n) := f(n)

At a moment t, TM works as follows:

if the internal state is then the value pos
is decreased by 1 -- imagine the automaton
as a small, squarish wagon, which moves
the length of the cell (= its own length) to
the left, on the tape (its track);

if the internal state is then pos increases
by 1 (the wagon moves one cell to the right);

if the internal state is or then nothing
else happens, only pos-- or pos++ respectively,
and the time becomes t+1; in particular:

g(t+1 n) = g(t n) for every cell n \in Z.

If the internal state w differs from and
from s, then the new value at pos becomes:

g(t+1 pos) = out(g(t pos) w)

and the new internal state (at the time t+1)
is:

w' = trn(g(t pos) w),

while the position stays the same, i.e.

pos' = pos

Also,

g(t+1, n) = g(t n) for every n =/= pos

i.e. only the cell at position pos can be
rewritten.

If the internal state at the moment t is s,
called the "stop state", than the calculation
is finished, it's over. The output result is the
writing on the tape, i.e. it's the function

h : Z -- A

given by:

h(n) := g(t n) for every n \in Z.

Now you know what a TM is -- it is a machine
which for every input function f attempts to
compute the respective output function h.
Sometimes it succeeds, when state s is reached,
and sometimes the poor creature computes
forever.

***

Now you know that Turing Machine is not any
"Turing Engine". Nobody, with even a bare minimum
of culture, writes in the described context anything
as ucki as "Turing Engine" or "TE". Possibly the early
material gadgets proposed by Turing were called
"engines", but it is irrelevant for the Turing Machines.

***

As has been already noted on rgcm, some of the Turing
Machines are universal, and other are not (in a sense, the
great majority of them are, but never mind). Universality
of a particular Turing Machine U means, that it can
simulate any other Turing Machine T as follows:

(for the sake of simplicity, let's assume that both
machines use the same alphabet A -- this is
a trivial issue)

A string over A is associated with T (different
strings for different machines T; it can be done
in an algorithmic way).

For each input f : Z -- A, such that f(n) := *
for every n 0, we place the associated string
on the tape, to the left of 0, thus replacing f with
a certain f'.

Now we apply U to f'. We will get the same
output result as in the case of applying T to f.

Thus instead of T we may use U. When U can
do it for every Turing Machine T then U is
universal.

********************

Regards,

Wlod

Wlodzimierz Holsztynski (Wlod) wrote:

Both a car and a bicycle provide an example
of a machine. There is a difference between
them: a car has a component, called "engine",
which accepts non-kinetic energy from a not
animated source, i.e. not from humans nor from
animals, and it turns it into kinetic energy.

Now you understand the diff (Tom Wachtel's
abbr of "difference") between a machine and
an engine, at least in the regular language.

Another example of a machine: typewriter.

********

Observe that different machines may use the
same engine, and the same machine may
use different engines (e.g. stronger or weaker).
E.g. you could have a steam engine in your
backyard, helping you with washing or whatever
(you could use it also to generate electricity).

This is characteristic of the progress
along the mass production and proliferation
of different machines. Instead of standards
machines, one goes one step further toward
standard components, in particular standard
engines. Thus now an engine has a stand alone
value (that's why one may confuse it with a machine).
You may buy and sell engines by themselves.
Nevertheless, engine by itself is useless. You still
need to connect it to the rest of a machine to get
a useful gadget.

In chess we do not have machines in the classical
sense, except for the robots which actually
move the pieces. Of course I would design a cheap
board operating on light instead of physical
pieces. You'd have the pieces as the images
on the squares. They would be created ("moved")
by the "machine".

Anyway, in the chess situation which is standard
today, the role of a machine is played by the
WHOLE chess program. And the program
component which generates moves is called a
chess engine. Once again, thanks to the standardization,
you may connect the same engine to different
user interfaces; and vice versa, different
chess engines to the same interface.

You may apply similar considerations to the stand
alone chess units.

Regards,

Wlod