Von Neumann proposed that an artificial self-replicating system would require a universal constructor that can build copies of itself by reading its own description. This is analogous to Turing machines that can emulate any other machine given its software instructions. Turing later proved that the halting problem, determining if a program will finish running, is undecidable. His proof works by considering a machine M' that determines if another machine M halts on itself as input, leading to circular self-reference that cannot be resolved. Similarly, attempting to solve the halting problem through self-replication results in an endless circular process of self-reproduction, showing the fundamental limits of self-replication and computation.

1. Cover image © Scientific American / Hybrid Medical Animation
Self-Replication and the
Halting Problem
ELSI Seminar July 25, 2017
Hiroki Sayama
sayama@binghamton.edu

2. dx.doi.org/10.1002/cplx.20218

3. Life and Self-Replication
“ ... when Rene Descartes
averred to Queen
Christina of Sweden that
animals were just
another form of
mechanical automata,
Her Majesty pointed to a
clock and said, “See to it
that it produces
offspring.”
― Sipper, M. & Reggia, J. A. (2001)
Scientific American 285(2)

5. Von Neumann’s Question
• Natural biological systems seem to have
increased their complexity through evolution
• Artificial systems seem to be able to make
only products that are less complex than
themselves
Can artificial systems make products equally
complex to, or more complex than,
themselves?

6. Von Neumann’s Answer
• An artificial system can self-replicate if
it consists of:
– a description I(X)
– a machine X that can
• build X by reading I(X)
• make a copy of I(X)
• combine them together (i.e. X + I(X) = itself)
• Description of a self-replicating
machine must be separate from the
machine itself

7. Von Neumann’s Self-Replicating
Automaton
A : universal constructor
B : tape duplicator
C : controller
ID=A+B+C : description tape
A + IX → A + IX + X
B + IX → B + IX + IX
(A + B + C) + IX
→ (A + B + C) + IX + X + IX
(A + B + C) + IA+B+C
→ (A + B + C) + IA+B+C
+ (A + B + C) + IA+B+C

8. From M. Sipper, Artificial Life 4: 237-257 (1998)
History of Self-Replication Studies

9. Computation and Construction

10. Rewinding the tape of history
for about a decade back…

13. Turing Machines
• Finite-state automaton + movable
read/write head + infinite memory tape
• Computationally universal
state
BB 1 0 B

14. Universal Turing Machines
• More important fact Turing showed:
There are TMs that can emulate
behaviors of any other TMs if
instructions (software) are given
A single machine can be
a “universal computer”
UTM
A
B
C
D

15. Computation and Construction
• Turing machines (1936)
– Universal computer that can execute any
computational tasks specified in a finite
description
– Emergence of “Computation Theory”
• Von Neumann’s automata (1948)
– Universal constructor that can execute any
constructional tasks specified in a finite
description
– Emergence of “Construction Theory”

16. Differences
• Universal computers must be able to
perform any logical, mathematical, or
computational tasks possible
– Universal constructors need not
• Universal constructors must be made
of the same parts they operate on, and
thus obey the same “physics” laws as
the parts
– Universal computers need not

17. More Difference?
A : universal constructor
B : tape duplicator
C : controller
ID=A+B+C : description tape
A + IX → A + IX + X
B + IX → B + IX + IX
(A + B + C) + IX
→ (A + B + C) + IX + X + IX
(A + B + C) + IA+B+C
→ (A + B + C) + IA+B+C
+ (A + B + C) + IA+B+C

18. More Difference?
A : universal constructor
B : tape duplicator
C : controller
ID=A+B+C : description tape
A + IX → A + IX + X
B + IX → B + IX + IX
(A + B + C) + IX
→ (A + B + C) + IX + X + IX
(A + B + C) + IA+B+C
→ (A + B + C) + IA+B+C
+ (A + B + C) + IA+B+C
computer
||
?

19. Hidden Connection
A : universal constructor
B : tape duplicator
C : controller
ID=A+B+C : description tape
A + IX → A + IX + X
B + IX → B + IX + IX
(A + B + C) + IX
→ (A + B + C) + IX + X + IX
(A + B + C) + IA+B+C
→ (A + B + C) + IA+B+C
+ (A + B + C) + IA+B+C
computer
||
These components DO appear
in computation theory as well

20. The Halting Problem

21. The Halting Problem
• Given a description of a computer
program and an initial input it receives,
determine whether the program
eventually finishes computation and
halts on that input
• Is there a general procedure to solve
this problem for any arbitrary programs
and inputs?
No

