O sistema numérico ordinal é um sistema com números infinitos. Muitos números infinitos. Tantos números infinitos que literalmente não tem um infinito para representar sua própria infinitude. A imagem acima fornece uma pequena idéia de como eles funcionam. Um número ordinal ( construção de Von Neumann ) é um conjunto de ordinais anteriores. Por exemplo, 0 é o conjunto vazio, 1 é o conjunto {0}, 2 é o conjunto {0, 1} e etc. Então chegamos a ω, que é {0, 1, 2, 3 ...}. ω + 1 é {0, 1, 2, 3 ... ω}, ω duas vezes é {0, 1, 2 ... ω, ω + 1, ω + 2 ...} e você continua assim aquele.

Seu programa produzirá um conjunto de ordinais, como {0, 1, 4}. Sua pontuação será o menos ordinal mais do que o ordinal do seu conjunto. Para {0, 1, 4} a pontuação seria 5. Para {0, 1, 2 ...}, a pontuação seria ω.

Como você produz seus ordinais, você pergunta. Código de curso. Ou seja, seu programa produzirá uma lista potencialmente infinita de outros programas, entre aspas, um em cada linha (use a string literal "\ n" para representar novas linhas). Um programa corresponde à sua pontuação, conforme indicado acima. Por exemplo, se você gerar

"A"
"B"
"C"

onde A, B e C são respostas válidas e têm pontuações {0, 1, 4}, a pontuação do seu programa seria 5. Observe que A, B e C devem ser programas completos, não fragmentos.

Com base nas regras acima, um programa que não produz nada tem uma pontuação de 0 (o menos ordinal maior que todos {} é 0). Além disso, lembre-se de que um conjunto não pode se conter, através do axioma da fundação . Ou seja, todo conjunto (e, portanto, ordinal) tem um caminho até zero. Isso significa que um quine completo seria inválido, pois não é um conjunto.

Além disso, nenhum programa tem permissão para acessar recursos externos (seu próprio arquivo, a internet etc ...). Além disso, quando você listar sua partitura, coloque a forma normal do cantor ao lado dela, se ela ainda não estiver na forma normal do cantor, se você puder (se não, outra pessoa pode).

Depois de levar tudo em consideração, a resposta real que você postar deve ser inferior a 1.000.000 bytes (sem contar os comentários). (Esse limite superior provavelmente só entrará em ação no código gerado automaticamente). Além disso, você aumenta sua pontuação para cada byte que não usa (já que estamos lidando com infinitos, isso provavelmente só será considerado quando os ordinais estiverem muito próximos ou iguais). Novamente, este parágrafo se aplica apenas à resposta postada, não às geradas, ou às geradas, e assim por diante.

Isso possui a tag quine, porque pode ser útil gerar pelo menos parte do código do próprio código-fonte, para uso na criação de ordinais grandes. Porém, isso não é necessário (por exemplo, um envio com pontuação 5 provavelmente não precisaria de seu próprio código-fonte).

Para um exemplo elaborado e anotado, veja aqui .

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

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 com ordinal ψ (Ω ^{Ω ω} ) + 1. Usa uma representação em árvore de ordinais descobertos por Jervell (2005) . A árvore com filhos α , β ,…, γ é denotada α :@ (β :@ (… :@ (γ :@ Z)…)). Essa ordem da esquerda para a direita concorda com Jervell, embora observe que Madore a vira da direita para a esquerda.

Haskell: Γ ₀ + 999777 pontos

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 com ordinal Γ ₀ + 1. Isso é baseado em uma generalização do Worm de Beklemishev para elementos com valor ordinal, que são representados recursivamente por worms.

Haskell: ε ₀ + 999853 pontos

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 com ordinal ε ₀ + 1. Isso é baseado no Worm de Beklemishev . A lista

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

representa o ordinal (ω ^y + ⋯ + ω ^p + ω ^ct ) - 1. Assim, as saídas de segundo nível [0], [1], [2], [3], ... representam 1, ω, ω ^ω , ω ^{ω ω} , ..., a saída do primeiro nível representa ε ₀ e o programa inicial representa ε ₀ + 1.

Haskell: ε ₀ + 999807 pontos

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 com ordinal ε ₀ + 1.

Zrepresenta 0, e podemos provar por indução transfinita em α , depois em β , que α :@ β≥ ω ^α + β . Portanto, existem saídas de segundo nível pelo menos tão grandes quanto qualquer torre ω ^{ω ⋰ ω} , o que significa que a saída de primeiro nível é pelo menos ε ₀ e o programa inicial é pelo menos ε ₀ + 1.

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

