👂 🎴 🕸️
<
div
style
=
„
font
-
size
:
60px
;
“
><
i
>“
We
may
say
that
thinking
is
essentially
the
activity
of
operating
with
signs
.”
i
>
div
><
br
/><
div
style
=
„
font
-
size
:
32px
;
“
>—
Ludwig
Wittgenstein
''
<
i
>
The
Blue
Book
i
>
(
1933
–
1934
)''
p
. 
6
of
the
commonly
used
edition
div
>
<
blockquote
class
='
fragment
'>
It
is
misleading
then
to
talk
of
thinking
as
of
a
“
mental
activity
”.
We
may
say
that
thinking
is
essentially
the
activity
of
operating
with
signs
.
This
activity
is
performed
by
the
<
strong
>
hand
strong
>''
when
we
think
by
writing
;
by
the
<
strong
>
mouth
and
larynx
strong
>''
when
we
think
by
speaking
;
and
''
if
we
think
by
imagining
signs
or
pictures
I
can
give
you
no
agent
that
thinks
.
blockquote
><
blockquote
class
='
fragment
'>
If
then
you
say
that
in
such
cases
the
mind
thinks
''
I
would
only
draw
your
attention
to
the
fact
that
you
are
using
a
metaphor
''
that
here
the
mind
is
an
agent
in
a
different
sense
from
that
in
which
the
hand
can
be
said
to
be
the
agent
in
writing
.
blockquote
><
blockquote
class
='
fragment
'>
If
again
we
talk
about
the
locality
where
thinking
takes
place
we
have
a
right
to
say
that
this
locality
is
<
strong
>
the
paper
on
which
we
write
strong
>;
or
the
mouth
which
speaks
.
blockquote
><
p
class
='
fragment
'>—
Ludwig
Wittgenstein
''
<
i
>
The
Blue
Book
i
>
(
1933
–
1934
)
p
><
p
class
='
fragment
'>
Keep
this
in
mind
today
:
in
our
exercises
''
<
strong
>
whose
hand
does
the
thinking
''
and
where
is
the
carry
kept
?
strong
>
p
>
<
p
class
='
fragment
'>
Question
of
the
day
:
<
strong
>
why
does
counting
in
binary
work
—
and
what
is
a
machine
doing
when
it
counts
?
strong
>
p
><
p
class
='
fragment
'>
You
already
know
<
em
>
how
em
>:
fold
every
<
code
>
1
code
>
down
''
carry
to
the
left
''
raise
the
first
<
code
>
0
code
>.
You
did
it
with
a
hand
and
with
a
Turing
machine
.
p
><
p
class
='
fragment
'>
Today
we
ask
<
em
>
why
em
>.
One
algorithm
—
<
strong
>
add
1
strong
>
—
seen
in
three
languages
:
<
strong
>
Logic
strong
>
(
Boole
)''
<
strong
>
Wire
strong
>
(
Shannon
)''
<
strong
>
Machine
strong
>
(
Turing
).
p
><
p
class
='
fragment
'>
Bring
a
thumb
.
Bring
a
partner
.
Both
will
be
needed
.
p
>
<
p
class
='
fragment
'><
strong
>
In
pairs
.
strong
>
One
of
you
counts
in
binary
on
one
hand
''
from
0
up
to
11
.
The
other
watches
and
says
“
stop
!”
at
the
first
mistake
.
p
><
p
class
='
fragment
'>
Swap
.
Then
count
from
<
code
>
0
1
1
1
code
>
(
7
)
—
what
happens
''
and
<
strong
>
who
remembers
the
carry
strong
>
while
the
fingers
fold
down
?
p
><
p
class
='
fragment
'>
Keep
that
question
.
The
rest
of
the
session
is
its
answer
.
p
>
<
p
class
='
fragment
'>
1854
:
George
Boole
''
professor
at
Queen
’
s
College
Cork
''
publishes
<
em
>
An
Investigation
of
the
Laws
of
Thought
em
>.
p
><
p
class
='
fragment
'>
His
claim
:
reasoning
itself
can
be
calculated
—
like
algebra
—
if
every
statement
is
reduced
to
just
<
strong
>
two
values
strong
>:
<
code
>
1
code
>
(
true
)
and
<
code
>
0
code
>
(
false
).
p
><
p
class
='
fragment
'>
Leibniz
’
s
old
dream
(<
em
>
calculemus
!
em
>)''
now
with
rules
.
p
><
p
class
='
fragment
'>
A
thumb
is
a
perfect
Boolean
variable
:
<
strong
>
up
=
1
''
down
=
0
strong
>.
p
>
<
p
class
='
fragment
'><
strong
>
NOT
strong
>
flips
:
<
code
>
NOT
1
=
0
code
>''
<
code
>
NOT
0
=
1
code
>.
p
><
p
class
='
fragment
'><
strong
>
AND
strong
>:
true
only
if
<
em
>
both
em
>
are
true
(
both
thumbs
up
).
p
><
p
class
='
fragment
'><
strong
>
OR
strong
>:
true
if
<
em
>
at
least
one
em
>
is
true
.
p
><
div
class
='
fragment
'><
table
><
tr
><
th
>
a
th
><
th
>
b
th
><
th
>
a
AND
b
th
><
th
>
a
OR
b
th
>
tr
><
tr
><
td
>
0
td
><
td
>
0
td
><
td
>
0
td
><
td
>
0
td
>
tr
><
tr
><
td
>
0
td
><
td
>
1
td
><
td
>
0
td
><
td
>
1
td
>
tr
><
tr
><
td
>
1
td
><
td
>
0
td
><
td
>
0
td
><
td
>
1
td
>
tr
><
tr
><
td
>
1
td
><
td
>
1
td
><
td
>
1
td
><
td
>
1
td
>
tr
>
table
>
div
>
<
p
class
='
fragment
'><
strong
>
XOR
strong
>
(
exclusive
or
):
true
if
the
two
inputs
<
em
>
differ
em
>
—
one
thumb
up
''
<
em
>
not
both
em
>.
p
><
div
class
='
fragment
'><
table
><
tr
><
th
>
a
th
><
th
>
b
th
><
th
>
a
XOR
b
th
>
tr
><
tr
><
td
>
0
td
><
td
>
0
td
><
td
>
0
td
>
tr
><
tr
><
td
>
0
td
><
td
>
1
td
><
td
>
1
td
>
tr
><
tr
><
td
>
1
td
><
td
>
0
td
><
td
>
1
td
>
tr
><
tr
><
td
>
1
td
><
td
>
1
td
><
td
>
0
td
>
tr
>
table
>
div
><
p
class
='
fragment
'>
Note
the
last
row
:
<
code
>
1
XOR
1
=
0
code
>.
Remember
it
—
it
will
carry
the
whole
session
.
p
>
<
p
class
='
fragment
'>
In
everyday
speech
<
em
>“
or
”
em
>
is
ambiguous
.
Logic
must
not
be
.
p
><
div
class
='
fragment
'><
table
><
tr
><
th
>
sentence
th
><
th
>
reading
th
>
tr
><
tr
><
td
>“
Soup
<
strong
>
or
strong
>
salad
?”
(
the
menu
)
td
><
td
><
strong
>
XOR
strong
>
—
not
both
(
unless
you
pay
extra
)
td
>
tr
><
tr
><
td
>“
Smoke
<
strong
>
or
strong
>
heat
sets
off
the
alarm
.”
td
><
td
><
strong
>
OR
strong
>
—
and
certainly
if
both
td
>
tr
><
tr
><
td
>“
Are
you
leaving
today
<
strong
>
or
strong
>
tomorrow
?”
td
><
td
><
strong
>
XOR
strong
>
—
you
cannot
leave
twice
td
>
tr
><
tr
><
td
>“
Bring
a
note
from
your
doctor
<
strong
>
or
strong
>
your
parents
.”
td
><
td
><
strong
>
OR
strong
>
—
two
notes
are
no
problem
td
>
tr
><
tr
><
td
>“
Milk
<
strong
>
or
strong
>
sugar
in
your
coffee
?”
td
><
td
><
em
>
unclear
!
em
>
Both
''
surely
?
td
>
tr
>
table
>
div
><
p
class
='
fragment
'>
Latin
had
two
words
for
it
:
<
strong
>
vel
strong
>
(
inclusive
:
“
one
or
the
other
or
both
”)
and
<
strong
>
aut
strong
>
(
exclusive
:
<
em
>
aut
Caesar
aut
nihil
em
>).
English
has
just
one
—
and
relies
on
you
to
guess
.
p
>
<
p
class
='
fragment
'>
Lawyers
and
programmers
cannot
afford
to
guess
:
p
><
p
class
='
fragment
'><
strong
>
Contracts
strong
>
write
<
em
>“
and
/
or
”
em
>
(
inclusive
)
and
<
em
>“
either
…
or
…''
but
not
both
”
em
>
(
exclusive
)''
because
courts
have
argued
over
a
bare
“
or
”.
p
><
p
class
='
fragment
'><
strong
>
Programming
languages
strong
>
give
the
two
meanings
different
symbols
:
<
code
>
a
||
b
code
>
(
or
)
and
<
code
>
a
^
b
code
>
(
xor
).
p
><
p
class
='
fragment
'><
strong
>
Linguists
strong
>
note
that
the
exclusive
reading
is
often
not
part
of
the
word
at
all
:
we
<
em
>
infer
em
>
“
not
both
”
(“
if
she
could
say
‘
and
’''
she
would
have
”).
p
><
p
class
='
fragment
'>
This
is
Boole
’
s
move
:
<
strong
>
give
each
meaning
its
own
symbol
strong
>''
and
the
ambiguity
disappears
—
for
a
machine
''
there
is
no
“
you
know
what
I
mean
”.
p
>
<
p
class
='
fragment
'><
strong
>
In
pairs
.
strong
>
Take
turns
reading
these
sentences
aloud
;
your
partner
decides
<
code
>
OR
code
>
or
<
code
>
XOR
code
>
and
<
em
>
defends
em
>
the
choice
with
one
sentence
about
the
situation
:
p
><
p
class
='
fragment
'>•
“
You
can
pay
by
card
or
cash
.”
•
“
Students
or
staff
may
enter
.”
•
“
A
fine
of
fifty
euros
or
three
days
in
jail
.”
•
“
She
speaks
German
or
French
.”
•
“
Take
the
lift
or
the
stairs
.”
p
><
p
class
='
fragment
'>
Which
ones
did
you
disagree
on
?
Notice
<
strong
>
what
you
used
to
decide
strong
>:
not
the
word
“
or
”''
but
knowledge
of
the
world
.
p
><
p
class
='
fragment
'>
Now
write
<
strong
>
one
real
sentence
of
your
own
strong
>
in
which
the
two
readings
lead
to
different
consequences
—
a
rule
''
a
promise
''
a
threat
.
Swap
''
and
rewrite
your
partner
’
s
so
it
can
only
be
read
one
way
.
p
>
<
p
><
strong
>
In
pairs
.
strong
>
Each
of
you
hides
a
thumb
behind
your
back
(
up
 = 
1
''
down
 = 
0
)
and
shows
it
on
three
.
The
<
strong
>
teacher
calls
the
gate
strong
>:
p
><
table
><
tr
><
th
>
a
th
><
th
>
b
th
><
th
>
AND
th
><
th
>
OR
th
><
th
>
XOR
th
><
th
>
NAND
th
>
tr
><
tr
><
td
>
0
td
><
td
>
0
td
><
td
>
0
td
><
td
>
0
td
><
td
>
0
td
><
td
>
1
td
>
tr
><
tr
><
td
>
0
td
><
td
>
1
td
><
td
>
0
td
><
td
>
1
td
><
td
>
1
td
><
td
>
1
td
>
tr
><
tr
><
td
>
1
td
><
td
>
0
td
><
td
>
0
td
><
td
>
1
td
><
td
>
1
td
><
td
>
1
td
>
tr
><
tr
><
td
>
1
td
><
td
>
1
td
><
td
>
1
td
><
td
>
1
td
><
td
>
0
td
><
td
>
0
td
>
tr
>
table
><
p
class
='
fragment
'>
Show
thumbs
.
As
a
pair
''
say
the
output
<
em
>
before
em
>
checking
the
table
—
then
check
it
.
p
><
p
class
='
fragment
'><
strong
>
Reverse
round
:
strong
>
the
teacher
says
gate
<
em
>
and
em
>
output
(“
XOR
gives
1
”);
you
show
a
pair
of
thumbs
that
produces
it
.
Is
the
answer
always
unique
?
For
which
calls
is
there
only
one
?
p
>
<
p
class
='
fragment
'>
Boole
discovered
that
these
operations
obey
<
strong
>
laws
strong
>''
like
numbers
do
:
p
><
div
class
='
fragment
'><
table
><
tr
><
th
>
law
th
><
th
>
in
words
th
>
tr
><
tr
><
td
><
code
>
a
AND
1
=
a
code
>
td
><
td
>
AND
with
1
changes
nothing
td
>
tr
><
tr
><
td
><
code
>
a
AND
0
=
0
code
>
td
><
td
>
AND
with
0
kills
everything
td
>
tr
><
tr
><
td
><
code
>
a
OR
0
=
a
code
>
td
><
td
>
OR
with
0
changes
nothing
td
>
tr
><
tr
><
td
><
code
>
a
AND
a
=
a
code
>
td
><
td
>
repeating
yourself
adds
nothing
td
>
tr
><
tr
><
td
><
code
>
a
AND
(
NOT
a
)
=
0
code
>
td
><
td
>
nothing
is
both
true
and
false
td
>
tr
><
tr
><
td
><
code
>
NOT
(
a
AND
b
)
=
(
NOT
a
)
OR
(
NOT
b
)
code
>
td
><
td
>
De
Morgan
(
Boole
’
s
contemporary
)
td
>
tr
>
table
>
div
><
p
class
='
fragment
'>
Laws
like
these
let
you
<
strong
>
simplify
circuits
and
programs
by
pure
calculation
strong
>
—
no
thumbs
needed
.
p
>
<
p
class
='
fragment
'>
Why
is
it
called
<
em
>
algebra
em
>?
Because
the
operations
behave
like
arithmetic
on
<
code
>
0
code
>
and
<
code
>
1
code
>:
p
><
p
class
='
fragment
'><
strong
>
AND
is
multiplication
strong
>:
<
code
>
a
·
b
code
>.
<
strong
>
NOT
strong
>
is
<
code
>
1
−
a
code
>.
p
><
p
class
='
fragment
'><
strong
>
XOR
is
addition
strong
>
—
but
one
that
forgets
the
carry
(
addition
modulo
2
):
<
code
>
1
+
1
=
0
code
>.
p
><
p
class
='
fragment
'>
Add
two
single
bits
properly
and
look
at
the
two
digits
of
the
answer
:
p
><
div
class
='
fragment
'><
table
><
tr
><
th
>
a
+
b
th
><
th
>=
carry
''
sum
th
><
th
>
carry
th
><
th
>
sum
th
>
tr
><
tr
><
td
>
0
+
0
td
><
td
>
00
td
><
td
>
0
td
><
td
>
0
td
>
tr
><
tr
><
td
>
0
+
1
td
><
td
>
01
td
><
td
>
0
td
><
td
>
1
td
>
tr
><
tr
><
td
>
1
+
0
td
><
td
>
01
td
><
td
>
0
td
><
td
>
1
td
>
tr
><
tr
><
td
>
1
+
1
td
><
td
>
10
td
><
td
>
1
td
><
td
>
0
td
>
tr
>
table
>
div
><
p
class
='
fragment
'><
strong
>
The
sum
digit
is
XOR
.
The
carry
digit
is
AND
.
strong
>
Arithmetic
<
em
>
is
em
>
logic
.
p
>
<
p
class
='
fragment
'>
1937
:
Claude
Shannon
''
21
''
writes
his
master
’
s
thesis
at
MIT
:
<
em
>
A
Symbolic
Analysis
of
Relay
and
Switching
Circuits
em
>.
p
><
p
class
='
fragment
'>
His
discovery
:
electrical
switches
<
strong
>
obey
Boole
’
s
algebra
strong
>.
Two
switches
in
<
strong
>
series
strong
>
=
<
code
>
AND
code
>
(
current
flows
only
if
both
are
closed
).
In
<
strong
>
parallel
strong
>
=
<
code
>
OR
code
>.
A
relay
that
opens
when
energised
=
<
code
>
NOT
code
>.
p
><
p
class
='
fragment
'>
So
any
Boolean
formula
can
be
<
em
>
built
out
of
hardware
em
>
—
and
any
circuit
can
be
<
em
>
checked
by
algebra
em
>.
p
><
p
class
='
fragment
'>
The
little
symbols
for
such
components
are
called
<
strong
>
gates
strong
>:
p
>
<
p
class
='
fragment
'>
One
gate
is
enough
to
build
all
the
others
:
<
strong
>
NAND
strong
>
(<
code
>
NOT
(
a
AND
b
)
code
>)''
Sheffer
1913
.
p
><
p
class
='
fragment
'><
code
>
NOT
a
=
a
NAND
a
code
>
p
><
p
class
='
fragment
'><
code
>
a
AND
b
=
NOT
(
a
NAND
b
)
code
>
—
i
.
e
.
a
NAND
followed
by
a
NAND
with
itself
.
p
><
p
class
='
fragment
'><
code
>
a
OR
b
=
(
NOT
a
)
NAND
(
NOT
b
)
code
>
—
De
Morgan
at
work
.
p
><
p
class
='
fragment
'>
A
NAND
gate
in
a
chip
costs
four
transistors
.
Billions
of
them
''
wired
by
algebra
''
are
every
computer
you
know
.
p
>
<
p
class
='
fragment
'><
strong
>
In
pairs
.
strong
>
One
of
you
is
the
<
strong
>
architect
strong
>''
the
other
the
<
strong
>
inspector
strong
>.
p
><
p
class
='
fragment
'>
Architect
:
on
paper
''
draw
<
code
>
XOR
code
>
using
only
<
code
>
NAND
code
>
gates
(
hint
:
four
NANDs
suffice
;
one
of
them
is
shared
).
p
><
p
class
='
fragment
'>
Inspector
:
feed
all
four
input
pairs
through
the
drawing
with
your
thumbs
—
one
gate
at
a
time
''
<
em
>
out
loud
em
>.
Compare
with
the
XOR
table
.
p
><
p
class
='
fragment
'>
If
a
row
fails
''
find
which
gate
lied
.
Then
swap
roles
and
build
<
code
>
OR
code
>.
p
>
<
p
class
='
fragment
'>
Put
the
two
observations
together
:
to
add
two
bits
<
code
>
b
code
>
and
<
code
>
c
code
>
you
need
exactly
two
gates
.
p
><
p
class
='
fragment
'><
code
>
sum
=
b
XOR
c
code
>
 
