Surpassing "Graham's number"

Sunday, September 19, 2010

This posting describes a 64-state 2-symbol Turing machine (GTM64) that computes a number greater than Graham's number (G), starting with a blank tape.

GTM64 implements the same pair-rewriting algorithm as the machines described in the previous posting, now restricted to ordinals less than ω2 instead of ω2. Since every pair (i,j) (denoting ωi + j) now has i=0 or i=1, the portion of the program that copies i is thereby simplified. The machine now initialises the tape to <n><i><j> = <0><1><2>, and thus computes hωi + j(n) + 1 = hω+2(0) + 1 = hω+1(hω+1(4)) + 1 >> G, where the h-functions are as described in the previous posting.

GTM64

This machine begins by writing <n><i><j> = <0><1><2> on an initially all-0 tape, doing so by using a 3-state busy beaver with two states added to produce the required configuration (0) 10 110 1110, where parentheses again indicate the current cell. (NB: A reduction by one more state would be realised by finding a shorter way to produce a configuration of the form (0)A0{X0Y0}, where the {}-bracketed part may be repeated any number of times with possibly different Xs and Ys, and where A, X, Y are blocks of 1s with A ≥ '1', '1' ≤ X ≤ '11', Y ≥ '1', such that X0Y = 110111 occurs at least once. It seems quite possible, if not probable, that such a configuration either occurs among the halting configurations of the multitude of 4-state Busy Beaver candidates, or could be produced by adding just one state to some 3-state Busy Beaver candidate.)

Program revisions have involved deleting some states, causing gaps in the labelling sequence within certain blocks of states. Here is the "raw" GTM64 with 68 states, four of which will later be eliminated by relabelling:

In the machine rawGTM64, each of the four states (e4, q7, v7, z2) is only "half used", and they can be eliminated by relabelling them as the previously "unused halves" of the four states (b1, q4, v4, x4):

This yields a 64-state machine in which there remain nine unused half-states (i1 1, i2 1, j4 1, l1 1, l2 1, m4 1, p1 1, p2 1, and s4 1). Here is the transition table as a Python list of numerical tuples with the states labelled consecutively 1-64, with Halt labelled as 0, and with L/R coded as 0/1 (the unused half-states are omitted):

(1) What is the least n such that Σ(n) > G?
(2) What is the least n for which it has been proved that Σ(n) > G?

The answer to (1) is not known, but—and this is pure speculation—it might be as small as 12 or so.

This posting answers (2) with n = 72, assuming the behavior of the machine described here (GTM72) has been adequately established. (This machine incorporates optimisations suggested by S. Ligocki in the comments section below.)

gα(n)
= n+1 if α = 0
= (gα-1)n+1(n+1) if α is a successor
= (gα[n+1])n+1(n+1) if α is a limit

where α is any ordinal in an initial segment of ordinals for which fundamental sequences have been assigned to the limit ordinals, and α[n] is the nth element of the fundamental sequence for limit α. Here (gα...)n+1 denotes the (n+1)-fold iteration of the bracketed function.

This function-hierarchy is simulated by the following rewriting system for finite sequences of ordinals prefixed by a natural number n:

where {α...}n+1 denotes a sequence of n+1 copies of the bracketed ordinal.

That is, starting with "n α" and applying the above rules repeatedly, the rewriting eventually terminates with only the natural number gα(n) remaining.

Now, every ordinal α in the range [0, ω2) has a unique representation as an ordered pair (i,j) of natural numbers denoting ω·i + j; therefore, by restricting to this initial segment of ordinals, the system can be reformulated as a rewriting system for sequences of such pairs:

where (.,.)n+1 denotes a sequence of n+1 copies of the bracketed pair.

Starting with "n (i,j)", the system will thus compute gωi+j(n).

Consequently, a "Busy Beaver"-class Turing machine that halts with more than Graham's number of 1s on the tape needs only to simulate this pair-rewriting system after initialising the tape to represent relatively small values of n, i, j; e.g., starting with "n (i,j)" = "0 (2,1)", the system will compute gω2+1(0) >> G.

Because of attempting to maximise the output while minimising the number of states, the function-hierarchy actually simulated by the Turing machine described below is hα() + 1, where

hα(n)
= n+1 if α = 0
= (hα-1)n+2(n+4) if α is a successor
= (hα[n+1])n+5(n+7) if α is a limit.

The machine we construct uses a two-symbol tape alphabet {0,1}, in which 0 is the blank symbol and natural numbers are coded in unary; i.e., a number x is coded as <x> = 1x+10. The machine begins by writing <n><i><j> = <0><2><1> = "10 1110 110" on an initially all-0 tape, which it does by incorporating a modified 3-state busy beaver.

In the following, "home" refers to the configuration 0(0)1, where parentheses identify the current bit, and the 00 is the rightmost 00 located to the left of a current 1-bit.

Navigation through the data string is often accomplished by positioning on a 1 and then moving in a given direction until 00 is detected (e.g., the 00s that bracket the entire data string). This allows navigation to either end of the string, and also gives a method for counting through a block of 1s by progressively moving a 00 rightward through the block until 000 is produced.

The "raw" TM has 77 states, five of which will later be eliminated by combining ten unused "half states".

In the machine GTM77, each of the five states (e6, q7, u2, v7, z2) is only "half used", and they can be eliminated by relabelling them as the complementary "unused halves" of the five states (e4, q4, s4, v4 , x4):