Функція TREE (k) дає довжину найдовшої послідовності дерев T ₁ , T ₂ , ... де кожна вершина позначена одним з k кольорів, дерево T _i має максимум i вершин, а жодне дерево не є другорядне будь-яке дерево, що слідує за ним у послідовності.

TREE (1) = 1, наприклад T ₁ = (1).

ДРЕВО (2) = 3: напр., T ₁ = (1); T ₂ = (2)--(2); T ₃ = (2).

ДРЕВО (3) - велика велика кількість. Навіть більше, ніж кількість Грема. Ваше завдання - вивести число навіть більше, ніж воно!

Це кодовий гольф, тому мета полягає в тому, щоб написати найкоротшу програму будь-якою мовою, яка детерміновано виводить число, що перевищує або рівне TREE (3) (до stdout).

• Вам не дозволяється приймати дані.
• Ваша програма повинна врешті-решт припинитися, але ви можете припустити, що машина має нескінченну пам'ять.
• Ви можете припустити, що тип вашої мови може містити будь-яке кінцеве значення, але потрібно пояснити, як саме це працює у вашій мові (наприклад: чи має float безмежна точність?)
  • Нескінченності не допускаються як вихід.
  • Під переповненням типу число випадає виняток. Він не загортається.
• Оскільки TREE (3) - це таке складне число, ви можете використовувати швидко зростаючу ієрархічну апроксимацію f _{ϑ (Ω ^ω ω) +1} (3) як число, яке потрібно перебити.
• Вам потрібно надати пояснення, чому ваш номер настільки великий, і необоротна версія вашого коду, щоб перевірити, чи ваше рішення є дійсним (оскільки немає комп'ютера з достатньою пам’яттю для зберігання TREE (3) )

Примітка: жодна з нині знайдених відповідей тут не працює.

Чому ТРЕЙ (3) такий великий?

Новий Ruby, 135 байт, >> H _{ψ (φ 3 (Ω + 1))} (9)

де H - ієрархія Харді, ψ - це розширена версія OCF Мадора (пояснимо нижче), а φ - функція Веблена.

Спробуйте в Інтернеті!

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

Невольф: (використовуючи функції, а не лямбда)

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

Розширений OCF Мадора:

І (грубо) фіб функція Веблена:

Пояснення без порядків:

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)до, h == 0і виводить 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) ~ = ψ * (Ω ^Ω ∙ x), де ψ * - нормальна пси-функція Мадора. Якщо це справедливо, то моя порядкова величина приблизно ψ * (φ ₃ (Ω + ω)).

Old Ruby, 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 та Ørjan Johansen за допомогу в гольфі в коді!

Як запропонував HyperNeutrino , моя програма точно виводить TREE (3) +1 (TREE обчислюється, як виявляється).

T n c- дерево з міткою cта вузлами n. cмає бути 1, 2або 3.

l t- кількість вузлів на дереві t.

t1 # t2вірно, якщо t1гомеоморфно вбудовується t2(на основі визначення тут 4.4 ), а помилково - інакше.

a nвиводить великий список дерев. Точний список не важливий. Важливою властивістю є те , що a nмістить кожне дерево до nвузлів, з вузлами, міченим 1, 2, або 3, і , можливо , ще кілька дерев , а також (але ці інші дерева також будуть позначені 1, 2або 3). Також гарантується виведення кінцевого списку.

s nперераховує всі довжини nдерев послідовностей , так що зворотний (оскільки ми будуємо його назад) цієї послідовності є дійсним. Послідовність є дійсною, якщо n-й елемент (де ми починаємо рахувати з 1) має не більше n вузлів, і жодне дерево гомеоморфно не вбудовується у більш пізній.

mainвиводить найменший n, щоб не було дійсних послідовностей довжини n.

Оскільки TREE(3)визначається як довжина найдовшої дійсної послідовності, TREE(3)+1є найменшою nтакою, що немає дійсних послідовностей довжини n, що і видає моя програма.

Python 2, 194 байт, ~ H _{ψ (Ω ^{Ω Ω} )} (9)

де H - ієрархія Харді, а ψ - порядкова функція згортання нижче порядкового порядка Бахмана-Говарда, визначеного Полером.

Завдяки Джонатану Фреху за -3 байти.