<
code
>
carry
=
b
AND
c
code
>
p
><
p
class
='
fragment
'>
This
tiny
circuit
is
called
the
<
strong
>
half
-
adder
strong
>.
All
arithmetic
in
your
phone
is
built
from
it
and
its
relatives
.
p
>
<
p
class
='
fragment
'>
Our
algorithm
<
em
>
increment
em
>
is
not
a
special
case
:
to
add
1
''
put
a
carry
of
<
strong
>
1
strong
>
into
the
lowest
position
''
then
let
every
position
run
a
half
-
adder
.
p
><
p
class
='
fragment
'><
code
>
c
<
sub
>
0
sub
>
=
1
code
>
(
that
is
the
“+
1
”)
p
><
p
class
='
fragment
'>
for
every
bit
<
code
>
b
<
sub
>
i
sub
>
code
>''
from
right
to
left
:<
br
/><
code
>
out
<
sub
>
i
sub
>
=
b
<
sub
>
i
sub
>
XOR
c
<
sub
>
i
sub
>
code
><
br
/><
code
>
c
<
sub
>
i
+
1
sub
>
=
b
<
sub
>
i
sub
>
AND
c
<
sub
>
i
sub
>
code
>
p
><
p
class
='
fragment
'>
The
lowest
bit
has
it
easiest
:
<
code
>
b
XOR
1
=
NOT
b
code
>
—
it
always
flips
.
Every
higher
bit
flips
only
if
the
carry
reached
it
—
and
the
carry
survives
only
through
a
chain
of
<
code
>
1
code
>
s
.
p
>
<
p
class
='
fragment
'><
strong
>
In
pairs
.
strong
>
Four
numbers
:
<
code
>
0101
code
>''
<
code
>
0111
code
>''
<
code
>
1011
code
>''
<
code
>
1111
code
>.
Increment
each
<
em
>
using
only
the
two
formulas
em
>
—
no
counting
.
p
><
p
class
='
fragment
'>
Split
the
labour
like
a
circuit
:
one
of
you
computes
every
<
code
>
XOR
code
>''
the
other
every
<
code
>
AND
code
>
and
keeps
the
carry
.
Fill
in
a
table
with
columns
<
code
>
b
code
>''
<
code
>
c
code
>''
<
code
>
out
code
>''
<
code
>
c
′
code
>
for
each
position
''
right
to
left
.
p
><
p
class
='
fragment
'>
Check
against
finger
counting
.
Which
number
made
the
carry
travel
farthest
?
What
is
<
code
>
c
code
>
after
the
last
position
of
<
code
>
1111
code
>?
p
>
<
p
class
='
fragment
'>
Build
the
circuit
literally
:
one
half
-
adder
per
bit
''
the
carry
wired
from
each
to
its
left
neighbour
.
p
><
p
class
='
fragment
'>
It
is
called
a
<
strong
>
ripple
-
carry
strong
>
circuit
:
change
the
input
and
the
carry
<
em
>
ripples
em
>
through
the
chain
like
a
row
of
dominoes
.
p
><
p
class
='
fragment
'>
A
64
-
bit
number
needs
64
adders
.
The
algorithm
is
spread
out
<
strong
>
in
space
strong
>.
p
>
<
p
class
='
fragment
'>
Now
the
other
idea
.
Do
not
build
five
adders
.
Build
<
strong
>
one
strong
>
and
walk
it
along
the
number
.
p
><
p
class
='
fragment
'>
Each
step
it
reads
one
bit
from
a
<
strong
>
tape
strong
>''
computes
<
code
>
XOR
code
>
and
<
code
>
AND
code
>''
writes
the
result
''
and
moves
one
cell
to
the
left
.
p
><
p
class
='
fragment
'>
But
then
the
carry
from
this
step
must
<
em
>
wait
em
>
for
the
next
one
.
Something
must
<
strong
>
remember
strong
>
it
.
That
memory
is
the
machine
’
s
<
strong
>
state
strong
>.
p
>
<
p
class
='
fragment
'>
Look
again
at
the
rule
table
of
our
Turing
machine
—
the
one
from
the
Alan
session
—
and
write
the
state
as
a
bit
:
<
code
>
CARRY
=
1
code
>''
<
code
>
HALT
=
0
code
>.
p
><
div
class
='
fragment
'><
table
><
tr
><
th
>
state
c
th
><
th
>
reads
b
th
><
th
>
writes
th
><
th
>
next
state
th
><
th
>
move
th
>
tr
><
tr
><
td
>
1
(
CARRY
)
td
><
td
>
0
td
><
td
>
1
td
><
td
>
0
(
HALT
)
td
><
td
>
left
td
>
tr
><
tr
><
td
>
1
(
CARRY
)
td
><
td
>
1
td
><
td
>
0
td
><
td
>
1
(
CARRY
)
td
><
td
>
left
td
>
tr
><
tr
><
td
>
0
(
HALT
)
td
><
td
>
0
td
><
td
>
0
td
><
td
>
0
td
><
td
>—
td
>
tr
><
tr
><
td
>
0
(
HALT
)
td
><
td
>
1
td
><
td
>
1
td
><
td
>
0
td
><
td
>—
td
>
tr
>
table
>
div
><
p
class
='
fragment
'><
strong
>
Writes
strong
>
=
<
code
>
b
XOR
c
code
>.
<
strong
>
Next
state
strong
>
=
<
code
>
b
AND
c
code
>.
The
rule
table
of
the
machine
<
em
>
is
em
>
the
half
-
adder
’
s
truth
table
.
p
><
p
class
='
fragment
'>
A
Turing
machine
is
a
half
-
adder
with
a
memory
and
a
moving
head
.
<
strong
>
The
carry
is
the
thumb
of
the
other
hand
.
strong
>
p
>
<
p
class
='
fragment
'><
strong
>
Alone
''
then
compare
.
strong
>
<
em
>
Right
hand
em
>
=
tape
(
thumb
is
the
lowest
bit
).
<
em
>
Left
thumb
em
>
=
the
state
<
code
>
c
code
>.
p
><
p
class
='
fragment
'>
Raise
your
left
thumb
:
you
are
adding
1
.
Now
walk
along
the
right
hand
''
thumb
to
little
finger
.
At
every
finger
say
out
loud
:
<
strong
>“
out
=
b
XOR
c
”
strong
>
(
set
the
finger
to
that
value
)
and
<
strong
>“
c
=
b
AND
c
”
strong
>
(
set
your
left
thumb
to
that
).
p
><
p
class
='
fragment
'>
Once
the
left
thumb
is
down
you
may
stop
—
nothing
further
can
change
.
p
><
p
class
='
fragment
'>
Count
from
0
to
31
this
way
.
Then
31
+
1
:
the
left
thumb
is
<
em
>
still
up
em
>
after
the
little
finger
.
<
strong
>
That
is
the
carry
that
fell
off
the
tape
strong
>
—
overflow
.
Turing
’
s
tape
is
infinite
;
your
hand
is
not
.
p
>
<
p
class
='
fragment
'><
strong
>
In
pairs
.
Two
roles
.
strong
>
<
strong
>
TAPE
:
strong
>
write
six
cells
on
paper
''
e
.
g
.
<
code
>
0
1
0
1
1
1
code
>''
and
cover
all
but
the
cell
under
the
head
with
your
hand
.
<
strong
>
MACHINE
:
strong
>
you
have
only
a
rule
card
(
the
table
of
the
previous
folio
)
and
your
left
thumb
as
the
state
.
You
may
never
see
the
whole
number
.
p
><
p
class
='
fragment
'>
Loop
:
MACHINE
says
“
read
!”
—
TAPE
reveals
the
bit
under
the
head
.
MACHINE
looks
up
the
row
and
says
“
write
w
''
move
left
”''
updating
the
thumb
.
TAPE
writes
and
moves
the
head
one
cell
left
.
Stop
when
the
thumb
is
down
.
p
><
p
class
='
fragment
'>
Run
<
code
>
010111
code
>''
<
code
>
001111
code
>''
<
code
>
111111
code
>.
Convert
to
decimal
to
check
.
What
happens
in
the
last
run
when
the
head
falls
off
the
tape
?
p
><
p
class
='
fragment
'>
Swap
roles
.
Afterwards
discuss
:
<
strong
>
did
either
of
you
ever
need
to
know
what
number
it
was
?
strong
>
Where
''
physically
''
was
the
carry
stored
?
p
>
<
p
class
='
fragment
'><
strong
>
In
pairs
.
strong
>
First
:
the
<
strong
>
forgetful
machine
strong
>.
It
has
no
thumb
:
at
every
cell
it
behaves
as
if
<
code
>
c
=
1
code
>
(
it
always
flips
the
bit
and
always
moves
on
).
p
><
p
class
='
fragment
'>
Run
it
on
<
code
>
0101
code
>.
What
should
the
answer
be
?
Which
inputs
does
the
forgetful
machine
happen
to
get
right
''
among
the
sixteen
four
-
bit
numbers
?
p
><
p
class
='
fragment
'>
Then
the
<
strong
>
challenge
:
run
it
backwards
strong
>.
Design
a
rule
table
for
<
em
>
subtract
1
em
>
(
state
<
code
>
BORROW
code
>)
—
hint
:
it
is
the
increment
table
with
the
roles
of
<
code
>
0
code
>
and
<
code
>
1
code
>
exchanged
.
Test
it
by
counting
down
from
8
on
your
hands
.
p
><
p
class
='
fragment
'>
Check
yourselves
:
<
code
>
BORROW
code
>
reads
<
code
>
0
code
>
→
write
<
code
>
1
code
>''
move
left
''
stay
in
<
code
>
BORROW
code
>;
<
code
>
BORROW
code
>
reads
<
code
>
1
code
>
→
write
<
code
>
0
code
>''
<
code
>
HALT
code
>.
In
algebra
:
<
code
>
out
=
b
XOR
w
code
>''
<
code
>
w
′
=
(
NOT
b
)
AND
w
code
>.
(
And
the
forgetful
machine
is
right
on
<
code
>
0111
code
>
and
<
code
>
1111
code
>
only
.)
p
>
<
div
class
='
fragment
'><
table
><
tr
><
th
>
th
><
th
>
Logic
(
Boole
1854
)
th
><
th
>
Wire
(
Shannon
1937
)
th
><
th
>
Machine
(
Turing
1936
)
th
>
tr
><
tr
><
td
>
what
it
is
td
><
td
>
formulas
td
><
td
>
circuit
of
gates
td
><
td
>
tape
''
head
''
states
td
>
tr
><
tr
><
td
>
sum
digit
td
><
td
><
code
>
out
=
b
XOR
c
code
>
td
><
td
>
XOR
gate
td
><
td
>
write
rule
td
>
tr
><
tr
><
td
>
carry
td
><
td
><
code
>
c
′
=
b
AND
c
code
>
td
><
td
>
AND
gate
+
wire
td
><
td
>
next
state
(
thumb
)
td
>
tr
><
tr
><
td
>
many
bits
td
><
td
>
same
formula
for
each
<
code
>
i
code
>
td
><
td
>
a
chain
:
<
strong
>
space
strong
>
td
><
td
>
one
gate
pair
''
repeated
:
<
strong
>
time
strong
>
td
>
tr
>
table
>
div
><
p
class
='
fragment
'>
Same
algorithm
''
three
notations
.
Algebra
says
<
em
>
what
em
>''
gates
say
<
em
>
with
what
em
>''
the
machine
says
<
em
>
in
what
order
em
>.
p
><
p
class
='
fragment
'>
And
the
translation
between
them
is
<
em
>
mechanical
em
>
—
which
is
exactly
why
computers
can
exist
.
p
>
<
p
class
='
fragment
'>
Every
neural
network
''
every
language
model
''
runs
on
chips
made
of
billions
of
gates
just
like
the
ones
you
drew
today
—
XOR
''
AND
''
NAND
''
wired
by
algebra
and
clocked
through
time
.
p
><
p
class
='
fragment
'>
When
people
say
“
the
machine
computes
”''
this
is
all
it
means
:
<
strong
>
logic
''
laid
out
in
space
''
unrolled
in
time
strong
>.
p
><
p
class
='
fragment
'>
Learning
does
not
change
that
.
It
changes
only
<
em
>
which
numbers
em
>
sit
in
the
tape
.
Next
time
:
how
those
numbers
came
to
be
tuned
—
Claude
''
Marvin
''
John
and
the
others
.
p
>
<
p
class
='
fragment
'><
strong
>
In
pairs
''
three
minutes
:
strong
>
explain
to
each
other
''
without
notes
''
<
em
>
why
em
>
the
sum
digit
is
XOR
and
the
carry
is
AND
.
p
><
p
class
='
fragment
'>
Then
answer
the
question
of
the
day
in
two
sentences
:
<
strong
>
why
does
counting
in
binary
work
''
and
what
is
a
machine
doing
when
it
counts
?
strong
>
p
><
p
class
='
fragment
'>
Write
down
where
your
thumb
was
needed
.
That
is
the
whole
difference
between
a
calculator
and
a
table
of
formulas
:
<
strong
>
memory
strong
>.
p
>
<
p
class
='
fragment
'>
Is
there
something
you
<
strong
>
like
strong
>
about
this
seminar
?
p
><
p
class
='
fragment
'>
Is
there
something
you
<
strong
>
don
’
t
like
strong
>?
p
><
p
class
='
fragment
'>
Is
there
something
<
strong
>
new
and
useful
strong
>
you
learned
during
this
seminar
?
p
>
[Impressum, Datenschutz, Login] Other subprojects of udk.ai linkring: teacher.solar gardens.digital fibel.digital baumhaus.digital refused.science