ตารางสีม่วงอ่อนให้ตัวอย่างของโปรแกรมที่ยังไม่ได้รับการแสดงที่จะยุติในระบบจริงมาตรฐานของคณิตศาสตร์ZFCแต่ที่จะยุติเมื่อหนึ่งถือว่าหลักการพระคาร์ดินัลมีขนาดใหญ่มาก

บทนำ

ตารางสีม่วงอ่อนคลาสสิกเป็นจีบราส์ จำกัด ที่ไม่ซ้ำกับชุดพื้นฐานและการดำเนินงานที่ตอบสนองความเป็นตัวตนและสถานที่สำหรับการและสถานที่ที่An{1,...,2n}*x * (y * z)=(x * y) * (x * z)x*1=x+1x<2n2n*1=1

ข้อมูลเพิ่มเติมเกี่ยวกับตาราง Laver แบบคลาสสิกสามารถพบได้ในหนังสือ Braids และ Self-Distributionivity โดย Patrick Dehornoy

ท้าทาย

รหัสที่สั้นที่สุด (ไบต์) ที่คำนวณคืออะไร1*32ในตารางอื้อคลาสสิกและยุติได้อย่างแม่นยำเมื่อมันพบnกับ? ในคำอื่น ๆ โปรแกรมยุติและถ้าหากมันพบกับแต่อย่างอื่นมันจะทำงานตลอด1*32<2nn1*32<2n

แรงจูงใจ

อันดับลงในตำแหน่งพระคาร์ดินัล (เรียกว่ายังเป็น I3-พระคาร์ดินัล) เป็นอย่างยิ่งใหญ่ระดับของอินฟินิตี้และถ้าหนึ่งจะถือว่าการดำรงอยู่ของพระคาร์ดินัลอันดับลงในตำแหน่งนั้นหนึ่งสามารถพิสูจน์ทฤษฎีบทมากกว่าถ้าใครไม่ได้ ถือว่าการดำรงอยู่ของพระคาร์ดินัลอันดับเข้าสู่อันดับ ถ้ามีพระคาร์ดินัลอันดับลงในตำแหน่งนั้นมีบางตารางอื้อคลาสสิกที่ อย่างไรก็ตามไม่มีหลักฐานพิสูจน์ว่าใน ZFC นอกจากนี้ยังเป็นที่รู้จักกันว่าอย่างน้อยที่มีค่ามากกว่า(ซึ่งเป็นจำนวนที่มีขนาดใหญ่มากตั้งแต่ฟังก์ชั่น Ackermann เป็นฟังก์ชั่นที่เติบโตอย่างรวดเร็ว) ดังนั้นโปรแกรมดังกล่าวจะมีอายุการใช้งานนานมากAn1*32<2n1*32<2nn1*32<2nAck(9,Ack(8,Ack(8,254)))Ack

ฉันต้องการที่จะดูว่าโปรแกรมสั้น ๆ ที่สามารถเขียนได้เพื่อที่เราจะไม่ทราบว่าโปรแกรมนั้นสิ้นสุดลงโดยใช้ระบบสัจพจน์มาตรฐาน ZFC หรือไม่ คำถามนี้ได้รับแรงบันดาลใจจากโพสต์ล่าสุดของ Scott Aaronsonซึ่ง Aaronson และ Adam Yedidia ได้สร้างเครื่องจักรทัวริงภายใต้รัฐ 8000 ซึ่ง ZFC ไม่สามารถพิสูจน์ได้ว่าเครื่องทัวริงไม่ยุติ แต่รู้ว่าไม่ยุติเมื่อมีสมมติฐานขนาดใหญ่

วิธีคำนวณตาราง Laver แบบดั้งเดิม

เมื่อคำนวณตารางอื้อก็มักจะสะดวกในการใช้จริงที่ว่าในพีชคณิตเรามีทั้งหมดในAn2n * x=xxAn

รหัสต่อไปนี้คำนวณตาราง Laver คลาสสิก An

# table (n, x, y) ส่งคืน x * y ใน A n
ตาราง: = ฟังก์ชั่น (n, x, y)
ถ้า x = 2 ^ n แล้วส่งคืน y
elif y = 1 แล้วส่งคืน x + 1;
อื่นกลับตาราง (n, ตาราง (n, x, y-1), x + 1); Fi; จบ;

ยกตัวอย่างเช่นการป้อนข้อมูลที่จะกลับมาtable(4,1,2)12

รหัสสำหรับtable(n,x,y)ค่อนข้างไม่มีประสิทธิภาพและสามารถคำนวณได้เฉพาะในตาราง Laver ในเวลาที่เหมาะสม โชคดีที่มีอัลกอริทึมที่เร็วกว่ามากสำหรับการคำนวณตาราง Laver แบบดั้งเดิมมากกว่าที่ระบุไว้ด้านบนA4

