Les tableaux de Laver fournissent des exemples de programmes qui ne se sont pas révélés se terminer dans le système axiomatique standard de mathématiques ZFC mais qui se terminent lorsque l'on suppose de très grands axiomes cardinaux.

introduction

Les tables classiques Laver sont les algèbres finies uniques avec ensemble sous - jacent et une opération qui satisfait l'identité et où pour et où .An{1,...,2n}*x * (y * z)=(x * y) * (x * z)x*1=x+1x<2n2n*1=1

Vous trouverez plus d'informations sur les tables Laver classiques dans le livre Braids and Self-Distributivity de Patrick Dehornoy.

Défi

Quel est le code le plus court (en octets) qui calcule 1*32dans les tables Laver classiques et se termine précisément lorsqu'il trouve un navec ? En d'autres termes, le programme se termine si et seulement s'il trouve un avec mais sinon il s'exécute indéfiniment.1*32<2nn1*32<2n

Motivation

Un cardinal de rang (également appelé cardinal I3) est un niveau d'infini extrêmement élevé et si l'on suppose l'existence d'un cardinal de rang, alors on est en mesure de prouver plus de théorèmes que si l'on ne le fait pas. supposons l'existence d'un cardinal de rang en rang. S'il existe un cardinal de rang en rang, alors il y a une table Laver classique où . Cependant, il n'y a aucune preuve connue que dans ZFC. Par ailleurs, il est connu que le moins où est supérieur à (ce qui est un nombre extrêmement important puisque la fonction Ackermann est une fonction à croissance rapide). Par conséquent, un tel programme durera très longtemps.An1*32<2n1*32<2nn1*32<2nAck(9,Ack(8,Ack(8,254)))Ack

Je veux voir à quel point un programme peut être écrit pour que nous ne sachions pas si le programme se termine en utilisant le système axiomatique standard ZFC mais où nous savons que le programme se termine finalement par un système axiomatique beaucoup plus fort, à savoir ZFC + I3. Cette question a été inspirée par le récent article de Scott Aaronson dans lequel Aaronson et Adam Yedidia ont construit une machine de Turing avec moins de 8000 états de sorte que ZFC ne peut pas prouver que la machine de Turing ne se termine pas mais est connue pour ne pas se terminer lorsque l'on suppose de grandes hypothèses cardinales.

Comment les tables Laver classiques sont calculées

Lors du calcul des tables , il est généralement Laver pratique d'utiliser le fait que , dans l'algèbre , nous avons pour tous dans .An2n * x=xxAn

Le code suivant calcule la table Laver classique An

# table (n, x, y) renvoie x * y dans A n
table: = fonction (n, x, y)
si x = 2 ^ n alors retourne y;
elif y = 1 puis retourne x + 1;
else retour table (n, table (n, x, y-1), x + 1); Fi; fin;

Par exemple, l'entrée table(4,1,2)reviendra 12.

Le code de table(n,x,y)est plutôt inefficace et il ne peut calculer dans la table Laver que dans un délai raisonnable. Heureusement, il existe des algorithmes beaucoup plus rapides pour calculer les tables Laver classiques que ceux donnés ci-dessus.A4

Calcul lambda binaire, 215 bits (27 octets)

\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

compile vers (en utilisant un logiciel à https://github.com/tromp/AIT )

000101000110100000010101010100011010000000010110000101111110011110010111
110111100000010101111100000011001110111100011000100000101100100010110101
00000011100111010100011001011101100000010111101100101111011001110100010

Cette solution est principalement due à https://github.com/int-e

CJam ( 36 32 octets)

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

En pratique, cette erreur sort assez rapidement car elle déborde de la pile d'appels, mais sur une machine théorique illimitée, elle est correcte, et je comprends que c'est l'hypothèse de cette question.

Le code de table(n,x,y)est plutôt inefficace et il ne peut calculer dans la table Laver A _{4 que} dans un temps raisonnable.

n'est pas réellement correct si nous mettons en cache les valeurs calculées pour éviter de les recalculer. C'est l'approche que j'ai adoptée, en utilisant l' jopérateur (mémoisation) . Il teste A ₆ en millisecondes et déborde le test de pile A ₇ - et j'ai en fait désoptimisé table dans l'intérêt du golf.

Dissection

Si nous supposons que cela nest compris dans le contexte, au lieu de

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

nous pouvons retirer le premier cas spécial, en donnant

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

et ça marche toujours parce

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

et pour tout autre y,

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

donc par induction nous obtenons f(2^n, y) = y.

Pour CJam, il s'avère plus pratique d'inverser l'ordre des paramètres. Et plutôt que d'utiliser la plage, 1 .. 2^nj'utilise la plage 0 .. 2^n - 1en décrémentant chaque valeur, donc la fonction récursive que j'implémente est

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 octets

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

Essayez-le en ligne! (Évidemment, la partie test n'est pas incluse ici.)