# Python 2, 194 bytes, ~ H<sub>ψ(Ω<sup>Ω<sup>Ω</sup></sup>)</sub>(9)

where **H** is the Hardy hierarchy, and **ψ** is the ordinal collapsing function below the Bachmann-Howard ordinal defined by Pohlers.

Thanks to Jonathan Frech for -3 bytes.

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

[Try it online!](https://repl.it/FyOe/10)

Better spaced version:

<pre>def S(T):
 return 0 if T==1 else [S(T[0])]+T[1:]

def R(T):
 U=T[0]
 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 else V
 
A=[[[1,1],1],0]
c=9
while A:
 A=R(A)
 c*=c
print c
</pre>

Explanation:

This program implements a variant of the [Buchholz hydra](http://googology.wikia.com/wiki/Buchholz_hydra), using just labels of 0 and 1. Basically, at each step, we look at the first leaf node of the tree, and see if it is labelled with a 0 or a 1.

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

-If the leaf node is labelled with a 1, then we search back towards the root until we reach an ancestor node labelled with a 0. Let S be the tree starting from that ancestor node. Let S' be S with the leaf node relabelled with 0. Replace the leaf node with S'.

We then repeat the process until we have nothing left but the root node.

This program differs from the normal Buchholz hydra procedure in two ways: First, after we do the above procedure, we recurse back up the tree, and do the label 0 copy procedure described above for each ancestor node of the original leaf node. This increases the size of the tree, so our procedure will take longer than the normal Buchholz hydra, and therefore lead to a bigger number in the end; however, it will still terminate because the ordinal associated with the new tree will still be less the the old tree. The other difference is, rather than start 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 ψ(Ω<sup>Ω<sup>Ω</sup></sup>), which is considerably bigger than the ordinal ϑ(Ω<sup>ω</sup>ω), and so our resulting final number of about H<sub>ψ(Ω<sup>Ω<sup>Ω</sup></sup>)</sub>(9) will definitely exceed TREE(3).