A MultiFaceted Attack on the Busy Beaver Problem

1
A Multi-Faceted Attack on the Busy Beaver Problem
thesis author thesis advisor other project
contributors
Owen Kellett Selmer Bringsjord Kyle Ross Bram
van Heuveln Kostas Arkoudas Marc
Destefano Boleshaw Szymanski Carlos
Varela Shailesh Kelkar
2
The Busy Beaver Problem (General Version)

• In general, the busy beaver problem is to find
  the most productive Turing machine with a given
  state and symbol set.
• The productivity of a Turing machine can be
  defined in many ways
• The number of symbols written
• The number of steps taken
• The number of cells moved away from the starting
  cell
• The number of non-blank symbols on tape
• Etc.
• Note Non-halting machines will set almost any of
  these numbers to infinity, so non-halting
  machines will be excluded from consideration.

3
Standard Settings

• Some standard settings for the Busy Beaver
  Problem are
• The alphabet consists of a blank and a non-blank
• The Turing Machine starts on an empty tape.
• Productivity is the number of non-blank symbols
  left on the tape

4
Formalizing the Problem

• n number of states
• M(n) set of TMs with n states and binary
  alphabet
• Prod(M) number of non-blank symbols left on tape
  by machine M, when started on empty tape.
• Busy Beaver Problem Find BB(n) max Prod(M)
  M ? M(n)
• Any machine M ? M(n) for which Prod(M) BB(n) is
  called a Busy Beaver.
• Rado defined the problem and proved that BB(n) is
  uncomputable (1962).
• However, we can find individual values BB(n) for
  small n.

5
Variations of the Problem

• We can still define a variety of Busy Beaver
  problems
• Do we use quadruple or quintuple machines?

• How does the machine come to a halt?

• Are there any restrictions on the output
  configuration?
• Standard configuration head positioned at
  leftmost 1 (non-blank) of consecutive string of
  1s on otherwise empty tape
• Anything goes

6
Taxonomy of BB Problems
BB
Quintuples
Quadruples
Anything goes
Standard config.
Anything goes
?
?
Explicit Halt State
Explicit Halt State
Implicit Halt State
Explicit Halt State
Implicit Halt State
?
B(n) (Boolos Jeffrey, Turings World)
R(n)
P(n) (Pereira et al.)
O(n) (Oberschelp et al.)
?(n) (Rado)
7
Problems in Determining BB(n)

• Turing unsolvable
• Large search space
• Implicit halt M(n)(4n1)2n
• Explicit halt M(n)(4n4)2n
• 4 possible actions for each of n next states
• For implicit machines 1 no-action transition to
  halt-state
• For explicit machines 4 possible actions to
  halt-state
• 2n possible transitions

8
General Algorithm

• Enumerate the set S of n-state Turing machines
  (1)
• foreach machine t in S do
• Classify t as either a halter or non-halter (2)
• if t is a halter then
• Run t until it halts
• If t satisfies the halting conditions of the
  formulation in question (standard/non-standard
  position requirements), add it to our candidate
  set C
• else
• Discard t
• return the most productive Turing machine in set C

Problem (1) Enormous search space Problem (2)
Halting problem
9
Problem (1) Solution Tree Normalization
10
Improvement from Optimizations
11
Problem (2) Partial Solution Non-halt detection

• Halting problem
• There is no generalized algorithm that will take
  as input machine m and return whether or not m
  halts
• Step Limit
• Run a machine for a fixed number of steps.
  Problem if it hasnt halted, it may still halt
  at some later point.
• Fortunately, algorithms can be designed to test
  for specific non-halting behaviors
• Thus we can develop an algorithm A such that for
  any machine m
• A eventually declares that m halts (m is a
  halter)
• A eventually declares that m does not halt (m is
  a non-halter)
• A eventually declares that it doesnt know
  whether m halts or not (m is a holdout)

12
Basic Non-halt detection mechanisms

• Backtracking
• Work backwards to prove that machine can never
  reach halt condition
• Subset loop
• A machine contains a subset of states in which
  all possible transitions from any of these states
  is a transition to another state in the set.
• The machine will loop around in this subset
  forever
• Simple loop
• Read head moves along the tape infinitely
  producing the same pattern over and over

13
Christmas Trees
            0               State
