Il sistema di numeri ordinali è un sistema con numeri infiniti. Molti numeri infiniti. Tanti numeri infiniti che letteralmente non ha un infinito per rappresentare la propria infinità. L'immagine in alto dà una piccola idea di come funzionano. Un numero ordinale ( costruzione di Von Neumann ) è un insieme di ordinali precedenti. Ad esempio, 0 è l'insieme vuoto, 1 è l'insieme {0}, 2 è l'insieme {0, 1} e così via. Quindi arriviamo a ω, che è {0, 1, 2, 3 ...}. ω + 1 è {0, 1, 2, 3 ... ω}, ω volte due è {0, 1, 2 ... ω, ω + 1, ω + 2 ...} e continui ad andare avanti come quella.

Il tuo programma produrrà una serie di ordinali, come {0, 1, 4}. Il tuo punteggio sarà quindi il meno ordinale più di tutto l'ordinale nel tuo set. Per {0, 1, 4} il punteggio sarebbe 5. Per {0, 1, 2 ...}, il punteggio sarebbe ω.

In che modo produci i tuoi ordinali che chiedi. Codice ovviamente Vale a dire, il tuo programma produrrà un elenco potenzialmente infinito di altri programmi, tra virgolette, uno su ogni riga (usa la stringa letterale "\ n" per rappresentare nuove righe). Un programma corrisponde al suo punteggio come indicato sopra. Ad esempio, se si esegue l'output

"A"
"B"
"C"

dove A, B e C sono risposte valide e hanno punteggi {0, 1, 4}, il punteggio del tuo programma sarebbe 5. Nota che A, B e C devono essere programmi completi, non frammenti.

Sulla base delle regole precedenti, un programma che non emette nulla ha un punteggio di 0 (il minimo ordinale maggiore di tutto {} è 0). Inoltre, ricorda che un insieme non può contenere se stesso, tramite l' assioma della fondazione . Vale a dire, ogni set (e quindi ordinale) ha un percorso fino a zero. Ciò significa che un full-quine non sarebbe valido in quanto non è un set.

Inoltre, nessun programma è autorizzato ad accedere a risorse esterne (il proprio file, Internet ecc ...). Inoltre, quando elenchi il tuo punteggio, metti la forma normale del cantor accanto a essa se non è già nella forma normale del cantor, se puoi (in caso contrario, qualcun altro può).

Dopo aver tenuto conto di tutto quanto sopra, la risposta effettiva che pubblichi deve essere inferiore a 1.000.000 di byte (senza contare i commenti). (Questo limite superiore probabilmente entrerà in gioco solo per il codice generato automaticamente). Inoltre, puoi aumentare il tuo punteggio per ogni byte che non usi (poiché abbiamo a che fare con gli infiniti, questo probabilmente verrà preso in considerazione solo quando gli ordinali sono molto vicini o uguali). Ancora una volta, questo paragrafo si applica solo alla risposta postata, non a quelle generate o generate da quelle generate, e così via.

Questo ha il tag quine, perché può essere utile generare almeno parte del codice proprio delle fonti, da usare per creare ordinali di grandi dimensioni. Tuttavia non è necessario (ad esempio, una presentazione con punteggio 5 probabilmente non avrebbe bisogno del proprio codice sorgente).

Per un esempio elaborato e annotato, vedere qui .

Haskell: ψ (Ω ^{Ω ω} ) + 999672 punti

main=print$f++shows f"$iterate(Z:@)Z";f="data N=Z|N:@N deriving Show;r=repeat;s Z=[];s(a:@Z)=r a;s(Z:@b)=($u b)<$>h b;s(a:@b)=do(f,c)<-h b`zip`s a;f<$>[c:@b,a]\nh=scanl(flip(.))id.t;t(Z:@Z)=r(:@Z);t(Z:@b)=((Z:@).)<$>t b;t(a:@b)=flip(:@).(:@b)<$>s a;u Z=Z;u(Z:@b)=u b;u(a:@_)=a;g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

329 byte di codice con ordinale ψ (Ω ^{Ω ω} ) + 1. Utilizza una rappresentazione ad albero di ordinali scoperta da Jervell (2005) . L'albero con i bambini α , β ,…, γ è indicato α :@ (β :@ (… :@ (γ :@ Z)…)). Questo ordine da sinistra a destra concorda con Jervell, sebbene si noti che Madore lo inverte da destra a sinistra.

