El sistema de números ordinales es un sistema con números infinitos. Muchos números infinitos. Tantos números infinitos que literalmente no tiene un infinito para representar su propia infinitud. La imagen de arriba da una pequeña idea de cómo funcionan. Un número ordinal ( construcción de von Neumann ) es un conjunto de ordinales anteriores. Por ejemplo, 0 es el conjunto vacío, 1 es el conjunto {0}, 2 es el conjunto {0, 1} y etc. Luego llegamos a ω, que es {0, 1, 2, 3 ...}. ω + 1 es {0, 1, 2, 3 ... ω}, ω multiplicado por dos es {0, 1, 2 ... ω, ω + 1, ω + 2 ...} y sigues como ese.

Su programa generará un conjunto de ordinales, como {0, 1, 4}. Su puntaje será el menos ordinal más que todo el ordinal en su conjunto. Para {0, 1, 4} la puntuación sería 5. Para {0, 1, 2 ...}, la puntuación sería ω.

¿Cómo sacas tus ordinales que preguntas? Código por supuesto. Es decir, su programa generará una lista potencialmente infinita de otros programas, entre comillas, uno en cada línea (use la cadena literal "\ n" para representar nuevas líneas). Un programa corresponde a su puntaje como se indicó anteriormente. Por ejemplo, si saca

"A"
"B"
"C"

donde A, B y C son respuestas válidas y tienen puntajes {0, 1, 4}, el puntaje de su programa sería 5. Tenga en cuenta que A, B y C deben ser programas completos, no fragmentos.

Según las reglas anteriores, un programa que no genera nada tiene una puntuación de 0 (el menor ordinal mayor que todos {} es 0). Además, recuerde que un conjunto no puede contenerse, a través del axioma de la fundación . Es decir, cada conjunto (y, por lo tanto, ordinal) tiene una ruta de acceso a cero. Esto significa que un quine completo sería inválido ya que no es un conjunto.

Además, ningún programa puede acceder a recursos externos (su propio archivo, Internet, etc.). Además, cuando enumere su puntaje, coloque la forma normal de puntaje junto a él si aún no está en forma normal, si puede (si no, alguien más puede).

Después de tener en cuenta todo lo anterior, la respuesta real que publique debe ser inferior a 1,000,000 bytes (sin contar los comentarios). (Este límite superior probablemente solo entrará en juego para el código generado automáticamente). Además, puede aumentar su puntaje por cada byte que no use (dado que estamos tratando con infinitos, esto probablemente solo se tendrá en cuenta cuando los ordinales estén muy cerca o lo mismo). Una vez más, este párrafo solo se aplica a la respuesta publicada, no a las generadas, o las que generan, y así sucesivamente.

Esto tiene la etiqueta quine, porque puede ser útil generar al menos parte del código propio de las fuentes, para usar en la creación de ordinales grandes. Sin embargo, de ninguna manera es obligatorio (por ejemplo, un envío con puntaje 5 probablemente no necesitaría su propio código fuente).

Para un ejemplo resuelto y anotado, vea aquí .

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

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 bytes de código con ordinal ψ (Ω ^{Ω ω} ) + 1. Utiliza una representación en árbol de ordinales descubiertos por Jervell (2005) . El árbol con hijos α , β , ..., γ se denota α :@ (β :@ (… :@ (γ :@ Z)…)). Este orden de izquierda a derecha está de acuerdo con Jervell, aunque tenga en cuenta que Madore lo cambia de derecha a izquierda.

Haskell: Γ ₀ + 999777 puntos

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 bytes de código con ordinal Γ ₀ + 1. Esto se basa en una generalización del gusano de Beklemishev a elementos de valor ordinal, que son representados recursivamente por gusanos.

Haskell: ε ₀ + 999853 puntos

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 bytes de código con ordinal ε ₀ + 1. Esto se basa en el gusano de Beklemishev . La lista

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

representa el ordinal (ω ^gamma + ⋯ + ω ^ß + ω ^alpha ) - 1. Por lo tanto las salidas de segundo nivel [0], [1], [2], [3], ... representan 1, ω, ω ^ω , ω ^{ω ω} , ..., la salida del primer nivel representa ε ₀ , y el programa inicial representa ε ₀ + 1.

Haskell: ε ₀ + 999807 puntos

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 bytes de código con ordinal ε ₀ + 1.

Zrepresenta 0, y podemos demostrar por inducción transfinita en α , luego en β , que α :@ β≥ ω ^α + β . Así que hay salidas de segundo nivel al menos tan grande como cualquier torre omega ^{omega ⋰ omega} , que significa que la salida de primer nivel es al menos ε ₀ y el programa inicial es al menos ε ₀ + 1.

Rubí, ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))} (0)) + 999663 puntos

