関数TREE（k）は、最長のツリーシーケンスT ₁、T ₂、... の長さを示します。各頂点にはk色のいずれかでラベルが付けられ、ツリーT _iには最大でi個の頂点があり、ツリーはありませんシーケンス内でそれに続くツリーのマイナー。

TREE（1）= 1、たとえばT ₁ = (1)。

TREE（2）= 3：例えばT ₁ = (1); T ₂ = (2)--(2); T ₃ = (2)。

TREE（3）は大きな大きな数字です。グラハムの数よりもさらに大きい。あなたの仕事は、それよりもさらに大きな数を出力することです！

これはコードゴルフなので、目標はTREE（3）以上の値を（stdoutに）確定的に出力する言語で最短のプログラムを作成することです。

• 入力を許可されていません。
• プログラムは最終的に終了する必要がありますが、マシンのメモリは無限にあると想定できます。
• あなたの言語の数値型は任意の有限値を保持できると仮定するかもしれませんが、これがあなたの言語でどのように正確に機能するかを説明する必要があります（例：浮動小数点数は無限の精度を持っていますか？）
  • 出力として無限は許可されません。
  • 数値型のアンダーフローは例外をスローします。ラップアラウンドしません。
• そのためTREE（3）が使用できるように複素数で急速に成長する階層 F近似_{（Ωθを^ω ω）1}拍の数（3）。
• （保存するのに十分なメモリとはコンピュータが存在しないので、あなたはあなたのソリューションが有効であるかどうかを確認するためにあなたの数がとても大きく、あなたのコードのungolfedバージョンである理由の説明を提供する必要がありますTREE（3） ）

注：ここで現在見つかっている答えはどれも機能しません。

なぜTREE（3）はそんなに大きいのですか？

新しいルビー、135バイト、>> H _{ψ（φ 3（Ω+ 1））}（9）

ここで、HはHardy階層、ψはMadoreのOCFの拡張バージョン（以下で説明します）、φはVeblen関数です。

オンラインでお試しください！

f=->a,n,b=a{c,d,e=a;a==c ?a-1:e ?a==a-[0]?[[c,d,f[e,n,b]],d-1,c]:c:[n<1||c==0?n:[f[c||b,n-1]],n,n]};h=[],k=9,k;h=f[h,p(k*=k)]while h!=0

Ungolfed：（ラムダではなく関数を使用）

def f(a,n,b)
  c,d,e = a
  if a == c
    return a-1
  elsif e
    if a == a-[0]
      return [[c,d,f(e,n,b)],d-1,c]
    else
      return c
    end
  else
    x = c || b
    if n < 1 || c == 0
      return [n,n,n]
    else
      return [f(x,n-1,x),n,n]
    end
  end
end

k = 9
h = [[],k,k]
while (h != 0) do
  k *= k
  p k
  h = f(h,k,h)
end

Madoreの拡張OCF：

そして（粗い）Veblenのファイ関数：

序数のない説明：

f(a,n,b) reduces an array recursively. (if no third argument given, it takes the first argument twice.)
f(k,n,b) = k-1, k is a positive int.
f([c,d,0],n,b) = f([c,0,e],n,b) = c
f([c,d,e],n,b) = [[c,d,f(e,n,b)],d-1,c], d ≠ -1 and c ≠ 0

f([a],0,b) = [0,0,0]
f([0],n,b) = [n,n,n]
f([],n,b) = f([b],n,b)
f([a],n,b) = [f[a,n-1,a],n,n]

私のプログラムが始まりk = 9, h = [[],9,9]ます。その後、適用されk = k*k、h = f(h,k)until h == 0およびoutputになりますk。

序数による説明：

Ordinals follow the following representation: n, [], [a], [a,b,c], where n,d is a natural number and a,c are all ordinals.
x = Ord(y) if y is the syntactic version of x.
a[n,b] = Ord(f(a,n))
ω = Ord([0]) = Ord(f([a],-1,b))
n = Ord(n)
Ω = Ord([])
ψ'(a) = Ord([a])
ψ'(a)[n] = Ord(f([a],n))
φ(b,c) ≈ Ord([[0],b,c])
a(↓b)c = Ord([a,b,c]) (down-arrows/backwards associative hyper operators I designed just for ordinals)