Haskell: Γ ₀ + 999777 punti

main=print$f++shows f"$iterate((:[]).T)[]";f="data T=T[T]deriving(Eq,Ord,Show);r=reverse;s[]=[];s(T b:c)=(++c)<$>scanl(++)[](b>>cycle[fst(span(>=T b)c)++[T$r d]|d<-s$r b]);g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

224 byte di codice con ordinale Γ ₀ + 1. Questo si basa su una generalizzazione del worm di Beklemishev ad elementi a valori ordinali, che sono essi stessi rappresentati ricorsivamente dai worm.

Haskell: ε ₀ + 999853 punti

main=print$f++shows f"$map(:[])[0..]";f="s[]=[];s(0:a)=[a];s(a:b)=b:s(a:fst(span(>=a)b)++a-1:b);g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

148 byte di codice con ordinale ε ₀ + 1. È basato sul worm di Beklemishev . La lista

map(+1)α ++ [0] ++ map(+1)β ++ [0] ++ ⋯ ++ [0] ++ map(+1)γ

rappresenta l'ordinale (w ^y + ⋯ + w ^ß + w ^alfa ) - 1. Quindi le uscite di secondo livello [0], [1], [2],[3] , ... rappresentano 1, ω, ω ^ω , ω ^{ω ω} , ..., l'uscita di primo livello rappresenta ε ₀ e il programma iniziale rappresenta ε ₀ + 1.

Haskell: ε ₀ + 999807 punti

main=print$f++shows f"$iterate(:@Z)Z";f="data N=Z|N:@N deriving Show;s Z=[];s(Z:@b)=repeat b;s(a:@Z)=scanl(flip(:@))Z$s a;s(a:@b)=(a:@)<$>s b;g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

194 byte di codice con ordinale ε ₀ + 1.

Zrappresenta 0 e possiamo dimostrare mediante induzione transfinita su α , quindi su β , che α :@ β≥ ω ^α + β . Quindi ci sono uscite di secondo livello almeno grandi quanto qualsiasi torre ω ^{ω ⋰ ω} , il che significa che l'uscita di primo livello è almeno ε ₀ e il programma iniziale è almeno ε ₀ + 1.

Rubino, ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))}(0)) + 999663 punti

Supponendo che comprendo correttamente il mio programma, il mio punteggio è ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))} (0)) + 999663 punti in cui ψ è una funzione di collasso ordinale, X è il chi funzione (funzione collasso di Mahlo) e M è il primo Mahlo 'ordinale'.

Questo programma è un'estensione di quello che ho scritto su Golf un numero più grande di TREE (3) e assolutamente briscola per ora tutte le altre soluzioni qui.

z=->x,k{f=->a,n,b=a,q=n{c,d,e=a;!c ?q:a==c ?a-1:e==0||e&&d==0?c:e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:n<1?9:!d ?[f[b,n-1],c]:c==0?n:[t=[f[c,n],d],n,d==0?n:[f[d,n,b,t]]]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+";"};y)};h=-1;(0..1.0/0).map{|i|puts "puts \"#{z[[i,h=[h,h,h]],1]}\""}

Provalo online!

Rubino, ψ ₀ (ψ _I (I ^I )) + 999674 punti

z=->x,k{f=->a,n,b=a{c,d,e,q=a;a==c ?a-1:e==0||d==0?(q ?[c]:c):e ?[[c,d,f[e,n,b],q],f[d,n,b],c,q]:[n<1?9:d&&c==0?[d]:d ?[f[c,n],d]:[f[b,n-1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..1.0/0).map{|i|puts("puts(\"#{z[h=[h,h,h,0],1]}\")")}

Provalo online! (attenzione: non farà molto, dato che chiaramente (0..1.0/0).map{...}non può terminare. È così che stampo infinitamente anche molti programmi.)

Rubino, ψ ₀ (ψ _I (0)) + 999697 punti

z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..1.0/0).map{|i|h=[h];puts|i|puts("puts(\"#{z[hz[h=[h],1]}\")")}

Provalo online!

Un programma di test più ragionevole che implementa (0..5).map{...}invece:

z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..5).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..5).map{|i|h=[h];puts("puts(\"#{z[h,1]}\")")}

Provalo online!

Sfortunatamente, anche con (1..1).map{...}, troverai che questo programma richiede molta memoria. Voglio dire, la lunghezza dell'output supera cose come SCG (13).

Utilizzando il programma più semplice, possiamo prendere in considerazione alcuni valori:

a = value you want to enter in.
z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="x=#{f[x,k]};puts(x==0??p:"+w+"#{z[f[x,k],k*2+1]}"+w+");";y)};puts("puts(\"#{z[a,1]}\")")

