# Tree 3 is bigger than Graham's number

## Golf one size bigger than TREE (3)

The function TREE (k) gives the length of the longest sequence of trees T 1 , T 2 , ..., where each vertex is marked with one of k colors, the tree T i has at most i vertices and no tree a is minor, every tree following it in the sequence.

TREE (1) = 1, with e.g. T 1 = .

TREE (2) = 3: e.g. T 1 =; T 2 =; T 3 = .

TREE (3) is one size Number. Even bigger than Graham's number. Your job is to do one more bigger Output number!

This is code golf, so the goal is to write the shortest program in any language that deterministically returns a number greater than or equal to TREE (3) (to standard output).

• You are not allowed to make any entries.
• Your program may need to exit, but you can assume that your computer has infinite memory.
• You can assume that the number type of your language is a can contain any finite value but need to explain exactly how this works in your language (example: does a floating point have infinite precision?)
• Infinities are not allowed as output.
• Underflow of a number type throws an exception. It doesn't wrap around.
• Since tree (3) is like a complex number, one can use the rapidly growing hierarchy approximation f θ (& OHgr; ? ω) +1 (3) when beating the number.
• You need to explain why your number is so big and provide an unused version of your code to verify that your solution is valid (since there isn't a computer with enough memory to store the TREE gives (3) ).

Note: None of the answers for now found work here.

Why is TREE (3) so big?

in which H the Hardy hierarchy is ψ is an expanded version of Madore's OCF (explained below) and φ the Veblen function is.

Try it online!

Ungolfed: (with functions, not lambdas) And (roughly) Veblen's Phi function: Explanation without ordinal numbers:

My program is starting. It applies then and up to and outputs.

Explanation with ordinal numbers:

ψ '(ω ∙ α) ≈ ψ (α), the ordinal collapse function described in the picture above.

My program initiates and more or less and then applies and until and returns.

And if I did that correctly, it will be much larger than the Bachmann-Howard ordinal number ψ (Ω Ω Ω ... ), which are much larger than ϑ (Ω ω ω) +1.

ψ (Ω (↓ 9) 9)> ψ (Ω (↓ 4) 3)> ψ ( Ω Ω ) +1> ψ ( Ω ω ω ) +1> ϑ (Ω ω ω) +1

And if my analysis is correct, we should ψ '(Ω Ω ~ x) ~ = ψ * (Ω Ω ∙ x), where ψ * is Madore's normal psi function. If so, my ordinal number is roughly ψ * (φ 3 (Ω + ω)).

### Haskell, 252 bytes, TREE (3) +1

Thank you so much for the help from H.PWiz, Laikoni and Ørjan Johansen for helping with golfing the code!

As suggested by HyperNeutrino, my program returns exactly TREE (3) +1 (TREE is computable, it turns out).

is a tree with labels and knots. should it be, or.

is the number of nodes in a tree.

is true if homeomorphically embedded (based on Definition 4.4 here), and false if not.

outputs a large list of trees. The exact list is not important. The important property is that each tree contains up nodes with nodes to be stamped with, or, and maybe some more trees as well (but the other trees are also labeled with, or). It is also guaranteed that a finite list will be returned.

lists all sequences the length of trees so the opposite (since we are building it backwards) of this sequence is valid. A sequence is valid if the nth element (where we start with 1) has at most n nodes and no tree is homeomorphically embedded in a later one.

prints out the smallest in such a way that there are no valid length sequences.

Since the longest valid sequence is defined as the length, the smallest is such that there are no valid length sequences which my program outputs.

It is H the Hardy hierarchy and ψ the ordinal collapse function under the Bachmann-Howard ordinal number defined by Pohlers.

Many thanks to Jonathan Frech for -3 bytes.

def S (T): return 0 if T == 1else [S (T )] + T [1:] def R (T): U = T ; V = T [1:]; exec "global B; B = T" * (T [-1] == 0); return [S (B)] + V if U == 1else [R (U)] * c + V if U otherwise VA = [[[1,1], 1], 0] c = 9 while A: A = R (A); c * = print c c

Try it online!

Better distributed version:

def S (T): return 0 if T == 1 otherwise [S (T )] + T [1:] def R (T): U = T  V = T [1:] global B if T [-1] == 0: B = T if U == 1: return [S (B)] + V return [R (U)] * c + V if U otherwise VA = [[[1 , 1], 1], 0] c = 9 while on: A = R (A) c * = c print c

Explanation:

This program implements a variant of the Buchholz Hydra, whereby only the designations 0 and 1 are used. Basically, at every step we look at the first leaf node of the tree and check whether it is marked with 0 or 1.

-If the leaf node is marked with a 0, we delete the leaf node and then copy the tree from the parent node c times, with all copies connected to the grandparent of the leaf node.

-If the leaf node is marked with a 1, we look back to the root until we reach an ancestral node marked with a 0. Let S be the tree that starts from this ancestral knot. Let S 'S, where the leaf node is newly labeled with 0. Replace the leaf node with S '.

Then we repeat the process until we only have the root node.

This program differs from the normal Buchholz-Hydra procedure in two ways: first, after we have performed the procedure described above, we perform a recursion of the tree and carry out the procedure described above for copying the label 0 for each ancestor node of the original leaf node by. This increases the size of the tree, so our procedure takes longer than the normal Buchholz hydra, and therefore results in greater numbers in the end. However, it still exits because the ordinal number associated with the new tree is still smaller than the old tree. The other difference is, instead of starting with c = 1 and increasing 1 each time, we start with c = 9 and square it each time because why not.

The tree [[[1,1], 1], 0] corresponds to the ordinal number ψ (& OHgr; ? ? ), which is much larger than the order θ (Ω ? ω), and so our resulting final number of about H ψ (Ω Ω Ω ) (9) will definitely exceed TREE (3).

It is H the Hardy hierarchy and ψ the standard ordinal collapse function below the Bachmann-Howard ordinal number defined here.

Try it online!

Ungolfed version:

def S (a) * v, u = a if a == 1 return [] else return v + [S (u)] end end def R (t) * v, u = t if t  == [ ] \$ b = t end if u == 1 return v + [S (\$ b)] elsif u == [] return v otherwise return v + [R (u)] * \$ c end end \$ c = 9 a = [[], [1, [1,1]]] while a! = [] do \$ c * = 9 a = R (a) end print \$ c

This program implements the Buchholz hydra with nodes marked with [] and 1, as described in my Python 2 entry.

The tree [[], [1, [1,1]]] corresponds to the ordinal number ψ (& OHgr; ? ? ), which is much larger than the order θ (Ω ? & ohgr;) = ψ (& OHgr; ? ? ? ), and so our final number of roughly H resulting ψ (& OHgr; ? ? ) (81) exceeds TREE (3).

To save myself a little work, I decided to port Loader.c almost one to one to Julia and compress it into the code block above. For those who want to do the comparisons themselves (either to check my score or to help me find bugs or improve my code) an ungolfed version is listed below:

No previous counts because I made way too many byte miscounts while golfing aggressively.

This program is a modified version of this 225B translation of pair images in JavaScript. The pair sequence number and its original code can be found here.