La funzione ALBERO (k) fornisce la lunghezza della più lunga sequenza di alberi T ₁ , T ₂ , ... dove ogni vertice è etichettato con uno dei colori k, l'albero T _i ha al massimo i vertici, e non è un albero minore di qualsiasi albero che lo segue nella sequenza.

ALBERO (1) = 1, ad es. T ₁ = (1).

ALBERO (2) = 3: ad es. T ₁ = (1); T ₂ = (2)--(2); T ₃ = (2).

TREE (3) è un grande numero. Ancora più grande del numero di Graham. Il tuo compito è produrre un numero ancora più grande di quello!

Questo è un codice-golf, quindi l'obiettivo è quello di scrivere il programma più breve in qualsiasi lingua che determini in modo deterministico un numero maggiore o uguale a TREE (3) (allo stdout).

• Non puoi ricevere input.
• Alla fine il tuo programma deve terminare ma puoi presumere che la macchina abbia una memoria infinita.
• Potresti supporre che il tipo di numero della tua lingua possa contenere qualsiasi valore finito ma devi spiegare come funziona esattamente nella tua lingua (es: un float ha una precisione infinita?)
  • Gli infiniti non sono ammessi come output.
  • Underflow di un tipo di numero genera un'eccezione. Non si avvolge.
• Poiché TREE (3) è un numero così complesso, puoi usare l' approssimazione della gerarchia in rapida crescita f _{ϑ (Ω ^ω ω) +1} (3) come numero da battere.
• Devi fornire una spiegazione del perché il tuo numero è così grande e una versione non modificata del tuo codice per verificare se la tua soluzione è valida (poiché non esiste un computer con memoria sufficiente per memorizzare TREE (3) )

Nota: nessuna delle risposte attualmente trovate qui funziona.

Perché TREE (3) è così grande?

Nuovo Ruby, 135 byte, >> H _{ψ (φ 3 (Ω + 1))} (9)

dove H è la gerarchia di Hardy, ψ è una versione estesa dell'OCF di Madore (spiegheremo di seguito) e φ è la funzione Veblen.

Provalo online!

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: (usando funzioni, non lambdas)

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

L'OCF esteso di Madore:

E (rozzamente) la funzione phi di Veblen:

Spiegazione senza ordinali:

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]

Il mio programma si avvia k = 9, h = [[],9,9]. Si applica quindi k = k*ke h = f(h,k)fino a quando h == 0e output k.

Spiegazione con ordinali:

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]

ψ '(ω ∙ α) ≈ ψ (α), la funzione di collasso ordinale descritta nell'immagine sopra.

Il mio programma avvia più o meno k = 9e h = Ω(↑9)9, quindi, si applica k ← k²e h ← h[k,h]fino a quando h = 1e ritorna k.

E quindi se ho fatto bene, [[],9,9]è molto più grande dell'ordinale di Bachmann-Howard ψ (Ω ^{Ω Ω ...} ), che è molto più grande di ϑ (Ω ^ω ω) +1.

ψ (Ω (↓ 9) 9)> ψ (Ω (↓ 4) 3)> ψ (Ω ^{Ω Ω} ) +1> ψ (Ω ^{Ω ω ω} ) +1> ϑ (Ω ^ω ω) +1

E se la mia analisi è corretta, allora dovremmo avere ψ '(Ω ^Ω ∙ x) ~ = ψ * (Ω ^Ω ∙ x), dove ψ * è la normale funzione psi di Madore. Se questo vale, allora il mio ordinale è approssimativamente ψ * (φ ₃ (Ω + ω)).

