Система порядковий номер являє собою систему з нескінченним числом. Дуже багато нескінченних чисел. Так багато нескінченних чисел, що буквально не має нескінченності представляти власну нескінченність. Зображення вище дає невелике уявлення про те, як вони працюють. Порядковий номер ( конструкція Фон Неймана ) - це сукупність попередніх порядків. Наприклад, 0 - це порожній набір, 1 - множина {0}, 2 - множина {0, 1} і т. Д. Тоді ми переходимо до ω, що дорівнює {0, 1, 2, 3 ...}. ω + 1 дорівнює {0, 1, 2, 3 ... ω}, ω разів два - {0, 1, 2 ... ω, ω + 1, ω + 2 ...}, і ви просто продовжуєте так, як що.

Ваша програма виведе набір порядків, наприклад {0, 1, 4}. Тоді ваш рахунок буде найменш порядковим, ніж усі порядкові порядки у вашому наборі. Для {0, 1, 4} оцінка буде 5. Для {0, 1, 2 ...} оцінка буде ω.

Як ви видаєте запитання, які ви запитуєте. Код звичайно. А саме, ваша програма виведе потенційно нескінченний список інших програм, у лапках, по одній у кожному рядку (використовуйте буквальний рядок "\ n" для представлення нових рядків). Програма відповідає її балу, як зазначено вище. Наприклад, якщо ви виходите

"A"
"B"
"C"

де A, B і C є дійсними відповідями і мають бали {0, 1, 4}, оцінка вашої програми була б 5. Зауважте, що A, B і C повинні бути повноцінними програмами, а не фрагментами.

Виходячи з вищенаведених правил, програма, яка нічого не видає, має бал 0 (найменший порядковий більший за всіх {} - 0). Також пам’ятайте, що набір не може містити себе через аксіому фундаменту . А саме, кожен набір (а отже, порядковий) має шлях до нуля. Це означає, що full-quine буде недійсним, оскільки це не набір.

Також жодна програма не має доступу до зовнішніх ресурсів (власний файл, Інтернет тощо). Крім того, коли ви перераховуєте свій рейтинг, додайте до нього звичайну форму партитури, якщо вона вже не в нормальній формі, якщо ви можете (якщо ні, то може хтось інший).

Враховуючи все вищезазначене, фактична відповідь, яку ви опублікуєте, повинна бути менше 1 000 000 байт (не рахуючи коментарів). (Ця верхня межа, ймовірно, вступає в гру лише для автоматично створеного коду). Крім того, ви можете збільшувати свій бал за кожен байт, який ви не використовуєте (оскільки ми маємо справу з нескінченностями, це, мабуть, буде враховано лише тоді, коли ординали дуже близькі або однакові). Знову ж таки, цей параграф застосовується лише до розміщеної відповіді, а не до генерованої, або до породженої, тощо.

Це має тег quine, тому що може бути корисним створити принаймні частину власних кодів джерел для використання у створенні великих порядків. Це жодним чином не потрібно (наприклад, для подання з оцінкою 5, мабуть, не знадобиться власний вихідний код).

Про відпрацьований та примічений приклад дивіться тут .

Haskell: ψ (Ω ^{Ω ω} ) + 999672 балів

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 байт коду з порядковим ψ (Ω ^{Ω ω} ) + 1. Використовує на основі дерева подання порядків, виявлених Джервеллом (2005) . Позначається дерево з дітьми α , β ,…, γα :@ (β :@ (… :@ (γ :@ Z)…)) . Цей наказ зліва направо погоджується з Джервеллом, хоча зауважте, що Мадоре перевертає його праворуч наліво.

Хаскелл: Γ ₀ + 999777 балів

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 байти коду з порядковими Γ ₀ + 1. Це засноване на узагальненні Черв'яка Беклемішева на порядкові значення елементів, які самі по собі рекурсивно представлені черв'яками.

Haskell: ε ₀ + 999853 балів

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 байт коду з порядковим ε ₀ + 1. На цьому базується черв'яку Беклемішева . Список

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

являє собою порядковий номер (ш & ^gamma + ⋯ + ш ^{& beta} ; + ш ^{& alpha} ; ) - 1. Таким чином, виходи другого рівня [0], [1], [2], [3], ... є 1, ш, ш ^ш , ш ^{ш ш} , ..., вихідний сигнал першого рівня являє е ₀ , а початкова програма представляє ε ₀ + 1.

