*Not to be confused with Trree.*

Template:Infobox function
The **TREE sequence** is a fast-growing function arising out of graph theory, devised by mathematical logician Harvey Friedman.^{[1]}^{[2]} Friedman showed that the function eventually dominates all recursive functions provably total in the system \(\text{ACA}_0\)+\(\Pi_2^1\)-\(\text{BI}\).^{[3]}

The smallest nontrivial member of the sequence is the famously large **TREE(3)**, notable because it is a number that appears in serious mathematics that is larger than Graham's number.

## Definition Edit

Suppose we have a sequence of *k*-labeled trees T_{1}, T_{2} ... with the following properties:

- Each tree T
_{i}has at most*i*vertices. - No tree is homeomorphically embeddable into any tree following it in the sequence.

Kruskal's tree theorem states that such a sequence cannot be infinite. Harvey Friedman expanded on this by asking the question: given *k*, what is the maximum length of such a sequence?

This maximal length is a function of *k*, dubbed TREE(*k*). The first two values are TREE(1) = 1 and TREE(2) = 3. The next value, **TREE(3)**, is famously very large. It vastly exceeds Graham's number and n^{n(5)}(5)^{[4]}. Chris Bird has shown that \(\text{TREE}(3) > \{3, 6, 3 [1 [1 \neg 1,2] 2] 2\}\), using his array notation.^{[5]}

TREE(n) grows at least as fast as \(f_{\vartheta(\Omega^\omega\omega)}(n)\) in the fast-growing hierarchy, making it quite sizable even to a googologist — \(\vartheta(\Omega^\omega\omega)\) is stronger than BEAF's *linear array-arrays*. It is more powerful than Kirby-Paris hydras and the Goodstein sequences, but weaker than subcubic graph numbers and Buchholz hydras.

## Weak tree function Edit

Define \(\text{tree}(n)\), the **weak tree function**, as the length of the longest sequence of 1-labelled trees such that:

- Every tree at position
*k*(for all*k*) has no more than*k*+*n*vertices. - No tree is homeomorphically embeddable into any tree following it in the sequence.

Adam P. Goucher has shown the following properties of this function:

- tree(n) has a "growth rate" comparable to that of \(f_{\vartheta(\Omega^\omega)}(n)\) in the fast-growing hierarchy.
- TREE(3) > tree
^{treetreetreetree8(7)(7)(7)(7)}(7)

A larger lower bound has since been found. Define \(\text{tree}_2(n)=\text{tree}^n(n)\) and \(\text{tree}_3(n)=\text{tree}_2^n(n)\). Then \(\text{TREE}(3) > \text{tree}_3(\text{tree}_2(\text{tree}(8)))\). The latter expression is equal to tree^{treetree...tree(n)...(n)(n)}(n) with n layers, where \(n = \text{tree}^{\text{tree}(8)}(\text{tree}(8))\).^{[6]}

### Values for \(\text{tree}(n)\) Edit

It can be shown that \(\text{tree}(1) = 2, \text{tree}(2) = 5\) and \(\text{tree}(3) \geq 262140\). \(\text{tree}(1)\) uses the sequence:

(()) ()

\(\text{tree}(2)\) is a bit larger, we have two longest sequences that go as follows:

((())) (()()()) (()()) (()) ()

Otherwise:

(()()) (((()))) ((())) (()) ()

Determining the exact value for \(\text{tree}(3)\) is much harder, since there are a lot of sequences to check, and each of these is very long.

Friedman has defined an FFF(k) function, which is equal to tree(k+1).^{[7]}

## Explanation Edit

Trees are tricky to visualize without drawing them out, so we shall devise a more compact way of representing them. Consider a language which has various kinds of parentheses such as `()`

, `[]`

, `{}`

etc. Parentheses always come in pairs and can nest within each other. Within a larger node, they may be concatenated. For example, the following strings are valid in this language:

[] ([]) {[()]()} [(){[[]]}(){(())[]}]

Suppose we have a string *A*. We shall call a pair of corresponding parentheses a **node**, in deference to the original tree construction. Define a **child** of a node to be a node that is nested one level deep within the original node. For example, take the string `{[()()][][()]}`

; the children of the node represented by `{}`

are the nodes represented by `[]`

, but not the nodes represented by `()`

.

Call a node **deletable** if it has fewer than two children. For example, in the string `{[()()][][()]}`

, the `()`

nodes are all deletable, as are the latter two `[]`

nodes, but not the first `[]`

or the `{}`

. In the string `([(()())])`

, the `[]`

node is deletable. (Note: is this correct?)

We say a string A is **reducible** to a string B if A can be transformed into B by removing deletable nodes. A string A is reducible to a string B if and only if the tree represented by B is homeomorphically embeddable in the tree represented by A.

With all this in mind, we can create an equivalent definition of TREE(*k*). Suppose we have a sequence of strings with the following properties:

- You may only use
*k*types of brackets. - The first string has at most one pair of brackets, the second string has at most two pairs of brackets, the third string has at most three pairs of brackets, etc.
- No string is reducible to an earlier string.

TREE(*k*) is the maximal length of the sequence.

For *k* = 1, the optimal sequence has only one member: `()`

.

For *k* = 2, the optimal sequence has only three members: `()`

, then `[[]]`

, then `[]`

.

### Weak tree function Edit

Suppose we have a sequence of strings with the following properties:

- You may only use
`()`

and no other types of brackets. - The first string has at most 1 +
*k*pairs of brackets, the second string has at most 2 +*k*pairs of brackets, the third string has at most 3 +*k*pairs of brackets, etc. - No string is carvable from a later string.

tree(*k*) (the weak tree function) is the maximal length of the sequence.

## Video Edit

Source: The Enormous TREE(3) - Numberphile

## Sources Edit

- ↑ Adam Goucher, TREE(3) and impartial games
- ↑ Friedman's post on FOM mailing list
- ↑ http://www.cs.nyu.edu/pipermail/fom/2006-March/010279.html
- ↑ How large is TREE(3)
- ↑ Chris Bird, Beyond Bird's Nested Arrays II, page 10
- ↑ How does TREE(3) grow to get so big? Need laymen explanation
- ↑ http://www.cs.nyu.edu/pipermail/fom/2006-June/010627.html