LittlePeng9 gave some lower bounds for tree(n) and otree(n). (otree(n) has the same definition as tree(n), except it is about trees where the children of each vertex are ordered rather than unordered.)

## Low Values

Obviously tree(0) = otree(0) = 1 and tree(1) = otree(1) = 2.

With a little work one can see that tree(2) = otree(2) = 5. To prove that tree(2) = 5: Define an n-path to be the tree consisting of a path of n edges starting from the root, and an n-star to be the tree where the root has n children, none of which have children. The first tree must be either an 2-path or an 2-star (or a subtree, and it is never better to take a subtree over a larger tree). If it is a 2-path, then there can be no more paths of length two or more in following trees, so the remaining trees can only be n-stars. So the best choices for the remaining trees must be to take the largest possible n-star each time, so you get ((())), (()()()), (()()), (()), (). Otherwise, the first tree is a 2-star, which means the remaining trees can have no vertices with two or more children. So the remaining trees must be n-paths, and again the best thing to do is to take the largest n-path each time, so you get (()()), (((()))), ((())), (()), (). These are the two longest sequences, and so tree(2) = 5.

## tree(3)

LittlePeng9 found a lower bound of \(2^{17} + 8\) for tree(3). Here we find a sequence for tree(3) of length \(2^{18} - 4\). Our strategy is to use a "greedy" algorithm, based on the my modification to the Levitz/Jervell ordering on trees defined in "How Large is TREE(3)?" on MathOverflow. For the ith tree, we select the largest possible tree less than the previous tree with at most 3 + i vertices. Here is the list of trees (the number on the left is the maximum number of vertices allowed, which we will call the max size.)

4:(()()())

5:((())(()))

6:(((())())())

7:((((()())))())

8:(((((()()))())))

9:((((()()))()))

10:(((()()))())

11:((((((((()())())))))))

12:(((((((()())()))))))

13:((((((()())())))))

14:(((((()())()))))

15:((((()())())))

16:(((()())()))

17:((()())())

18:((((((((((((((((())))))))))))))))())

So in our last tree our root has two children, a path of length 15 descends from the left child. Each time we delete an edge from the path, we add a path of maximum possible length at the top, between the root and the two children. We then delete one edge at a time from the top path until we completely eliminate the top path, after which we delete an edge from the lower path and add a maximum length top path again. After the first edge is deleted we can add a path of length 2 to the top; after the second edge is deleted we can add a path of length 6 to the top; in general, after the nth edge is deleted we can add a path of length \(2^{n+1} - 2\) to the top. So after the 15th edge is deleted, we can add a path of length \(2^{16} - 2\) to the top. The max size of the tree is \(2^{16} + 1\). For the next \(2^{16} - 2\) trees we delete one edge from the path at a time, until we reach the tree (()()). The max size of the tree will be \(2^{17} - 1\). The next tree will have max size of \(2^{17}\), so it will be a path of \(2^{17}\) vertices. We delete one edge at a time until we get down to a single vertex, which will have a max size of \(2^{18} - 1\). Since we started from a max size of 4, the length of the sequence is \(2^{18 }- 4\).

## otree(3)

LittlePeng9 found a lower bound for otree(3) of \(2 \uparrow\uparrow\uparrow\uparrow\uparrow\uparrow 3\); in fact we can do much better.

For otree(3), consider the following construction. Stage n will consist of a tree with <= n vertices. x will stand for a leaf ().

stage 4: (x, x, x)

5: ((x, x), x)

6: ((((x))), x)

7: (((x)), (x, x))

8: (((x)), (((x))))