def S (T): повернути 0if T == 1else [S (T [0])] + T [1:]
def R (T): U = T [0]; V = T [1:]; exec "глобальний B; B = T" * (T [-1] == 0); повернути [S (B)] + V, якщо U == 1else [R (U)] * c + V, якщо U else V
A = [[[1,1], 1], 0]
c = 9
а A: A = R (A); c * = c
друк c

Спробуйте в Інтернеті!

Краще розташована версія:

def S (T):
  повернути 0, якщо T == 1 інше [S (T [0])] + T [1:]

def R (T):
  U = T [0]
  V = T [1:]
  глобальний В
  якщо T [-1] == 0:
    B = T
  якщо U == 1: 
    повернення [S (B)] + V
  повернути [R (U)] * c + V, якщо U else V

A = [[[1,1], 1], 0]
c = 9
а A:
  A = R (A)
  c * = c
друк c

Пояснення:

Ця програма реалізує варіант гідри Бухгольца , використовуючи лише мітки 0 і 1. В основному на кожному кроці ми дивимось на перший вузол листя дерева і бачимо, чи він позначений позначкою 0 або 1.

-Якщо вузол листя позначений 0, ми видаляємо вузол листка, а потім копіюємо дерево, починаючи з батьківського вузла листка c разів, всі копії, підключені до бабусі та дідуся з листового вузла.

-Якщо вузол листків позначений знаком 1, то ми шукаємо назад до кореня, поки не досягнемо вузла предка, позначеного знаком 0. Нехай S - дерево, починаючи з цього вузла предка. Нехай S 'буде S, коли вузол листка позначається на 0. Замініть листовий вузол на S'.

Потім ми повторюємо процес, поки у нас не залишиться нічого, крім кореневого вузла.

Ця програма відрізняється від звичайної процедури гідра Бухгольца двома способами: По-перше, після того, як ми виконаємо вищевказану процедуру, ми повторно створимо резервне копіювання дерева та зробимо процедуру копіювання ярлика 0, описану вище, для кожного вузла предка вихідного вузла листя. Це збільшує розміри дерева, тому наша процедура займе більше часу, ніж звичайна гідра Бухгольца, і тому в кінцевому підсумку призведе до більшої кількості; однак воно все одно припиниться, оскільки порядкова, пов’язана з новим деревом, все ще буде меншою, ніж старе дерево. Інша відмінність, а не починати з c = 1 і збільшувати 1 кожен раз, ми починаємо з c = 9 і кожен раз його квадратуємо, бо чому б ні.

Дерево [[[1,1], 1], 0] відповідає порядковій ψ (Ω ^{Ω Ω} ), яка значно більша за порядкову ϑ (Ω ^ω ω), і тому отримане нами кінцеве число приблизно H _{ψ (Ω ^{Ω Ω} )} (9), безумовно, перевищить TREE (3).

Ruby, 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 
    повернути []
  ще
    повернути v + [S (u)]
  кінець
кінець  

def R (t)
  * v, u = t
  якщо t [0] == []
    $ b = t
  кінець
  якщо u == 1
    повернути v + [S ($ b)]
  elsif u == []
    повернути v
  ще
    повернути v + [R (u)] * $ c
  кінець
кінець

$ c = 9

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

а a! = [] робити
  $ c * = 9
  a = R (a)
кінець

друкувати $ c

Ця програма реалізує гідру Бухгольца з вузлами, позначеними символами [] та 1, як описано в моєму записі Python 2.

Дерево [[], [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 на Джулію майже один на один і зафіксувати її в блоці коду, що знаходиться вище. Для тих, хто хоче зробити порівняння самостійно (або для перевірки моєї оцінки, або для того, щоб допомогти мені знайти помилки або покращити код), нижче наведена версія нефабрикованої версії:

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

Ця програма є видозміненою версією цього перекладу номера 225B в послідовний переклад на JavaScript . Про номер послідовності пари та їх оригінальний код див. Тут .

Зроблені зміни:

• Це в JavaScript замість BASIC.
• Без ітерації (f _{ψ (Ω ω +1)} -> f _{ψ (Ω ω )} )
• Послідовність дорівнює (0,0) (1,1) (2,2), що відповідає порядковій ψ (ε _{Ω + 1} ). _{Це в порядковій ієрархії Харді}