Old Ruby, 309 byte, H _{ψ ' 0 (Ω 9 )} (9) (vedere la cronologia delle revisioni , oltre a quella nuova è molto meglio)

Haskell, 252 byte, 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

Grazie per l'aiuto di H.PWiz, Laikoni e Ørjan Johansen per l'aiuto nel golfare il codice!

Come suggerito da HyperNeutrino , il mio programma genera TREE (3) +1, esattamente (TREE è calcolabile a quanto pare).

T n cè un albero con etichetta ce nodi n. cdovrebbe essere 1, 2o 3.

l tè il numero di nodi in un albero t.

t1 # t2è vero se si t1integra omeomorficamente t2( in base alla definizione 4.4 qui ) e falso altrimenti.

a ngenera un grande elenco di alberi. L'elenco esatto non è importante. La proprietà importante è che a ncontiene ogni albero fino a nnodi, con i nodi di essere etichettati con 1, 2, o 3, e forse alcuni più alberi così (ma quegli altri alberi saranno etichettati con 1, 2o 3). È inoltre garantito l'output di un elenco finito.

s nelenca tutte le sequenze ndi alberi, in modo tale che sia valido il contrario (poiché lo costruiamo all'indietro) di quella sequenza. Una sequenza è valida se l'ennesimo elemento (dove iniziamo a contare da 1) ha al massimo n nodi e nessun albero omeomorficamente si incorpora in uno successivo.

mainstampa il più piccolo in modo ntale che non vi siano sequenze valide di lunghezza n.

Poiché TREE(3)è definita come la lunghezza della sequenza valida più lunga, TREE(3)+1è la più piccola in modo ntale che non ci siano sequenze valide di lunghezza n, che è ciò che il mio programma genera.

Python 2, 194 byte, ~ H _{ψ (Ω ^{Ω Ω} )} (9)

dove H è la gerarchia di Hardy, e ψ è la funzione di collasso ordinale al di sotto dell'ordinale di Bachmann-Howard definito da Pohlers.

Grazie a Jonathan Frech per -3 byte.

def S (T): restituisce 0 se 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 se U == 1else [R (U)] * c + V se U altro V
A = [[[1,1], 1], 0]
c = 9
mentre A: A = R (A); c * = c
stampa c

Provalo online!

Versione con spaziatura migliore:

def S (T):
  ritorna 0 se T == 1 altro [S (T [0])] + T [1:]

def R (T):
  U = T [0]
  V = T [1:]
  globale B
  se T [-1] == 0:
    B = T
  se U == 1: 
    return [S (B)] + V
  restituisce [R (U)] * c + V se U altro V

A = [[[1,1], 1], 0]
c = 9
mentre A:
  A = R (A)
  c * = c
stampa c

Spiegazione:

Questo programma implementa una variante dell'idra di Buchholz , usando solo etichette di 0 e 1. Fondamentalmente, ad ogni passo, osserviamo il primo nodo foglia dell'albero e vediamo se è etichettato con uno 0 o un 1.

-Se il nodo foglia è etichettato con uno 0, quindi eliminiamo il nodo foglia e quindi copiamo l'albero partendo dal genitore del nodo foglia c volte, tutte le copie collegate al nonno del nodo foglia.

-Se il nodo foglia è etichettato con 1, allora cerchiamo di nuovo verso la radice fino a raggiungere un nodo antenato etichettato con 0. S sia l'albero a partire da quel nodo antenato. Sia S 'essere S con il nodo foglia rietichettato con 0. Sostituire il nodo foglia con S'.

Quindi ripetiamo il processo fino a quando non rimane altro che il nodo principale.

Questo programma differisce dalla normale procedura dell'idra di Buchholz in due modi: in primo luogo, dopo aver eseguito la procedura sopra descritta, eseguiamo nuovamente il backup dell'albero e eseguiamo la procedura di copia dell'etichetta 0 descritta sopra per ciascun nodo antenato del nodo foglia originale. Ciò aumenta le dimensioni dell'albero, quindi la nostra procedura richiederà più tempo della normale idra di Buchholz, e quindi porterà a un numero maggiore alla fine; tuttavia, terminerà comunque perché l'ordinale associato al nuovo albero sarà ancora meno il vecchio albero. L'altra differenza è, anziché iniziare con c = 1 e aumentando 1 ogni volta, iniziamo con c = 9 e lo quadriamo ogni volta, perché perché no.

L'albero [[[1,1], 1], 0] corrisponde all'ordinale ψ (Ω ^{Ω Ω} ), che è considerevolmente più grande dell'ordinale ϑ (Ω ^ω ω), e quindi il nostro numero finale risultante di circa H _{ψ (Ω ^{Ω Ω} )} (9) supererà sicuramente TREE (3).

Rubino, 140 byte, ~ H _{ψ (Ω ^{Ω Ω} )} (81)

dove H è la gerarchia di Hardy e ψ è la normale funzione di collasso ordinale sotto l'ordinale di Bachmann-Howard, come definito qui .

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

Provalo online!

Versione non golfata:

def S (a)
  * v, u = a
  se a == 1 
    ritorno []
  altro
    return v + [S (u)]
  fine
fine  

def R (t)
  * v, u = t
  if t [0] == []
    $ b = t
  fine
  se u == 1
    return v + [S ($ b)]
  elsif u == []
    ritorno v
  altro
    return v + [R (u)] * $ c
  fine
fine

$ c = 9

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

mentre a! = [] do
  $ c * = 9
  a = R (a)
fine

stampa $ c

Questo programma implementa l'idra di Buchholz con nodi etichettati con [] e 1, come descritto nella mia voce di Python 2.

L'albero [[], [1, [1,1]]] corrisponde all'ordinale ψ (Ω ^{Ω Ω} ), che è considerevolmente più grande dell'ordinale ϑ (Ω ^ω ω) = ψ (Ω ^{Ω ω ω} ), e quindi il nostro numero finale risultante di circa H _{ψ (Ω ^{Ω Ω} )} (81) supererà TREE (3).

Julia, 569 byte, numero del caricatore

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))))))

Per risparmiarmi un po 'di legwork, ho deciso di trasferire Loader.c su Julia quasi uno per uno e compattarlo nel blocco di codice sopra. Per coloro che vogliono fare i confronti da soli (sia per verificare il mio punteggio o per aiutarmi a trovare errori o migliorare il mio codice), una versione non modificata è di seguito:

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))))))

Nessun precedente conta perché ho fatto troppi conteggi errati di byte nel golf aggressivo che ho fatto.

JavaScript, 190B, H _{ψ (ε Ω + 1 )} (9) _{Basato su questa analisi}

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

Questo programma è una versione modificata di questa traduzione numerica della sequenza di coppie 225B in JavaScript . Per il numero di sequenza di coppie e il loro codice originale, vedere qui .

Le modifiche apportate:

• È in JavaScript anziché BASIC.
• Nessuna iterazione (f _{ψ (Ω ω +1)} -> f _{ψ (Ω ω )} )
• La sequenza è (0,0) (1,1) (2,2), che corrisponde all'ordinale ψ (ε _{Ω + 1} ). _{Questo è nella gerarchia di Hardy ordinale}