9: (x, (((x)), ((x)))

10: ((((((x)), ((x))))))

11: (((((x)), ((x)))))

12: ((((x)), ((x))))

13: (((x)), ((x)))

14: ((x), ((x), (x, (((x)), (x)))))

15: ((x), ((x), ((((((x)), (x)))))))

16: ((x), (x, ((x), (((((x)), (x)))))))

17: ((x, (((((x), (((((x)), (x)))))))))

18: (x, ((x), ((((x), (((((x)), (x)))))))))

19: (((((x), ((((x), (((((x)), (x)))))))))))

20: ((((x), ((((x), (((((x)), (x))))))))))

21: (((x), ((((x), (((((x)), (x)))))))))

22: ((x), ((((x), (((((x)), (x))))))))

23: (x, (x, (x, (x, ((x), (((x), (((((x)), (x)))))))))))

We will call a 2-splitting with an x on the left a "trivial 2-splitting". Stage 23 is the beginning of a long sequence with X = ((x), (((x), (((((x)), (x))))))) at the top. We will use the following notation: Let a,b,c,d mean the tree

(...(x, (...(x, (...(x, (...(X)...) with number of left parentheses being 1+a, 1+b, 1+c and 1+d in order.

Then we have

24: 0,0,0,3

25: 0,0,2,2

26: 0,2,1,2

27: 2,1,1,2

28: 1,1,1,2

29: 0,1,1,2

30: 6,0,1,2

31: 5,0,1,2

...

36: 0,0,1,2

37: 0,14,0,2

From here, each time we decrement the second parameter, we can increase the first parameter by an exponentially increasing amount. The nth time we decrement the second parameter, the first parameter increases to 2^(n+1) - 2. So eventually:

32,789: 32766, 0, 0, 2

65,555: 0, 0, 0, 2

65,556: 0, 0, 65534, 1

Here, each time we decrease the third parameter, the third increases by \(2\uparrow\uparrow (n+1) - 2\). So eventually:

0, 0, 1, 1

\(0, 2\uparrow\uparrow 65536 - 2, 0, 1\)

...

0,0,0,1

\(0,0, 2\uparrow\uparrow 65536 - 2, 0\)

...

\(0,2\uparrow\uparrow (2\uparrow\uparrow 65536 - 1) - 2, 0, 0\)

...

stage \(2\uparrow\uparrow (2\uparrow\uparrow 65536) + 17 : 0,0,0,0\)

We now eliminate one of the three trivial 2-splittings below X, and let a,b,c be the tree

(...(x, (...(x, (...(X)...) with 1+a, 1+b, and 1+c left parentheses.

\(2\uparrow\uparrow (2\uparrow\uparrow 65536)+18: 0, 0, 2\uparrow\uparrow (2\uparrow\uparrow 65536)\)

\(2\uparrow\uparrow (2\uparrow\uparrow (2\uparrow\uparrow 65536) + 1) + 16: 0, 2\uparrow\uparrow (2\uparrow\uparrow (2\uparrow\uparrow 65536) + 1) - 2, 0\)

\(2\uparrow\uparrow(2\uparrow\uparrow(2\uparrow\uparrow65536) + 2) + 14: 0, 0, 0\)

We next eliminate the remaining two trivial 2-splittings below X, which does not increase the stage by that much (to more than \(2\uparrow\uparrow(2\uparrow\uparrow(2\uparrow\uparrow65536) + 3) \)) until we finally arrive at X.

The next tree after X is

(x, (x, ... (x, (x, ((x), ((x), (((((x)), (x))))))))...))

followed by

(x, (x, ... (x, (((((x), ((x), (((((x)), (x)))))))))...))

where the number of trivial 2-splittings is more than \(2\uparrow\uparrow(2\uparrow\uparrow2\uparrow\uparrow65536+3) / 2\). We now turn to the fast-growing hierarchy, defined by

\(F_0 (x) = x+1\)

\(F_{a+1} (x) = (F_a)^x (x)\)

\(F_a (x) = F_{a[x]} (x)\) for a limit

We have seen that each additional trivial 2-splitting ascends the fast-growing hierarchy by one level; in particular, 0,0,...,3 with n parameters is greater than \(F_{n-1} (n-1) = F_{\omega} (n-1)\). Since our last tree is 0,0,...,3 with more than \(2\uparrow\uparrow2\uparrow\uparrow2\uparrow\uparrow65536 + 1\) parameters, we reach a stage of more than \(F_{\omega} (2\uparrow\uparrow2\uparrow\uparrow2\uparrow\uparrow65536)\) before we finally reach the tree

((x), ((x), (((((x)), (x))))))

The following tree is

((x), (x, (x, ..., (x, ((x), ((((x)), (x)))))...)))

where there are more than \(F_{\omega} (2\uparrow\uparrow2\uparrow\uparrow2\uparrow\uparrow65536)\) trivial 2-splittings in between the two (x)'s.

We can abbreviate this with the notation |0, 0, ... 0, where the | indicates the initial (x) in the tree. We achieve an ascending hierarchy much like above, except this time when we have the notation |a, b, ... with a > 0, we do not simply decrement to |a-1, b, ..., but rather go to 0, 0, ... 0|a-1, b... . That is, we decrement a by 1, then add as many trivial 2-splittings as we can below the initial (x). We have already seen that n trivial 2-splittings at the bottom leads to a sequence of more than F_omega (n-2) trees. So decrementing the nth parameter to the right of | for the mth time will increase the previous parameter by more than F_(omega+n) (m). We have more than \(F_{\omega} (2\uparrow\uparrow2\uparrow\uparrow2\uparrow\uparrow65536)\) parameters to the right of | leading to a sequence of more than

\(F_{\omega*2} (F_{\omega} (2\uparrow\uparrow2\uparrow\uparrow2\uparrow\uparrow65536))\) trees.

The next trees are

((x), ((x), ((((x)), (x)))))

((x), (x, (x, ... (x, ((x), (((x)), (x))))...)))

and by the same argument as before, this leads to a sequence of about \(F_{\omega*2} (n)\) trees. Our stage is now more than

\(F_{\omega*2} (F_{\omega*2} (F_{\omega} (2\uparrow\uparrow2\uparrow\uparrow2\uparrow\uparrow65536)))\).

Next, we remove the second (x):

((x), ((x), (((x)), (x))))

((x), (x, (x, ... (x, (((x)), (x)))...)))

leading to a sequence of more than

\(F_{\omega*2} (F_{\omega*2} (F_{\omega*2} (F_{\omega} (2\uparrow\uparrow2\uparrow\uparrow2\uparrow\uparrow65536))))\) trees.

Our sequence continues:

((x), (((x)), (x)))

...

(((x)), (x))

((x), ((x), ((x), ... ((x), (((x)), x)))...)))

Now, we have an unimaginable number of 2-splittings with (x) as the left member. In our notation, this would be ||...| with a large number of |'s; each | represents an omega level of the fast-growing hierarchy. This leads to more than F_(omega*n) (n) = F_(omega^2) (n) trees, where n is a few less than the number of two-splittings. So we arrive at more than

\(F_{\omega^2} (F_{\omega*2} (F_{\omega*2} (F_{\omega*2} (F_{\omega} (2\uparrow\uparrow2\uparrow\uparrow2\uparrow\uparrow65536)))))\) trees.

Finally, we reduce to

(((x)), x)

((x), ((x), ... ((x), x))...))

which again results in \(F_{\omega^2} (n)\) trees, so we arrive at a final number of more than

\(F_{\omega^2} (F_{\omega^2} (F_{\omega*2} (F_{\omega*2} (F_{\omega*2} (F_{\omega} (2\uparrow\uparrow2\uparrow\uparrow2\uparrow\uparrow65536))))))\) trees.