Quali sono i programmi molto brevi con stato di arresto sconosciuto?

Questo programma a 579 bit nel calcolo binario Lambda ha uno stato di arresto sconosciuto:

01001001000100010001000101100111101111001110010101000001110011101000000111001110
10010000011100111010000001110011101000000111001110100000000111000011100111110100
00101011000000000010111011100101011111000000111001011111101101011010000000100000
10000001011100000000001110010101010101010111100000011100101010110000000001110000
00000111100000000011110000000001100001010101100000001110000000110000000100000001
00000000010010111110111100000010101111110000001100000011100111110000101101101110
00110000101100010111001011111011110000001110010111111000011110011110011110101000
0010110101000011010

Cioè, non è noto se questo programma termina o meno. Per determinarlo, devi risolvere la congettura di Collatz - o, almeno, per tutti i numeri fino a 2 ^ 256. Su questo repository c'è una spiegazione completa di come è stato ottenuto questo programma.

Ci sono (molto) programmi BLC più brevi che hanno anche uno stato di arresto sconosciuto?

Sì. Questa pagina dice che ci sono 98 5-state le macchine di Turing i cui stati di arresto sono sconosciute. Stranamente, non fornisce alcun esempio di tali macchine, ma questa pagina di 26 anni offre 2 macchine Turing a 5 stati i cui stati di arresto apparentemente erano sconosciuti in quel momento. (La ricerca di "contatore semplice" ti porterà esattamente tra quelle 2.) Le ho copiate qui nel caso in cui quel link dovesse scendere:

Input Bit   Transition on State     Steps            Comment
             A   B   C   D   E

    0       B1L C1R D0R A1L H1L   > 2*(10^9)       ``chaotic''
    1       B1R E0L A0L D0R C0L

    0       B1L A0R C0R E1L B0L       ?        complex ``counter''
    1       A1R C0L D1L A0R H1L

Congettura di Collatz:

Il seguente programma si ferma sempre:

void function( ArbitraryInteger input){
     while( input > 1){
            if(input % 2 == 0)
                input /= 2;
            else
                input = (input*3) + 1;
     }

     // Halt here
}

Leggera variazione (ancora una congettura, perché si basa su un risultato di quello di Collatz):

Per alcuni input il seguente programma non entrerà mai nello stesso stato due volte (dove lo stato è determinato dal valore mantenuto da "input"):

void function( ArbitraryInteger input){
     while( input >= 1){ // notice the "="
            if(input % 2 == 0)
                input /= 2;
            else
                input = (input*3) + 1;
     }
}

Si noti che il secondo programma non si arresta mai, indipendentemente dal fatto che il primo programma si arresti o meno.

Si ritiene che il primo programma termini sempre per qualsiasi input, tuttavia non ne abbiamo la prova e potrebbe esistere ancora un numero intero per il quale il programma non si ferma (c'è anche un premio di $ 100 per dimostrarlo) .

Anche il secondo programma è interessante: afferma che il programma non entrerà mai nello stesso stato due volte per alcuni input, il che richiede sostanzialmente che il primo programma abbia una sequenza nota per divergere senza ripetere. Non solo richiede che la congettura di Collatz sia falsa, ma richiede che sia falsa e senza anelli , a parte l'ovvio ciclo 1,4,2,1.

• Se Collatz ha solo contro-esempi in loop, la variazione sulla congettura è falsa

• Se Collatz è falso senza loop, la variazione sulla congettura è vera

• Se Collatz è vero, la variazione è falsa

• Se Collatz è falso sia perché ha anelli sia perché ha un numero per cui diverge, la variazione sulla congettura è vera (richiede solo un numero per cui diverge senza entrare in un ciclo)

Penso che la variazione sia più interessante (non solo perché l'ho trovata per caso e l'ho notata grazie a @LieuweVinkhuijzen), ma perché in realtà richiede una vera prova. Con la forza bruta, potremmo essere in grado di trovare un loop un giorno o l'altro (e che sarà un loop più lungo di 70 numeri: lo stato dell'arte attuale è che non ci possono essere infiniti loop più corti di 68 o giù di lì) e brute forzare non è interessante: è solo uno scricchiolio dei numeri. Tuttavia non possiamo forzare una sequenza divergente infinita, non sappiamo se finirà davvero senza una vera prova.

EDIT: Ho scusato la parte sulla congettura di Collatz Mi dispiace, ho sinceramente risposto a memoria con un algoritmo che ho letto alcuni anni fa, non mi aspettavo che fosse già stato menzionato.

EDIT2: Un commento mi ha fatto notare che ho scritto l'algoritmo con un errore, tuttavia, quell'errore rende la mia risposta diversa dalla congettura di Collatz (ma una sua variazione diretta).