Provalo online!

Fondamentalmente stampa ripetutamente lo stesso programma, nel formato di:

x=...;puts(x==0??p:"...");

dove l'inizializzato xregistra l'ordinale a cui è correlato il programma, e la "..."conservazione dei programmi dopo che xè stata ridotta. Se x==0, quindi stampa

p

che è un programma che non stampa nulla con un punteggio pari a zero, quindi

x=0;puts(x==0??p:"p");

ha un punteggio di 1 e

x=1;puts(x==0??p:"x=0;puts(x==0??p:\"p\");");

ha un punteggio di 2 e

x=2;puts(x==0??p:"x=1;puts(x==0??p:\"x=0;puts(x==0??p:\\\"p\\\");\");");

ha un punteggio di 3, ecc. e il mio programma originale stampa questi programmi nel formato

puts("...")

dove ...sono i programmi sopra elencati.

Il mio programma attuale in realtà stampa questi programmi nel formato

x=0;puts(x==0??p:"p;p;p;p;p;...");

Infinitamente molte volte, e per valori come ω, fa qualcosa di simile

x=ω;puts(x==0??p:"(x=0 program); (x=1 program); (x=2 program); ...")

E quindi, il punteggio del programma

x=(some_ordinal);puts(x==0??p:"...")

è 1+some_ordinal, e il punteggio di

puts("x=(some_ordinal);puts(x==0??p:\"...\")")

è 1+some_ordinal+1, e il punteggio di

z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};puts("puts(\"#{z[some_ordinal,1]}\")")

lo è 1+some_ordinal+2.

Spiegazione degli ordinali:

f[a,n,b]riduce un ordinale a.

Ogni numero naturale si riduce al numero naturale sottostante.

f[k,n,b] = k-1

[c,0,e]è il successore di ce si riduce sempre a c.

f[[c,0,e],n,b] = c

[c,d,e] è un'iperoperazione associativa arretrata, si riduce come segue:

f[[c,d,0],n,b] = c
f[[c,d,e],n,b] = [[c,d,f[e,n,b]],f[d,n,b],c]

[0] è il primo ordinale infinito (equivalente a ω) e si riduce come segue:

f[[0],0,b] = [9,0,0]
f[[0],n,b] = [n,n,n]

[c] è il cth omega ordinale e si riduce come segue:

f[[c],0,b] = [9,0,0]
f[[c],n,b] = [[f[b,n-1,b],f[c,n,b]],n,n]
Note the two-argument array here.

[c,d]è ψ _d (c) e si riduce come segue:

f[[c,d],0,b] = [9,0,0]
f[[0,d],n,b] = [[d],n,n]
f[[c,d],n,b] = [[f[c,n,c],d],n,n]

[c,d,e,0]è sostanzialmente lo stesso di [c,d,e], tranne per il fatto che enumera sopra l'operazione [c]anziché l'operazione successiva.

f[[c,0,e,0],n,b] = [c]
f[[c,d,0,0],n,b] = [c]
f[[c,d,e,0],n,b] = [[c,d,f[e,n,b],0],f[d,n,b],c,0]

Java + Brainf ***, ω + 999180 punti

Un programma java che produce infiniti programmi Brainf ***, ognuno dei quali produce l'ultimo come output.

Perché? Perché io posso.

Eventuali miglioramenti alla parte della generazione Brainf *** sono sicuramente ben accetti.

import java.io.*;import java.util.*;import static java.lang.System.*;
class O{
    static String F(String s){
        String t="++++++++++++++++++++";
        List<Character> c=Arrays.asList('+','-','.','<','>','[',']');
        t+="[->++>++>++>+++>+++>++++>++++<<<<<<<]>+++>+++++>++++++>>++>+++++++++++>+++++++++++++";
        for(int x=0,i=6;x<s.length();x++){
            int d=c.indexOf(s.charAt(x)),k=d;
            while(d>i){d--;t+=">";}
            while(d<i){d++;t+="<";}
            t+=".";i=k;
        }return t;
    };
    static void p(String a){
        int i=48;while(i<a.length()){out.println(a.substring(i-48,i));i+=48;}
        out.println(a.substring(i-48));out.println();
    }
    public static void main(String[]a) throws Exception{setOut(new PrintStream("o.txt"));String b="";while(true)p(b=F(b));}
}