22. Proof (1)
M
Program p
Input i
M
M
If p halts on i
1
If p doesn’t halt on i
0
(M always halts)
• Assume there is a TM (called M) that
can solve the halting problem for any
program p and input i
– Output of M: M(p, i) = 1 or 0

23. Proof (2)
• Derive another TM (called M’) from M
which computes diagonal components
in the p-i space
– Output of M’: M’(p) = M(p, p)
M’
Program p
M’
M’
If p halts on p
1
If p doesn’t halt on p
0
(M’ always halts)

24. Proof (3)
M*
Program p
M*
M*
If p halts on p
If p doesn’t halt on p
0 M* halts
M* doesn’t
halt
• Derive another TM (called M*) from M’
that enters an infinite loop if M’(p) = 1
– Output of M*: M*(p) = 0 if M’(p) = 0; doesn’t
halt otherwise

25. Proof (4)
• What happens if M* is given its self-
description p(M*)?
• No general algorithm exists for the
halting problem
M*
Program p(M*)
M*
M*
If p(M*) halts on p(M*)
If p(M*) doesn’t halt on p(M*)
0 M* halts
M* doesn’t
halt
Contradictions

26. However…

27. Turing’s Original Proof

28. “ ... This proof,
although perfectly
sound, has the
disadvantage that it
may leave the
reader with a
feeling that “there
must be something
wrong”. The proof
which I shall give
has not this
disadvantage, …”

29. “ ... Now let K be the D.N of H. What does H do in the K-th
section of its motion? It must test whether K is satisfactory,
giving a verdict “s” or “u”. Since K is the D.N of H and since H is
circle-free, the verdict cannot be “u”. On the other hand the verdict
cannot be “s”. For if it were, then in the K-th section of its motion
H would be bound to compute the first R(K – 1) + 1 =
R(K) figures of the sequence computed by the machine
with K as its D.N and to write down the R(K)-th as a figure
of the sequence computed by H. The computation of the first R(K)
– 1 figures would be carried out all right, but the instructions
for calculating the R(K)-th would
amount to “calculate the first R(K) figures
computed by H and write down the R(K)-th”.
This R(K)-th figure would never be found. I.e.,
H is circular …”

30. Turing’s Proof (In Essence)
• Derive another TM (called M’) from M
which computes diagonal components
in the p-i space
– Output of M’: M’(p) = M(p, p)
M’
Program p
M’
M’
If p halts on p
1
If p doesn’t halt on p
0
(M’ always halts)
What happens if M’ receives its own
program p(M’) as an input?

31. • The system M’ + p(M’) tries to compute
the behavior of the TM described in
p(M’) (i.e., M’) given p(M’) as an input
→ Computing the situation “M’ + p(M’)”
→ Circular self-computation
→ Self-replication within a TM tape
Turing’s Proof (In Essence)

32. M’ + p(M’)
“M’ + p(M’)”
“ “M’ + p(M’)” ”
“ “ “M’ + p(M’)” ” ”

33. Hidden Connection Revealed
A : universal constructor
B : tape duplicator
C : controller
ID=A+B+C : description tape
A + IX → A + IX + X
B + IX → B + IX + IX
(A + B + C) + IX
→ (A + B + C) + IX + X + IX
(A + B + C) + IA+B+C
→ (A + B + C) + IA+B+C
+ (A + B + C) + IA+B+C
computer
||
Diagonalization
M’(p) = M(p, p)
The computer
M’ + p(M’)
The computed
“M’ + p(M’)”

34. Solving the Unsolvable
• The Halting Problem:
To determine whether the process
eventually stops or not
• Attempt to solve the halting problem
creates an endless circular process of
self-replication (in both computation
and construction)

35. M’ + p(M’)
“M’ + p(M’)”
“ “M’ + p(M’)” ”
“ “ “M’ + p(M’)” ” ”

36. M’ + p(M’)
“M’ + p(M’)”
“ “M’ + p(M’)” ”
“ “ “M’ + p(M’)” ” ”
What happens
if I execute this
instruction?
What happens
if I execute this
instruction?
What happens
if I execute this
instruction?
What happens
if I execute this
instruction?

37. Summary
• Similarities between construction and
computation
• Von Neumann’s self-replication model
~ Turing’s original proof of the
undecidability of the halting problem
• Undecidability => endless process

38. We are all in an endless
self-computation/construction
process initiated billions of
years ago by a first universal
constructor, who just tried to
solve the halting problem for a
diagonal input.

39. Thank You