Хаскелл: ε ₀ + 999807 балів

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 байти коду з порядковою ε ₀ + 1.

Zявляє собою 0, і ми можемо довести через трансфінітну індукцію на α , потім на β , що α :@ β≥ ω ^α + β . Таким чином, є виходи другого рівня, принаймні такі ж великі, як і будь-яка вежа ω ^{ω ⋰ ω} , а це означає, що вихід першого рівня становить щонайменше ε _0, а початкова програма - щонайменше ε ₀ + 1.

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

Assuming I understand my program properly, my score is ψ₀(ψ_{X(ψM+1(ΩM+1^ΩM+1))}(0)) + 999663 points where ψ is an ordinal collapsing function, X is the chi function (Mahlo collapsing function), and M is the first Mahlo 'ordinal'.

This program is an extension of the one I wrote on Golf a number bigger than TREE(3) and utterly trumps all of the other solutions here for now.

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

Try it online!

Ruby, ψ₀(ψ_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]}\")")}

Try it online! (warning: it won't do much, since clearly (0..1.0/0).map{...} cannot terminate. It's how I print infinitely many programs as well.)

Ruby, ψ₀(ψ_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]}\")")}

Try it online!

A more reasonable test program that implements (0..5).map{...} instead:

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

Try it online!

Unfortunately, even with (1..1).map{...}, you will find this program to be extremely memory intensive. I mean, the length of the output exceeds things like SCG(13).

By using the simpler program, we may consider a few values:

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

Try it online!

It basically prints the same program repeatedly, in the format of:

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

where the initialized x records the ordinal the program is related to, and the "..." holds the programs after x has been reduced. If x==0, then it prints

p

which is a program that prints nothing with a score of zero, hence

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

has a score of 1, and

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

has a score of 2, and

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

has a score of 3, etc., and my original program prints these programs in the format

puts("...")

where ... are the programs listed above.

My actual program actually prints these programs in the format

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

Infinitely many times, and for values such as ω, it does something akin to

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

And thus, the score of the program

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

is 1+some_ordinal, and the score of

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

is 1+some_ordinal+1, and the score of

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

is 1+some_ordinal+2.

Explanation of ordinals:

f[a,n,b] reduces an ordinal a.

Every natural number reduces to the natural number below it.

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

[c,0,e] is the successor of c, and it always reduces down to c.

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

[c,d,e] is a backwards associative hyperoperation, are reduces as follows:

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] is the first infinite ordinal (equivalent to ω) and reduces as follows:

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

[c] is the cth omega ordinal and reduces as follows:

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] is ψ_d(c) and reduces as follows:

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] is basically the same as [c,d,e], except it enumerates over the operation [c] instead of the successor operation.

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

A java program that produces infinitely many Brainf*** programs, of which each produces the last as output.

Why? Because I can.

Any improvements to the Brainf*** generation part are definitely welcome.

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 points.

This will serve as an example answer. Since its an example, it only makes sense to use literate programming. It won't score well though. The birdies will decrease my score, but oh well. First, let's make a helper function s. If x is an ordinal, s x = x+1, but we find unexpected uses of s.

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

The show function luckily does all the string sanitization for us. Its also worth making 0. Zero is not the successor of anything, but s"" will equal "main=putStrLn """, which equals 0.

> z=s""

Now we will make a function that takes n, and returns ω*n.

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

It works by making ω*n by {ω*(n-1), ω*(n-1)+1, ω*(n-1)+2, ...}. What is this q? Why, its the reason we have a quine tag. q is the above helper functions so far.

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

Note that only o n needs q, not any of its successors (s(o(n)), s(s(o(n)))), since they don't need the helper functions (except indirectly from o n.) Now we only have to output all of ω*n for finite n.

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

There we go. ω^2 Having used only 314 code character, I claim a final bonus of 999686, giving me a final score of ω^2 + 999686, which is already in cantor's normal form.

First four lines of 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 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~

It can probably be better, but I became too lazy to debug and prove larger ordinals.

Smaller ordinals

#ω^ω^ω
#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 is the Javascript engine which comes built into Java. This may also work in Rhino, but I haven't tested it in that yet.

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