Le système de nombres ordinaux est un système avec des nombres infinis. Beaucoup de nombres infinis. Tant de nombres infinis qu'il n'a littéralement pas d'infini pour représenter sa propre infinité. L'image ci-dessus donne une petite idée de leur fonctionnement. Un nombre ordinal ( construction de Von Neumann ) est un ensemble d'ordinaux précédents. Par exemple, 0 est l'ensemble vide, 1 est l'ensemble {0}, 2 est l'ensemble {0, 1} et etc. Ensuite, nous arrivons à ω, qui est {0, 1, 2, 3 ...}. ω + 1 est {0, 1, 2, 3 ... ω}, ω fois deux est {0, 1, 2 ... ω, ω + 1, ω + 2 ...} et vous continuez comme cette.

Votre programme affichera un ensemble d'ordinaux, tels que {0, 1, 4}. Votre score sera alors le moins ordinal plus que tous les ordinaux de votre set. Pour {0, 1, 4}, le score serait 5. Pour {0, 1, 2 ...}, le score serait ω.

Comment sortez-vous vos ordinaux que vous demandez. Code bien sûr. À savoir, votre programme affichera une liste potentiellement infinie d'autres programmes, entre guillemets, un sur chaque ligne (utilisez la chaîne littérale "\ n" pour représenter les nouvelles lignes). Un programme correspond à son score comme indiqué ci-dessus. Par exemple, si vous sortez

"A"
"B"
"C"

où A, B et C sont eux-mêmes des réponses valides et ont des scores {0, 1, 4}, le score de votre programme serait 5. Notez que A, B et C doivent être des programmes complets, pas des fragments.

Sur la base des règles ci-dessus, un programme qui ne produit rien a un score de 0 (le moins ordinal supérieur à tous {} est 0). Souvenez-vous également qu'un ensemble ne peut pas se contenir lui-même, via l' axiome de fondation . A savoir, chaque ensemble (et donc ordinal) a un chemin vers zéro. Cela signifie qu'un quine complet serait invalide car ce n'est pas un ensemble.

De plus, aucun programme n'est autorisé à accéder à des ressources externes (son propre fichier, Internet etc ...). De plus, lorsque vous listez votre score, mettez la forme normale du cantor à côté si elle n'est pas déjà sous la forme normale du cantor, si vous le pouvez (sinon, quelqu'un d'autre peut le faire).

Après avoir pris en compte tout ce qui précède, la réponse réelle que vous publiez doit être inférieure à 1 000 000 octets (sans compter les commentaires). (Cette limite supérieure n'entrera probablement en jeu que pour le code généré automatiquement). De plus, vous pouvez incrémenter votre score pour chaque octet que vous n'utilisez pas (car nous avons affaire à des infinis, cela ne sera probablement pris en compte que lorsque les ordinaux sont très proches ou identiques). Encore une fois, ce paragraphe s'applique uniquement à la réponse publiée, pas aux réponses générées, ni à celles générées par les réponses générées, etc.

Celui-ci a la balise quine, car il peut être utile de générer au moins une partie du code propre des sources, pour une utilisation dans la fabrication de grandes ordinales. Ce n'est en aucun cas requis (par exemple, une soumission avec un score de 5 n'aurait probablement pas besoin de son propre code source).

Pour un exemple élaboré et annoté, voir ici .

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

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 octets de code avec l'ordinal ψ (Ω ^{Ω ω} ) + 1. Utilise une représentation arborescente des ordinaux découverte par Jervell (2005) . L'arbre avec les enfants α , β ,…, γ est noté α :@ (β :@ (… :@ (γ :@ Z)…)). Cet ordre de gauche à droite est d'accord avec Jervell, bien que notez que Madore le retourne de droite à gauche.

Haskell: Γ ₀ + 999777 points

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 octets de code avec l'ordinal Γ ₀ + 1. Ceci est basé sur une généralisation du ver de Beklemishev aux éléments à valeur ordinale, qui sont eux-mêmes représentés récursivement par des vers.

Haskell: ε ₀ + 999853 points

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 octets de code avec l'ordinal ε ₀ + 1. Ceci est basé sur le ver de Beklemishev . La liste

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

représente l'ordinal (ω la ^y + ⋯ + ω la ^ß + ω ^alpha ) - 1. Donc , les sorties de second niveau [0], [1], [2], [3], ... représentent 1, ω, ω ^ω , ω ^{ω ω} , ..., la sortie de premier niveau représente ε ₀ , et le programme initial représente ε ₀ + 1.

Haskell: ε ₀ + 999807 points

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 octets de code avec l'ordinal ε ₀ + 1.

Zreprésente 0, et on peut prouver par induction transfinie sur α , puis sur β , que α :@ β≥ ω ^α + β . Il y a donc des sorties de deuxième niveau au moins aussi grandes que n'importe quelle tour ω ^{ω ⋰ ω} , ce qui signifie que la sortie de premier niveau est au moins ε ₀ et que le programme initial est au moins ε ₀ + 1.

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