Suponiendo que entiendo mi programa correctamente, mi puntaje es ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))} (0)) + 999663 puntos donde ψ es una función de colapso ordinal, X es el chi función (función de colapso de Mahlo), y M es el primer 'ordinal' de Mahlo.

Este programa es una extensión de la que escribí en Golf, un número mayor que TREE (3) y supera por completo a todas las otras soluciones aquí por ahora.

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]}\""}

Pruébalo en línea!

Rubí, ψ ₀ (ψ _I (I ^I )) + 999674 puntos

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]}\")")}

Pruébalo en línea! (advertencia: no hará mucho, ya que claramente (0..1.0/0).map{...}no puede terminar. Es así como también imprimo infinitos programas).

Rubí, ψ ₀ (ψ _I (0)) + 999697 puntos

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]}\")")}

Pruébalo en línea!

Un programa de prueba más razonable que implementa en su (0..5).map{...}lugar:

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]}\")")}

Pruébalo en línea!

Desafortunadamente, incluso con (1..1).map{...}, encontrará que este programa requiere mucha memoria. Quiero decir, la longitud de la salida excede cosas como SCG (13).

Al usar el programa más simple, podemos considerar algunos valores:

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]}\")")

Pruébalo en línea!

Básicamente imprime el mismo programa repetidamente, en el formato de:

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

donde el inicializado xregistra el ordinal con el que se relaciona el programa, y ​​la "..."retención de los programas después de que xse ha reducido. Si x==0, entonces imprime

p

que es un programa que no imprime nada con una puntuación de cero, por lo tanto

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

tiene una puntuación de 1 y

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

tiene una puntuación de 2 y

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

tiene un puntaje de 3, etc., y mi programa original imprime estos programas en el formato

puts("...")

¿Dónde ...están los programas mencionados anteriormente?

Mi programa actual realmente imprime estos programas en el formato

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

Infinitamente muchas veces, y para valores como ω, hace algo similar a

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

Y así, el puntaje del programa

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

es 1+some_ordinal, y la puntuación de

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

es 1+some_ordinal+1, y la puntuación de

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]}\")")

es 1+some_ordinal+2.

Explicación de ordinales:

f[a,n,b]Reduce un ordinal a.

Cada número natural se reduce al número natural debajo de él.

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

[c,0,e]es el sucesor de c, y siempre se reduce a c.

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

[c,d,e] Es una hiperoperación asociativa hacia atrás, se reduce de la siguiente manera:

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] es el primer ordinal infinito (equivalente a ω) y se reduce de la siguiente manera:

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

[c] es el cth omega ordinal y se reduce de la siguiente manera:

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]es ψ _d (c) y se reduce de la siguiente manera:

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]es básicamente lo mismo que [c,d,e], excepto que enumera la operación en [c]lugar de la operación sucesora.

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 puntos

Un programa de Java que produce infinitos programas Brainf ***, cada uno de los cuales produce el último como salida.

¿Por qué? Porque puedo.

Cualquier mejora en la parte de generación Brainf *** es definitivamente bienvenida.

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

Alfabetizado Haskell (GHC 7.10): ω² + 999686 puntos.

Esto servirá como una respuesta de ejemplo. Como es un ejemplo, solo tiene sentido usar programación alfabetizada . Sin embargo, no puntuará bien Los pajaritos disminuirán mi puntaje, pero bueno. Primero, hagamos una función auxiliar s. Si x es un ordinal, sx = x + 1, pero encontramos usos inesperados de s.

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

La función show afortunadamente hace toda la desinfección de cadenas por nosotros. También vale la pena hacer 0. Zero no es el sucesor de nada, pero s "" será igual a "main = putStrLn" "", que es igual a 0.

> z=s""

Ahora haremos una función que tome n y devuelva ω * n.

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

Funciona haciendo ω * n por {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...}. ¿Qué es esto q? Por qué, es la razón por la que tenemos una etiqueta quine . q son las funciones de ayuda anteriores hasta ahora.

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

Tenga en cuenta que solo en las necesidades q, no en ninguno de sus sucesores (s (o (n)), s (s (o (n)))), ya que no necesitan las funciones auxiliares (excepto indirectamente de o n). Ahora solo tenemos que generar todos ω * n para n finito.

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

Aquí vamos. 2 ^ 2 Habiendo usado solo el código 314, reclamo un bono final de 999686, lo que me da un puntaje final de ω ^ 2 + 999686, que ya está en la forma normal de cantor.

Primeras cuatro líneas de salida (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 puntos

{{
{"{"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~

Probablemente puede ser mejor, pero me volví demasiado vago para depurar y probar ordinales más grandes.

Ordenales más pequeños

#ω^ω^ω
#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 puntos

Nashorn es el motor Javascript que viene integrado en Java. Esto también puede funcionar en Rhino, pero aún no lo he probado en eso.

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