Supondo que eu entenda meu programa corretamente, minha pontuação é ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))} (0)) + 999663 pontos em que ψ é uma função ordinal em colapso, X é o chi (função de colapso do Mahlo) e M é o primeiro 'ordinal' do Mahlo.

Este programa é uma extensão do que eu escrevi no Golf um número maior que o TREE (3) e supera totalmente todas as outras soluções aqui por enquanto.

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

Experimente online!

Ruby, ψ ₀ (ψ _I (I ^I )) + 999674 pontos

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

Experimente online! (aviso: não fará muito, pois claramente (0..1.0/0).map{...}não pode terminar. É assim que eu imprimo infinitamente muitos programas também.)

Ruby, ψ ₀ (ψ _I (0)) + 999697 pontos

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

Experimente online!

Um programa de teste mais razoável que implementa (0..5).map{...}:

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

Experimente online!

Infelizmente, mesmo com (1..1).map{...}, você encontrará este programa extremamente intensivo em memória. Quero dizer, o comprimento da saída excede coisas como SCG (13).

Usando o programa mais simples, podemos considerar alguns 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]}\")")

Experimente online!

Basicamente, imprime o mesmo programa repetidamente, no formato de:

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

onde os xregistros inicializados estão relacionados ao ordinal ao programa e "..."mantêm os programas após a xredução. Se x==0, então, imprime

p

que é um programa que imprime nada com pontuação zero, portanto

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

tem uma pontuação de 1 e

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

tem uma pontuação de 2 e

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

tem uma pontuação de 3, etc., e meu programa original imprime esses programas no formato

puts("...")

onde ...estão os programas listados acima.

Meu programa atual realmente imprime esses programas no formato

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

Infinitamente, muitas vezes, e para valores como ω, ele faz algo semelhante a

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

E assim, a pontuação do programa

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

é 1+some_ordinale a pontuação de

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

é 1+some_ordinal+1e a pontuação 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]}\")")

é 1+some_ordinal+2.

Explicação dos ordinais:

f[a,n,b]reduz um ordinal a.

Todo número natural se reduz ao número natural abaixo dele.

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

[c,0,e]é o sucessor de c, e sempre se reduz a c.

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

[c,d,e] é uma hiperoperação associativa para trás, reduz-se da seguinte forma:

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] é o primeiro ordinal infinito (equivalente a ω) e reduz da seguinte forma:

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

[c] é o césimo ordinal ômega e reduz da seguinte forma:

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 reduz o seguinte:

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]é basicamente o mesmo que [c,d,e], exceto que enumera a operação em [c]vez da operação sucessora.

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 pontos

Um programa java que produz infinitos programas Brainf ***, dos quais cada um produz o último como saída.

Por quê? Porque eu posso.

Quaisquer melhorias na parte da geração Brainf *** são definitivamente bem-vindas.

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

Haskell alfabetizado (GHC 7.10): ω² + 999686 pontos.

Isso servirá como exemplo de resposta. Desde que é um exemplo, só faz sentido usar a programação alfabetizada . Não vai marcar bem embora. Os passarinhos diminuirão minha pontuação, mas tudo bem. Primeiro, vamos fazer uma função auxiliar s. Se x é um ordinal, sx = x + 1, mas encontramos usos inesperados de s.

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

Felizmente, a função show faz toda a limpeza das cordas para nós. Também vale a pena fazer 0. Zero não é o sucessor de nada, mas s "" será igual a "main = putStrLn" "", que é igual a 0.

> z=s""

Agora criaremos uma função que recebe n e retorna ω * n.

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

Funciona criando ω * n por {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...}. O que é isso q? Por que, é a razão pela qual temos uma tag quine . q são as funções auxiliares acima até agora.

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

Observe que somente nas necessidades q, nenhum de seus sucessores (s (o (n)), s (s (o (n)))), pois eles não precisam das funções auxiliares (exceto indiretamente de on). Agora, temos apenas que produzir todos os ω * n para n finito.

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

Aqui vamos nós. ω ^ 2 Tendo usado apenas 314 caracteres de código, reivindico um bônus final de 999686, dando-me uma pontuação final de ω ^ 2 + 999686, que já está na forma normal de cantor.

Primeiras quatro linhas de saída (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 pontos

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

Provavelmente pode ser melhor, mas fiquei com preguiça de depurar e provar ordinais maiores.

Ordinais menores

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

Nashorn é o mecanismo Javascript incorporado ao Java. Isso também pode funcionar no Rhino, mas ainda não o testei.

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