We follow the following FS for our ordinals:
k[n,b] = k-1, k < ω
ω[n,b] = n(↓n)n
(a(↓b)0)[n,b] = (a(↓0)c)[n,b] = a
(a(↓b)c)[n,b] = (a(↓b)(c[n,b]))(↓b[n,b])a, b ≥ 0 and c > 0.
ψ'(a)[0,b] = 0(↓0)0
ψ'(a)[n,b] = (ψ'(a[n-1,a]))(↓n)ω, a > 0 and n ≥ 0. (also note that we've changed from [n,b] to [n,a].)
Ω[n,b] = ψ'(b)[n,b]

ψ '（ω∙α）≈ψ（α）、上の画像で説明した順序崩壊関数。

私のプログラムは多かれ少なかれ開始k = 9してh = Ω(↑9)9、それから適用しk ← k²、h ← h[k,h]終わるまでh = 1戻りますk。

私はこの権利をしたそうであれば、[[],9,9]バックマン・ハワード序ψ（Ωより道大きい^{Ω Ω ...} θより道大きい）、（Ω ^ω ω）+1。

ψ（Ω（↓9）9）>ψ（Ω（↓4）3）>ψ（Ω ^{Ω Ω}）+1>ψ（Ω ^{Ω ω ω}）+1>θ（Ω ^ω ω）+1

私の分析が正しいかどうかと、我々はψ '（Ω持っている必要があり^Ω ∙x）は〜=ψ*（Ω ^Ω ψ*が通常MadoreのPSI機能である∙X）を、。これが成立する場合は、その後、私の序数は約ψである*（φ ₃（Ω+ω））。

旧ルビー、309バイト、H _{ψ」0（Ω 9）}（9）（参照改訂履歴を新しいものには方法が優れているほか、）

Haskell、252バイト、TREE（3）+1

data T=T[T]Int
l(T n _)=1+sum(l<$>n)
a@(T n c)#T m d=any(a#)m||c==d&&n!m
l@(x:t)!(y:u)=l!u||x#y&&t!u
x!_=null x
a n=do x<-[1..n];T<$>mapM(\_->a$n-1)[2..x]<*>[1..3]
s 0=[[]]
s n=[t:p|p<-s$n-1,t<-a n,(l t<=n)>any(#t)p]
main=print$[x|x<-[0..],null$s x]!!0

H.PWiz、Laikoni、およびØrjanJohansenからコードのゴルフを手伝ってくれてありがとう！

HyperNeutrinoで示唆されているように、私のプログラムは正確にTREE（3）+1を出力します（TREEは結果的に計算可能です）。

T n cは、ラベルcとノードを持つツリーnです。cあるべき1、2または3。

l tは、ツリー内のノードの数ですt。

t1 # t2（ここの定義4.4に基づいて）t1同相的に埋め込む場合はtrue、そうでない場合はfalseです。t2

a nツリーの大きなリストを出力します。正確なリストは重要ではありません。重要な特性は、それがあるa nにすべてのツリーを含んでいるnで標識されたノードと、ノード1、2または3、そしておそらくいくつかのより多くの樹木だけでなく（しかし、それらの他の木もで標識される1、2または3）。有限リストの出力も保証されています。

s nnツリーのすべてのシーケンスの長さをリストします。その結果、そのシーケンスの逆（逆方向に構築するため）が有効になります。n番目の要素（1でカウントを開始する）に最大でn個のノードがあり、ツリーが同相的に後のノードに埋め込まれていない場合、シーケンスは有効です。

mainnは、長さの有効なシーケンスがないように最小のものを出力しnます。

以来TREE(3)最長の有効なシーケンスの長さとして定義され、TREE(3)+1最も小さいn長さの有効なシーケンスが存在しないようなnものを私のプログラムの出力です、。

パイソン2、194バイト、〜H _{ψ（Ω ^{Ω Ω}）}（9）

ここで、HはHardy階層、ψはPohlersによって定義されたBachmann-Howard順序の下の順序崩壊関数です。

-3バイトのJonathan Frechに感謝します。

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 = Uの場合= 1else [R（U）] * c + V Uの場合V
A = [[[1,1]、1]、0]
c = 9
一方、A：A = R（A）; c * = c
印刷c

オンラインでお試しください！

より良い間隔のバージョン：

def S（T）：
  T == 1の場合は0を返し、それ以外の場合は[S（T [0]）] + T [1：]

def R（T）：
  U = T [0]
  V = T [1：]
  グローバルB
  T [-1] == 0の場合：
    B = T
  U == 1の場合： 
    return [S（B）] + V
  Uの場合[R（U）] * c + Vを返し、そうでない場合はV

A = [[[1,1]、1]、0]
c = 9
A：
  A = R（A）
  c * = c
印刷c

説明：

このプログラムは、0と1のラベルだけを使用して、Buchholz hydraのバリアントを実装します。基本的に、各ステップで、ツリーの最初の葉ノードを調べ、0または1のラベルが付いているかどうかを確認します。

-リーフノードに0のラベルが付いている場合、リーフノードを削除し、リーフノードの親からc回ツリーをコピーします。すべてのコピーはリーフノードの祖父母に接続されます。

-リーフノードに1のラベルが付いている場合、0のラベルが付いた祖先ノードに到達するまでルートに向かって検索します。Sをその祖先ノードから始まるツリーとします。SをSとし、リーフノードのラベルを0に変更します。リーフノードをS 'に置き換えます。

次に、ルートノードのみが残るまでプロセスを繰り返します。

このプログラムは、2つの点で通常のBuchholz hydraプロシージャと異なります。まず、上記のプロシージャを実行した後、ツリーを再帰的に戻し、元のリーフノードの各祖先ノードに対して上記のラベル0コピープロシージャを実行します。これにより木のサイズが大きくなるため、この手順は通常のブッフホルツのヒドラよりも時間がかかり、最終的にはより大きな数になります。ただし、新しいツリーに関連付けられた序数は古いツリーよりも小さいため、終了します。もう1つの違いは、c = 1から始めて毎回1ずつ増やすのではなく、c = 9から始めて毎回2乗することです。

ツリー[[[1,1]、1]、0]序ψ（Ωに対応^{Ω Ω}序θよりもかなり大きい）、（Ω ^ω私たちは、Hの程度の最終的な数得られたω）、およびSO _{ψを（Ω ^{Ω Ω}）}（9）は、間違いなくTREE（3）を超えるであろう。

ルビー、140バイト、〜H _{ψ（Ω ^{Ω Ω}）}（81）

ここで、Hはハーディ階層であり、ψはここで定義されているように、バッハマン-ハワード順序の下の標準順序崩壊関数です。

s=->t{*v,u=t;t==1?[]:v<<s[u]}
r=->t{*v,u=t;$b=t[0][0]?$b:t;u==1?v<<s[$b]:u[0]?v+[r[u]]*$c:v}
$c=9
a=[],[1,[1,1]]
($c*=9;a=r[a])while a[0]
$c

オンラインでお試しください！

ゴルフされていないバージョン：

def S（a）
  * v、u = a
  a == 1の場合 
    []を返す
  他に
    return v + [S（u）]
  終わり
終わり  

def R（t）
  * v、u = t
  t [0] == []の場合
    $ b = t
  終わり
  u == 1の場合
    return v + [S（$ b）]
  elsif u == []
    戻りv
  他に
    return v + [R（u）] * $ c
  終わり
終わり

$ c = 9

a = [[]、[1、[1,1]]]

一方、！= [] do
  $ c * = 9
  a = R（a）
終わり

$ cを印刷

このプログラムは、Python 2のエントリで説明されているように、[]と1でラベル付けされたノードでBuchholz hydraを実装します。

序ψ（Ωにツリー[]、[1、[1,1]]]相当^{Ω Ω}序θ（Ωよりもかなり大きい）、^ω ω）=ψ（Ω ^{Ω ω ω}）、及び私たちは、Hについての最終的な数得られるよう_{ψ（Ω ^{Ω Ω}）}（81）TREE（3）を超えるであろう。

ジュリア、569バイト、ローダーの番号

r,/,a=0,div,0;¬x=x/2;r<s=r?s:0;y\x=y-~y<<x;+x=global r=(x%2!=0)<1+(+¬x);!x=¬x>>+x;√x=S(4,13,-4,x);S(v,y,c,t)=(!t;f=x=r;f!=2?f>2?f!=v?t-(f>v)%2*c:y:f\(S(v,y,c,!x)\S(v+2,t=√y,c,+x)):S(v,y,c,!x)$S(v,y,c,+x));y$x=!y!=1?5<<y\x:S(4,x,4,+r);D(x)=(c=0;t=7;u=14;while(x!=0&&D(x-1);(x=¬x)%2!=0)d=!!D(x);f=!r;x=!r;c==r<((!u!=0||!r!=f||(x=¬x)%2!=0)<(u=S(4,d,4,r);t=t$d);¬f&(x=¬x)%2!=0<(c=d\c;t=√t;u=√u));(c!=0&&(x=¬x)%2!=0)<(t=((~u&2|(x=¬x)%2!=0)<(u=1<<(!c\u)))\(!c\t);c=r);¬u&(x=¬x)%2!=0<(c=t\c;u=√t;t=9)end;global a=(t\(u\(x\c)))\a);D(D(D(D(D(BigInt(99))))))

少し手間を省くために、Loader.cをほぼ1対1でJuliaに移植し、上記のコードブロックに圧縮することにしました。比較を自分で行いたい（自分のスコアを確認する、ミスを見つけたり、コードを改善する）ために、未使用のバージョンを以下に示します。

r,/,a=0,div,0;
¬x=x/2;
r<s=r?s:0;
y\x=y-~y<<x;
+x=global r=(x%2!=0)<1+(+¬x);
!x=¬x>>+x;
√x=S(4,13,-4,x);
S(v,y,c,t)=(
    !t;
    f=x=r;
    f!=2?
        f>2?
            f!=v?
                t-(f>v)%2*c
                :y
            :f\(S(v,y,c,!x)\S(v+2,t=√y,c,+x))
        :S(v,y,c,!x)$S(v,y,c,+x)
);
y$x=!y!=1?5<<y\x:S(4,x,4,+r);
D(x)=(
    c=0;
    t=7;
    u=14;
    while(x!=0&&D(x-1);(x=¬x)%2!=0) 
        d=!!D(x);
        f=!r;
        x=!r;
        c==r<(
            (!u!=0||!r!=f||(x=¬x)%2!=0)<(
                u=S(4,d,4,r);
                t=t$d
            );
            ¬f&(x=¬x)%2!=0<(
                c=d\c;
                t=√t;
                u=√u
            )
        );
        (c!=0&&(x=¬x)%2!=0)<(
            t=((~u&2|(x=¬x)%2!=0)<(u=1<<(!c\u)))\(!c\t);
            c=r
        );
        ¬u&(x=¬x)%2!=0<(
            c=t\c;
            u=√t;
            t=9
        )
    end;
    global a=(t\(u\(x\c)))\a
);
D(D(D(D(D(BigInt(99))))))

過去のカウントはありません。アグレッシブゴルフでバイトミスカウントが多すぎるためです。

JavaScript、190B、Hψ _（ εΩ _{+ 1）}（9）_{この分析に基づく}

A=[0,1,2];B=[0,1,2];for(F=C=9;F;F--){for(C++,G=0;G<=F;G++)(A[F]||A[F-G]<A[F]-H)&&(B[F]?(I=G,G=F):(H=A[F]-A[F-G],B[F-G]<B[F]&&(I=G,G=F)));for(J=0;J<C*I;J++)A[F]=A[F-I]+H,B[F]=B[F-I],F++;H=0}C

このプログラムは、JavaScriptでのこの225Bペアシーケンス番号変換の修正バージョンです。ペアシーケンス番号と元のコードについては、こちらをご覧ください。

行われた変更：

• それはBASICではなくJavaScriptです。
• （F反復無し_{ψ（Ωはω +1）} - > F _{ψ（Ωのω）}）
• シーケンスは（0,0）（1,1）（2,2）で、これは序数ψ（εΩ _{+ 1}）に対応します。_{これは、ハーディ階層序数です}