แคลคูลัสแลมบ์ดาไบนารี, 215 บิต (27 ไบต์)

\io. let
  zero = \f\x. x;
  one = \x. x;
  two = \f\x. f (f x);
  sixteen = (\x. x x x) two;
  pred = \n\f\x. n (\g\h. h (g f)) (\h. x) (\x. x);
  laver = \mx.
    let laver = \b\a. a (\_. mx (b (laver (pred a))) zero) b
    in laver;
  sweet = sixteen;
  dblp1 = \n\f\x. n f (n f (f x)); -- map n to 2*n+1
  go2 = \mx. laver mx sweet mx (\_. mx) (go2 (dblp1 mx));
in go2 one

คอมไพล์ถึง (ใช้ซอฟต์แวร์ที่https://github.com/tromp/AIT )

000101000110100000010101010100011010000000010110000101111110011110010111
110111100000010101111100000011001110111100011000100000101100100010110101
00000011100111010100011001011101100000010111101100101111011001110100010

โซลูชันนี้ส่วนใหญ่เกิดจากhttps://github.com/int-e

CJam ( 36 32 ไบต์)

1{2*31TW$,(+a{0X$j@(@jj}2j)W$=}g

ในทางปฏิบัติข้อผิดพลาดนี้ออกมาค่อนข้างเร็วเพราะล้นสแตคการโทร แต่ในเครื่องที่ไม่ จำกัด เชิงทฤษฎีมันถูกต้องและฉันเข้าใจว่าเป็นข้อสันนิษฐานของคำถามนี้

รหัสสำหรับtable(n,x,y)ค่อนข้างไม่มีประสิทธิภาพและสามารถคำนวณได้เฉพาะในตาราง Laver A ₄ในเวลาที่เหมาะสม

ไม่ถูกต้องจริง ๆ ถ้าเราแคชค่าที่คำนวณได้เพื่อหลีกเลี่ยงการคำนวณใหม่ นั่นเป็นวิธีที่ผมเคยนำมาใช้j(memoisation) ผู้ประกอบการ มันทดสอบ A ₆ในมิลลิวินาทีและล้นการทดสอบ A ₇ - และจริง ๆ แล้วฉันได้deoptimised tableในความสนใจของการเล่นกอล์ฟ

การผ่า

หากเราสันนิษฐานว่าnเข้าใจได้จากบริบทแทนที่จะเป็น

f(x,y) =
    x==2^n ? y :
    y==1 ? x+1 :
    f(f(x,y-1),x+1)

เราสามารถลบเคสพิเศษตัวแรกได้

f(x,y) =
    y==1 ? x+1 :
    f(f(x,y-1),x+1)

และมันก็ยังใช้งานได้เพราะ

f(2^n, 1) = 2^n + 1 = 1

และอื่น ๆy,

f(2^n, y) = f(f(2^n, y-1), 1) = f(2^n, y-1) + 1

f(2^n, y) = yดังนั้นจากการเหนี่ยวนำที่เราได้รับ

สำหรับ CJam มันกลับกลายเป็นว่าสะดวกกว่าที่จะกลับลำดับของพารามิเตอร์ และแทนที่จะใช้ช่วงที่1 .. 2^nฉันใช้ช่วง0 .. 2^n - 1โดยลดค่าแต่ละค่าลงดังนั้นฟังก์ชันเรียกซ้ำที่ฉันใช้คือ

g(y,x) =
    y==0 ? x+1
         : g(x+1, g(y-1, x))

1           e# Initial value of 2^n
{           e# do-while loop
  2*        e#   Double 2^n (i.e. increment n)
  31T       e#   table(n,1,32) is g(31,0) so push 31 0
  W$,(+a    e#   Set up a lookup table for g(0,x) = x+1 % 2^n
  {         e#   Memoisation function body: stack is 2^n ... y x
    0X$j    e#     Compute g(0,x) = x+1 % 2^n
            e#     Stack is 2^n ... y x (x+1%2^n)
    @(      e#     Bring y to top, decrement (guaranteed not to underflow)
            e#     Stack is 2^n ... x (x+1%2^n) (y-1%2^n)
    @jj     e#     Rotate and apply memoised function twice: g(x+1,g(y-1,x))
  }
  2j        e#   Memoise two-parameter function
            e#   Stack: 2^n g(31,0)
  )W$=      e#   Test whether g(31,0)+1 is 2^n
}g          e# Loop while true

Pyth, 33 ไบต์

.N?qT^2NY?tY:N:NTtYhThT<:T1 32^2T

ลองออนไลน์! (เห็นได้ชัดว่าส่วนการทดสอบไม่รวมอยู่ที่นี่)