0            1               State
1            10              State
2            10              State
3           010              State
0           110              State
1           110              State
2           110              State
0           111              State
1           1110             State
2           1110             State
3           1110             State
0           1010             State
3           1010             State
3          01010             State
0          11010             State
1          11010             State
2          11010             State
0          11110             State
1          11110             State
2          11110             State
0          11111             State
1          111110            State
2          111110            State
3          111110            State
0          111010            State
3          111010            State
3          111010            State
0          101010            State
3          101010            State
3         0101010            State 0

• Read head sweeps back and forth across tape in
  provably repeatable manner
• Variations
• Multi-sweep trees
• Leaning trees

14
Counters
0         State 01         State
110        State 2100       State
3101       State 0101       State
1101       State 1101       State
2101       State 3100       State
21000      State 31001      State
01001      State 11001      State
11001      State 11001      State
21001      State 31011      State
01011      State 11011      State
11011      State 21011      State
31001      State 21001      State
31000      State 210000     State 3
10001     State 010001     State
110001     State 110001     State
110001     State 110001     State
210001     State 310101     State
010101     State 110101     State
110101     State 210101     State
310001     State 210001     State
310011     State 010011     State
110011     State 110011     State
110011     State 210011     State
310111     State 010111     State
110111     State 110111     State
210111     State 310011     State 2
15
Initial Results
16
The Human Attack

• Continuing in this manner yields three
  possibilities
• There exists a smallest n such that some machine
  with n states cannot be proven a non-halter by
  some automated detection routine
• Every non-halting Turing machine can be proven a
  non-halter by some automated detection routine.
  Thus the set of detection routines is not
  recursively enumerable (but is it enumerable by
  humans?)
• There exists a smallest n such that some machine
  with n states cannot be proven a non-halter by
  some automated detection routine. However, it's
  non-haltingness can be ascertained by mechanisms
  available to human thought (i.e.
  diagrammatic/visual reasoning)

17
Visual Reasoning Example

• Consider the diagram shown
• Property
• Question How does a human observer determine
  this property?

18
Attacking the 98 Holdouts viaDiagrammatic
Reasoning

• Without formal, automated routines, a trained
  observer can determine the behaviors of the 98
  holdouts in the n 5 search space

19
Leaning Christmas Trees

• Similar to Christmas Trees except they lean
  meaning the read head pushes outward in only one
  direction
• Automated detection failed in some cases because
  of difficulties in identifying components

20
Nested Christmas Trees

• Like a normal Christmas Tree except return sweep
  takes form of a Christmas Tree itself. Thus I
  call them Nested Christmas Trees
• I have a formal specification defined but it is
  not checked against all nested trees in the 98
  holdouts yet
• Possible nested tree variations may/do exist

21
Counter Variations

• Base 3, Base 4, etc. counters
• Intuitive derivative of binary counter behavior
• Alternating counters
• In a nutshell, checkpoint component of counter
  alternates between two different components
• Resetting counters
• When additional digit needs to be added, instead
  of adding 1, resets to 0 or possibly some other
  value with higher base counters
• Complex counters
• Ordinary counters identify components for the 0s
  and 1s of the number and also certain Turing
  machine states that define the behavior
• Complex counters allow these components to be
  defined as a set of components

22
Uneven Multi-Sweep Christmas Trees

• These machines act much like multi-sweep
  Christmas trees
• However, they escape the automated detection
  routine because not every sweep reaches the
  previous extremum

23
Other behaviors

• Nested Counter Christmas Tree
• Similar to a nested Christmas Tree. However,
  return sweep behaves like a nested counter
  instead of a nested Christmas tree
• Double Sweep Leaning Christmas Trees
• 1.5 Sweep Christmas Trees
• every other sweep only reaches halfway across
  tape
• Asymmetric Christmas Trees
• interior components of tree are not identical
  from end to end

24
Results

• The 98 Holdouts from the n 5 search space
  categorized by diagrammatic reasoning

25
Future Work/Goals

• Continued development of non-halt detection
  routines
• Christmas tree variations
• Counter variations (base 3, base 4, etc..)
• novel techniques for detecting non-halting
• automated routines for the behaviors of the 98
  holdouts described
• Certification of our records (Athena)
• Visual reasoning
• Distributed computation
• Parallel implementation of our attack for serious
  attempts at setting records for n 7, n 8, and
  beyond