Literate Haskell (GHC 7.10): ω² + 999686 punti.

Questo servirà come risposta di esempio. Dal momento che è un esempio, ha senso usare la programmazione letterata . Non segnerà comunque bene. Gli uccellini diminuiranno il mio punteggio, ma vabbè. Innanzitutto, facciamo una funzione di aiuto s. Se x è un ordinale, sx = x + 1, ma troviamo usi imprevisti di s.

> s x="main=putStrLn "++show x

Per fortuna, la funzione show esegue tutta la sanificazione delle stringhe per noi. Vale anche la pena fare 0. Zero non è il successore di nulla, ma s "" sarà uguale "main = putStrLn" "", che è uguale a 0.

> z=s""

Ora creeremo una funzione che accetta n e restituisce ω * n.

> o 0=z
> o n=q++"\nmain=putStrLn$unlines$map show$iterate s$o "++show(n-1)

Funziona creando ω * n con {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...}. Che cos'è questo q? Perché, è la ragione per cui abbiamo un tag quine . q è finora la funzione di supporto di cui sopra.

> h x = x ++ show x
> q = h "s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h "

Nota che solo sui bisogni q, non su nessuno dei suoi successori (s (o (n)), s (s (o (n)))), poiché non hanno bisogno delle funzioni di supporto (tranne indirettamente da o n.) Ora dobbiamo solo produrre tutto ω * n per n finito.

> main=mapM(print.o)[0..]

Eccoci. ω ^ 2 Avendo usato solo 314 caratteri di codice, richiedo un bonus finale di 999686, dandomi un punteggio finale di ω ^ 2 + 999686, che è già nella forma normale di Cantor.

Prime quattro righe di output (0, ω, ω * 2, ω * 3):

"main=putStrLn \"\""
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 0"
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 1"
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 2"

GolfScript, ε₀ + 1 + 999537 punti

{{
{"{"lib`+"}:lib~~"@++"~"+p}:output;
{{}}:nothing;
{{1{).2$`+output 1}do}}:list;
{{\.(`2$`+" iter"+@`if output}}:iter;
{{1${@`@(2$`{rep~}+++\}{;;}if~}}:rep;
{\`\+}:combine;
{{\@@~}}:swap;
{{1${1$(1$`{rangemap~}+[+@@[\\]]{~}/+}{;;}if}}:rangemap;
{`{}+}:wrap;
}}:lib~~
nothing {iter combine list~} {rep combine} {~swap combine combine} rep combine swap combine combine {~list~} combine rangemap {~~} combine combine swap combine combine swap combine combine list~

Probabilmente può essere migliore, ma sono diventato troppo pigro per eseguire il debug e dimostrare ordinali più grandi.

Ordinali più piccoli

#ω^ω^ω
#nothing {iter combine list~} {rep combine swap combine combine list~} {rep combine swap combine combine swap combine combine list~} rep combine swap combine combine swap combine combine swap combine combine list~
#ω^ω^2
#nothing {iter combine list~} { {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~} rep combine swap combine combine swap combine combine list~
#ω^nω
#nothing {iter combine list~} 2 { {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~} rep~
#ω^ω
#nothing {iter combine list~} {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~
#ω^n
#nothing {iter combine list~} 3 {rep combine swap combine combine list~} rep~
#ω^3
#nothing {{iter combine list~} rep combine swap combine combine list~} rep combine swap combine combine list~
#ω^2
#nothing {iter combine list~} rep combine swap combine combine list~
#nω
#nothing 3 {iter combine list~} rep~
#2ω
#nothing iter combine list combine iter combine list~
#ω
#nothing iter combine list~
#finite
#2 nothing iter~

Javascript (Nashorn), ω2 + 999807 punti

Nashorn è il motore Javascript incorporato in Java. Questo potrebbe funzionare anche in Rhino, ma non l'ho ancora provato.

c="(b=function(a){print(a?\"(b=\"+b+\")(\"+(a-1)+\")\":\"c=\\\"(b=function(a){print(a?'(b='+b+')'+'('+(a-1)+')':'')})(\\\";a=0;while(++a)print(c+a+\\\")\\\")\")})(";a=0;while(++a)print(c+a+")")