En supposant que je comprends bien mon programme, mon score est ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))} (0)) + 999663 points où ψ est une fonction de regroupement ordinale, X est le chi (fonction d'effondrement de Mahlo), et M est le premier «ordinal» de Mahlo.

Ce programme est une extension de celui que j'ai écrit sur Golf, un nombre plus grand que TREE (3) et l' emporte complètement sur toutes les autres solutions ici pour l'instant.

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

Essayez-le en ligne!

Rubis, ψ ₀ (ψ _I (I ^I )) + 999674 points

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

Essayez-le en ligne! (avertissement: cela ne fera pas grand-chose, car il ne (0..1.0/0).map{...}peut clairement pas se terminer. C'est ainsi que j'imprime également une infinité de programmes.)

Rubis, ψ ₀ (ψ _I (0)) + 999697 points

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

Essayez-le en ligne!

Un programme de test plus raisonnable qui implémente à la (0..5).map{...}place:

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

Essayez-le en ligne!

Malheureusement, même avec (1..1).map{...}, vous trouverez que ce programme est extrêmement gourmand en mémoire. Je veux dire, la longueur de la sortie dépasse des choses comme SCG (13).

En utilisant le programme plus simple, nous pouvons considérer quelques valeurs:

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

Essayez-le en ligne!

Il imprime essentiellement le même programme à plusieurs reprises, au format:

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

où l'initialisation xenregistre l'ordinal auquel le programme est lié, et la "..."détient les programmes après xa été réduite. Si x==0, alors il imprime

p

qui est un programme qui n'imprime rien avec un score de zéro, d'où

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

a un score de 1, et

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

a un score de 2, et

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

a un score de 3, etc., et mon programme d'origine imprime ces programmes au format

puts("...")

où ...sont les programmes énumérés ci-dessus.

Mon programme réel imprime ces programmes au format

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

Infiniment de fois, et pour des valeurs telles que ω, cela fait quelque chose de semblable à

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

Et donc, le score du programme

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

est 1+some_ordinal, et le score de

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

est 1+some_ordinal+1, et le score 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]}\")")

est 1+some_ordinal+2.

Explication des ordinaux:

f[a,n,b]réduit un ordinal a.

Chaque nombre naturel se réduit au nombre naturel en dessous.

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

[c,0,e]est le successeur de c, et il se réduit toujours à c.

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

[c,d,e] est une hyperopération associative à l'envers, se réduit comme suit:

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] est le premier ordinal infini (équivalent à ω) et se réduit comme suit:

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

[c] est le cième oméga ordinal et se réduit comme suit:

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]est ψ _d (c) et se réduit comme suit:

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]est fondamentalement le même que [c,d,e], sauf qu'il énumère l'opération [c]au lieu de l'opération qui lui succède.

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 points

Un programme java qui produit une infinité de programmes Brainf ***, dont chacun produit le dernier en sortie.

Pourquoi? Parce que je peux.

Toute amélioration de la partie génération Brainf *** est certainement la bienvenue.

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

Alphabétisé Haskell (GHC 7.10): ω² + 999686 points.

Cela servira d'exemple de réponse. Étant donné que c'est un exemple, il est logique d'utiliser une programmation alphabétisée . Cela ne marquera pas bien cependant. Les birdies diminueront mon score, mais bon. D'abord, faisons une fonction d'aide s. Si x est un ordinal, sx = x + 1, mais nous trouvons des utilisations inattendues de s.

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

La fonction show fait heureusement toute la désinfection des cordes pour nous. Cela vaut également la peine de faire 0. Zéro n'est le successeur de rien, mais s "" sera égal à "main = putStrLn" "", ce qui équivaut à 0.

> z=s""

Nous allons maintenant créer une fonction qui prend n et renvoie ω * n.

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

Il fonctionne en faisant ω * n par {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...}. Quel est ce q? Pourquoi, c'est la raison pour laquelle nous avons une balise quine . q est les fonctions d'assistance ci-dessus jusqu'à présent.

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

Notez que seulement sur les besoins q, aucun de ses successeurs (s (o (n)), s (s (o (n)))), car ils n'ont pas besoin des fonctions d'assistance (sauf indirectement à partir de o n.) Il ne nous reste plus qu'à sortir tout ω * n pour n fini.

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

Et voilà. ω ^ 2 N'ayant utilisé que 314 caractères de code, je réclame un bonus final de 999686, ce qui me donne un score final de ω ^ 2 + 999686, qui est déjà sous la forme normale de Cantor.

Quatre premières lignes de sortie (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 points

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

Cela peut probablement être mieux, mais je suis devenu trop paresseux pour déboguer et prouver des ordinaux plus gros.

Petits ordinaux

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

Nashorn est le moteur Javascript intégré à Java. Cela peut également fonctionner dans Rhino, mais je ne l'ai pas encore testé dans cela.

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