Prova di non regolarità, basata sulla complessità di Kolmogorov

In classe il nostro professore ci ha mostrato 3 metodi per dimostrare la non regolarità:

1. Teorema di Myhill – Nerode
2. Pompaggio di Lemma per le lingue normali
3. Prova di non regolarità, basata sulla complessità di Kolmogorov

Ora i primi due, il teorema di Myhill-Nerode e il lemma di pompaggio, ho capito bene e sono stato anche in grado di fare gli esercizi con i primi due metodi. Ma non ho capito il terzo. La definizione del terzo metodo è la seguente:

Permettere $\ L \subseteq (\Sigma_{bool})^*$essere una lingua normale. Let per ogni . Quindi esiste una costante , tale che per tutti$\ L_x=\{ y \in (\Sigma_{bool})^* | xy\in L \}$$\ x \in (\Sigma_{bool})^*$$\ c$$\ x,y \in (\Sigma_{bool})^*$

$\ K(y) \leq \lceil log_2(n+1)\rceil+c$

se è la nona parola nella lingua .$\ y$$\ L_x$

Ora non capisco come usare questo teorema per dimostrare che una lingua non è regolare, non capisco davvero il concetto. Abbiamo usato la complessità di kolmogorov prima per determinare la lunghezza del programma per computer più breve di un oggetto. Come si dimostra la non regolarità con questo teorema? E qual è il pensiero dietro?

Molte grazie!

Per quanto ne sappia, questo non è uno degli approcci "classici" utilizzati per caratterizzare le lingue regolari.

Questo approccio è discusso in "Un nuovo approccio alla teoria del linguaggio formale della complessità Kolmogorov" , di Ming Li e Paul MB Vitanyi (vedere la sezione 3.1).

Forniscono diversi esempi in cui è possibile utilizzare la frase menzionata anziché utilizzare il lemma di pompaggio. Ad esempio, dimostrando la non regolarità di$L$ dove

$L=\left\{1^p|\text{p is prime}\right\}$.

Dato alcuni $x\in\Sigma^*$, $L_x=\left\{y| \hspace{1mm} xy=1^p \land \text{p is prime}\right\}$. Scegliamo$x=1^{p'}$ dove $p'$ è il $k$primo. Permettere$y_1$ sii la prima parola dentro $L_x$. Ovviamente,$y_1=1^{p-p'}$ dove $p$ è il $k+1$Prime. Secondo la dichiarazione che hai citato,$K(y_1)\le c$ ($n=1$), per qualche costante $c$ dipende solo da $L$ (vedi documento).

Dal momento che questo vale per tutti $x$, possiamo legare la complessità di Kolmogorov di tutti gli elementi in $S=\left\{y_1^x| x=1^p \text{ for prime $p$ } \land \text{$y_1^x$ is the first string in $L_x$}\right\}$ dalla stessa costante $c$. Tuttavia, l'abbiamo visto$S$ in realtà consiste in differenze tra numeri primi consecutivi, vale a dire $S=\left\{1^{p_{k+1}-p_k} | k\ge 1\right\}$ dove $p_k$ è il $k$primo. Dal momento che sappiamo$S$ non può aver limitato la complessità di Kolmogorov (le differenze principali diventano arbitrariamente grandi), questo significa $L$ non può essere regolare.

Un altro esempio molto semplice è il seguente: utilizzare la complessità di Kolmogorov per dimostrarlo $L_{ww} = \{ww \mid w \in \{0,1\}^* \}$ non è regolare.

Ti do una prova molto informale sperando che possa aiutarti a capire meglio il ruolo della complessità di Kolmogorov.

L'idea chiave è la seguente: un automa finito $D$ (che riconosce una lingua normale $L_D$) ha una quantità finita di "memoria"; quindi in esecuzione su una stringa di input$x = yz$ quando ha "elaborato" la prima parte dell'input $y$ l'appartenenza di $x$ in $L_D$ dipende solo dal suo stato attuale e dalla seconda parte dell'input $z$.

Ora supponiamo che $L_{ww}$è regolare; poi c'è un DFA$D_{ww}$ questo lo riconosce.

Permettere $y$ essere una stringa incomprimibile di lunghezza $|y| = n \gg |D|$

Per tutti gli ingressi $x=y z$, alla fine della prima parte $y$, il DFA $D_{ww}$ sarà chiaramente sullo stesso stato $q_i$e per ipotesi accetterà solo se la parte rimanente $z$ è tale che $x = y z$ può essere diviso in due metà uguali (es $yz = ww$); per esempio

 Let y = 10110
       y   z
 x = 10110 0  >> rejected
 x = 10110 1  >> accepted  (w=101, |y|>|z|)
 x = 10110 00 >> rejected
 x = 10110 01 >> rejected
 ....
 x = 10110 10110 >> accepted  (w=10110,  |y|=|z| !!!)
 ....
 x = 10110 1101101 >> accepted (w=101101, |z|<|y|

Ma è importante notare che esiste solo una stringa $z$ di lunghezza $|y|$ che è accettato ($z = y$).

Quindi, data la descrizione di $D_{ww}$, lo stato $q_i$ alla fine di $y$e la lunghezza $|y|$ possiamo simulare il comportamento di $D_{ww}$ su tutto il $2^{|y|}$ stringhe e vedere quale di esse accetta ... ma accetta esattamente $z=y$.

Quindi con un programma di dimensioni $\ell = |D_{ww}| + \log{i} + \log y + c$

($|D_{ww}|$ è necessario spazio per memorizzare la descrizione di $D_{ww}$, $\log i$ spazio per riporre $q_i$, $\log y$ spazio per memorizzare la lunghezza di $y$, $c$ è necessario spazio per le istruzioni che simulano il DFA)

possiamo "ricostruire" la stringa $y$; ma abbastanza grande$y$ noi abbiamo $\ell < |y|$ che è una contraddizione perché $y$ è incomprimibile.