E in particolare la seconda legge : l'entropia di un sistema isolato aumenta nel tempo .

Per questa sfida,

• Un " sistema isolato " sarà considerato un programma o una funzione (d'ora in poi abbreviato in "programma");
• Il passare del " tempo " corrisponderà alle esecuzioni ripetute dell'output del programma , considerato come un nuovo programma;
• L '" entropia " sarà considerata come l'entropia del primo ordine di Shannon (da definire in seguito), che è una misura della diversità dei caratteri della stringa.

La sfida

Il tuo programma dovrebbe produrre una stringa non vuota che quando eseguita come un programma nella stessa lingua produce una stringa con più entropia della precedente. L'iterazione infinita di questo processo di esecuzione in uscita deve produrre una sequenza strettamente crescente di valori di entropia .

Le stringhe possono contenere qualsiasi carattere Unicode 9.0 . La sequenza di stringhe deve essere deterministica (al contrario di casuale).

L' entropia per una determinata stringa verrà definita come segue. Identifica i suoi caratteri univoci e il loro numero di occorrenze nella stringa. La frequenza p _i della i carattere unico -esimo è il numero di occorrenze di tale carattere diviso per la lunghezza della stringa. L'entropia è quindi

dove la somma è sopra tutti i caratteri univoci della stringa. Tecnicamente, questo corrisponde all'entropia di una variabile casuale discreta con distribuzione data dalle frequenze osservate nella stringa.

Lascia che H _k denoti l'entropia della stringa prodotta dal programma k -th e che H ₀ denoti l'entropia del codice del programma iniziale. Inoltre, lascia che L ₀ indichi la lunghezza del programma iniziale in caratteri. La sequenza { H _k } è monotona secondo i requisiti della sfida ed è limitata (perché il numero di caratteri esistenti è finito). Pertanto ha un limite, H _∞ .

Il punteggio di un invio sarà ( H _∞ - H ₀ ) / L ₀ :

• Il numeratore, H _∞ - H ₀ , riflette in che misura il tuo codice "obbedisce" alla legge di aumentare l'entropia in un arco di tempo infinito.
• Il denonimatore, L ₀ , è la lunghezza del codice iniziale in caratteri (non in byte).

Vince il codice con il punteggio più alto . I legami saranno risolti a favore della prima presentazione / modifica.

Per calcolare l'entropia di una stringa, puoi usare lo snippet JavaScript (per gentile concessione di @flawr e con correzioni di @Dennis e @ETHproductions ) alla fine di questo post.

Se ottenere il limite H _∞ è difficile nel tuo caso specifico, puoi usare qualsiasi limite inferiore, ad esempio H ₂₀ , per calcolare il punteggio (in modo da usare ( H ₂₀ - H ₀ ) / L ₀ ). Ma in ogni caso, la sequenza infinita di entropie deve essere strettamente crescente.

Per favore, includi una spiegazione o una breve prova che la sequenza di entropie sta aumentando, se non è evidente.

Esempio

In un linguaggio fittizio, considera il codice aabcab, che quando viene eseguito produce la stringa cdefgh, che quando viene eseguito produce cdefghi, che ...

I caratteri unici del codice originale sono a, be c, con rispettive frequenze di 3/6, 2/6 e 1/6. La sua entropia è 1.4591. Questo è H ₀ .

La stringa cdefghha più entropia di aabcab. Possiamo saperlo senza calcolarlo perché per un dato numero di caratteri l'entropia è massimizzata quando tutte le frequenze sono uguali. In effetti, l'entropia H ₁ è 2.5850.

La stringa cdefghiha di nuovo più entropia della precedente. Ora possiamo senza calcolo perché l'aggiunta di un carattere inesistente aumenta sempre l'entropia. In effetti, H ₂ è 2.8074.

Se la stringa successiva fosse 42la catena non sarebbe valida, poiché H ₃ sarebbe 1, inferiore a 2.8074.

Se, d'altra parte, la sequenza continuasse a produrre stringhe di entropia crescente con limite H _∞ = 3, il punteggio sarebbe (3 -1,4597) / 6 = 0,2567.

Ringraziamenti

Grazie a

• @xnor per il suo aiuto nel migliorare la sfida, e in particolare per avermi convinto che infinite catene di entropia crescente ottenute dall'esecuzione ripetuta sono effettivamente possibili;

• @flawr per numerosi suggerimenti, tra cui la modifica della funzione di punteggio e per la scrittura del frammento molto utile;

• @Angs per evidenziare un inconveniente essenziale in una precedente definizione della funzione score;

• @Dennis per una correzione nello snippet JavaScript;

• @ETHproductions per un'altra correzione nello snippet;

• @PeterTaylor per una correzione nella definizione di entropia.

Snippet per il calcolo dell'entropia

function calculateEntropy() {
  var input = document.getElementById("input").value; // fetch input as string
  if (/[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)|([^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/.test(input)) {
    document.getElementById("output").innerHTML = " invalid (unmatched surrogates)";
    return;
  }
  var charArray = input.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[^]/g);
  var frequency = {};
  for (var ind in charArray) {
    frequency[charArray[ind]] = 0;
  }
  var total = 0;
  for (var ind in charArray) {
    frequency[charArray[ind]] ++;
    total++;
  }
  var entropy = 0;
  for (var key in frequency) {
    var p = frequency[key] / total;
    entropy -= p * Math.log2(p);
  }
  document.getElementById("output").innerHTML = " " + entropy;
};

<button type="button" onClick="javascript:calculateEntropy();">calculate</button>Entropy: <span id="output">NaN</span> 
<br/>
<textarea id="input">asdf asdf</textarea>

Gelatina, 0.68220949

“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”©v⁵

H ₉₀ = 19.779597644909596802, H ₀ = 4.088779347361360882, L ₀ = 23

Ho usato lunghi doppi per calcolare H ₉₀ . I galleggianti a doppia precisione hanno erroneamente segnalato che H ₄₇ <H ₄₆

Viene stampato il primo programma

“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”©v1010

dove …funge da segnaposto per tutti i caratteri Unicode con punti di codice compresi tra 100.000 e 1.000.000 . La lunghezza effettiva è di 900.031 caratteri.

Il programma dei secondi viene stampato

“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”
“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”©v101010

che, a sua volta, stampa

“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”
“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”
“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”©v10101010

eccetera.

Nessuno di questi programmi funziona nell'interprete online, che ha un limite di output di 100 KB . Tuttavia, se modifichiamo il programma in modo da stampare 0123456789anziché i summenzionati 900.000 caratteri Unicode, puoi provarlo online!

MATLAB, 9.6923e-005 0.005950967872272

H0 =  2.7243140535197345, Hinf = 4.670280547752703, L0 = 327

Questa nuova versione è una versione migliorata della prima "prova di concetto". In questa versione ottengo un grande aumento del punteggio dalla prima iterazione. Ciò è stato ottenuto "facendo esplodere" l'output del primo programma, che viene replicato da tutti i successivi. Quindi ho anche cercato di trovare il minimo H0semplicemente aggiungendo il simbolo più comune del codice il maggior numero di volte possibile. (Ciò ha ovviamente avuto un limite, poiché non solo diminuisce H0ma aumenta anche L0allo stesso tempo. Puoi vedere lo sviluppo del punteggio tracciato rispetto alla dimensione del programma in cui la dimensione è variata semplicemente aggiungendo o rimuovendo 1.) Il successivo le iterazioni sono ancora equivalenti alla versione precedente di seguito.

a=['ns}z2e1e1116k5;6111gE16:61kGe1116k6111gE16:6ek7;:61gg3E1g6:6ek7;:61gg3E1'];11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111;;disp(['[''',a+1,'''];',0,'a=[''',a,'''];',0,[a-10,']]);'],0,[a-10,']]);']]);

Versione precedente:

H0 = 4.22764479010266, Hinf = 4.243346286312808, L0 = 162

Il seguente codice è ispirato al matlab quine . Fondamentalmente viene emesso di nuovo solo due volte . L'indizio è che per ogni iterazione abbiamo nrighe di codice e n-1simboli newline \n. Così come si navvicina all'infinito, il rapporto tra linee di codice e newline si avvicina a 1, e allo stesso tempo questo garantisce che abbiamo una crescita strettamente monotona nell'entropia. Ciò significa anche che possiamo facilmente calcolare Hinfsemplicemente considerando il codice di generazione zero con altrettante nuove righe come righe di codice. (Quale può confermare sperimentalmente, in quanto converge abbastanza rapidamente.)

a=['ns}z2e1kGe1116k6111gE16;:61kGe1116k6111gE16;:6ek7;:61gg3E1g6;:6ek7;:61gg3E1'];
disp(['a=[''',a,'''];',10,'a=[''',a,'''];',10,[a-10,']]);'],10,[a-10,']]);']]);