Determinare le capacità di un min-heap (o di altre macchine esotiche)

Vedere la fine di questo post per alcuni chiarimenti sulla definizione (i) degli automi min-heap.

Si può immaginare di utilizzare una varietà di strutture di dati per archiviare informazioni per l'uso da parte di macchine a stati. Ad esempio, gli automi push-down archiviano le informazioni in uno stack e le macchine Turing utilizzano un nastro. Le macchine a stati che usano le code e quelle che usano due pile o nastri multipli hanno dimostrato di essere equivalenti in potenza alle macchine di Turing.

Immagina una macchina heap min. Funziona esattamente come un automa push-down, con le seguenti eccezioni:

1. Invece di guardare l'ultima cosa che hai aggiunto all'heap, puoi solo guardare l'elemento più piccolo (con l'ordinamento definito su una base per macchina) attualmente nell'heap.
2. Invece di rimuovere l'ultima cosa che hai aggiunto all'heap, puoi solo rimuovere uno degli elementi più piccoli (con l'ordinamento definito su una base per macchina) attualmente nell'heap.
3. Invece di aggiungere un elemento nella parte superiore dell'heap, è possibile solo aggiungere un elemento all'heap, con la sua posizione determinata in base agli altri elementi nell'heap (con l'ordinamento definito su una base per macchina).

Questa macchina può accettare tutte le lingue normali, semplicemente non usando l'heap. Può anche accettare la lingua $\displaystyle \{a^{n}b^{n} \in \{a, b\}^{*} \mid n \ge 0\}$ aggiungendo $a$ 'h all'heap e rimuovendo $a$ ' h dall'heap quando legge $b$ '. Può accettare una varietà di altre lingue senza contesto. Tuttavia, non può accettare, ad esempio, $\displaystyle \{w \in \{a, b\}^{*} \mid w = w^{R}\}$(dichiarato senza prove). EDIT: o può? Non credo che possa, ma sono stato sorpreso prima, e sono sicuro che continuerò a essere sorpreso quando i miei presupposti continueranno a farmi un ... beh.

Può accettare lingue sensibili al contesto o complete di Turing?

Più in generale, quali ricerche sono state condotte in questa direzione? Quali risultati ci sono, se ce ne sono? Sono anche interessato ad altre varietà di macchine a stati esotici, forse quelle che utilizzano altre strutture di dati per l'archiviazione o vari tipi di restrizioni di accesso (ad esempio, come le LBA sono restrizioni alle TM). I riferimenti sono apprezzati. Mi scuso in anticipo se questa domanda sta dimostrando ignoranza.

Definizione formale:

Fornisco qui alcune definizioni più dettagliate degli automi min-heap al fine di chiarire ulteriori discussioni in domande che fanno riferimento a questo materiale.

Definiamo un automa non heap non deterministico di tipo 1 come una 7 tupla dove ...

1. è un insieme finito di stati non vuoti;$Q$
2. è lo stato iniziale;$q_0 \in Q$
3. è l'insieme degli stati accettanti;$A \subseteq Q$
4. è un alfabeto di input finito, non vuoto;$\Sigma$
5. è un alfabeto di input finito, non vuoto, in cui il peso di un simbolo γ ∈ Γ , w ( γ ) ∈ N , è tale che w ( γ 1 ) = w ( γ 2$\Gamma$$\gamma \in \Gamma$$w(\gamma) \in \mathbb{N}$ ;$w(\gamma_1) = w(\gamma_2) \iff \gamma_1 = \gamma_2$
6. è il simbolo speciale della parte inferiore dell'heap;$Z_0 \notin \Gamma$
7. è la funzione di transizione.$\delta : Q \times (\Sigma \cup \{\epsilon\}) \times (\Gamma \cup \{Z_0\}) \rightarrow \mathcal{P}({Q \times \Gamma^*})$

La funzione di transizione funziona presupponendo un heap inizialmente vuoto costituito solo da . La funzione di transizione può aggiungere al mucchio una raccolta arbitraria (finita, ma possibilmente vuoto o con ripetizioni) di elementi y 1 , γ 2 , . . . , γ k ∈ Γ . In alternativa, la funzione di transizione può rimuovere un'istanza dell'elemento γ con il peso più basso w ( γ $Z_0$$\gamma_1, \gamma_2, ..., \gamma_k \in \Gamma$$\gamma$$w(\gamma)$di tutti gli elementi rimanenti sull'heap (ovvero l'elemento sopra l'heap). La funzione di transizione può usare solo l'istanza di simbolo più in alto (cioè di peso minimo) per determinare una data transizione.

Inoltre, definire un automa deterministico di heap min di tipo 1 come un automa non deterministico di heap di tipo 1 che soddisfa la seguente proprietà: per tutte le stringhe tale che | x | = n e σ ∈ Σ , | δ n + 1 ( q 0 , x σ y , Z 0 ) | ≤ 1 .$x{\sigma}y \in \Sigma$$|x| = n$$\sigma \in \Sigma$$|\delta^{n+1}(q_0, x{\sigma}y, Z_0)| \leq 1$

Definire anche un automa non heap non deterministico di tipo 2 esattamente uguale a un automa heap min non deterministico di tipo 1, ad eccezione delle seguenti modifiche:

1. è un alfabeto di input finito, non vuoto, in cui il peso di un simbolo γ ∈ Γ , w ( γ ) ∈ N , è tale che w ( γ 1 ) = w ( γ 2 ) non implica necessariamente γ 1 = γ 2 ; in altre parole, diversi simboli heap possono avere lo stesso peso.$\Gamma$$\gamma \in \Gamma$$w(\gamma) \in \mathbb{N}$$w(\gamma_1) = w(\gamma_2)$$\gamma_1 = \gamma_2$
2. Quando all'heap vengono aggiunte istanze di simboli heap distinti con lo stesso peso, il loro ordine relativo viene conservato in base a un ordinamento simile a stack last-in, first-out (LIFO).

Grazie a Raffaello per aver sottolineato questa definizione più naturale, che cattura (ed estende) le lingue senza contesto.

Alcuni risultati hanno dimostrato finora:

1. Gli automi min-heap di tipo 1 riconoscono un insieme di lingue che non è né un sottoinsieme né un superset delle lingue senza contesto. [ 1 , 2 ]
2. Gli automi min-heap di tipo 2, per definizione, riconoscono un insieme di lingue che è un corretto superset delle lingue senza contesto, nonché un superset adeguato delle lingue accettate dagli automi min-heap di tipo 1.
3. Le lingue accettate dagli automi min-heap di tipo 1 sembrano essere chiuse sotto unione, concatenazione e stella di Kleene, ma non sotto complementazione [ 1 ], intersezione o differenza;
4. Le lingue accettate dagli automi non heap non deterministici di tipo 1 sembrano essere un vero e proprio insieme di lingue accettate dagli automi deterministici heap min di tipo 1.

Potrebbero esserci alcuni altri risultati che ho perso. Altri risultati sono (probabilmente) in arrivo.

Domande di follow-up

1. Chiusura invertita? -- Aperto
2. Chiusura sotto integrazione? -- No!
3. Il non determinismo aumenta il potere? -- Sì?
4. $HAL \subsetneq CSL$
5. L'aggiunta di heap aumenta la potenza per il tipo 1? - per (?)$HAL^1 \subsetneq HAL^2 = HAL^k$$k > 2$
6. L'aggiunta di uno stack aumenta la potenza per il tipo 1? -- Aperto

È possibile riconoscere il linguaggio canonico non privo di contesto (ma sensibile al contesto) con questo tipo di macchina a stati. Il punto cruciale è che si aggiunge gettoni al mucchio per ogni personaggio, e durante l'analisi dei caratteri, si aggiunge token 'grandi' al mucchio, così finiscono solo fino al fondo del mucchio dopo aver analizzato tutti i personaggi.$\{ a^n b^n c^n\ |\ n \geq 1 \}$$a$$b$$b$

I simboli heap sono e , dove . Noi consumiamo tutte le simboli sull'ingresso e aggiungere simbolo al mucchio. Se incontriamo una , cambiamo strategia: per ogni che incontriamo successivamente rimuoviamo una dall'heap e aggiungiamo una all'heap. Quando incontriamo una avremmo dovuto esaurire s per rimuoverla, quindi per ogni nell'input rimanente rimuoviamo una dall'heap. Se l'heap è vuoto alla fine, la stringa è nella lingua. Ovviamente, rifiutiamo se qualcosa va storto.$a$$b$$a < b$$a$$a$$b$$b$$a$$b$$c$$a$$c$$b$

Aggiornare:

La lingua non può essere riconosciuto dagli automi min-heap. Supponiamo di avere un automa min-heap in grado di riconoscere . Osserviamo lo 'stato' in cui si trova l'automa dopo aver letto (la prima parte dell'ingresso, quindi è il prossimo). L'unico stato che abbiamo sono i contenuti del cumulo e la particolare stato della automa è in. Ciò significa che, dopo aver riconosciuto , questo esigenze degli statali per contenere informazioni sufficienti per corrispondere .$EPAL = \{ ww^R | w \in \{a, b\}^* \}$$EPAL$$w$$w^R$$w$$w^R$

In particolare, per fare ciò, ci devono essere possibili diversi 'stati' (dove ), in quanto vi sono parole possibili costituite da e caratteri. Poiché ci sono solo un numero finito di stati e solo un numero finito di caratteri heap, ciò implica che esiste una parola per la quale l'heap contiene un numero esponenziale di alcuni caratteri heap, diciamo .$2^n$$n = |w|$$2^n$$a$$b$$w$$x$

Dimostriamo innanzitutto il teorema per gli automi deterministici dell'heap min, quindi estendiamo questa dimostrazione agli automi non deterministici dell'heap min. In particolare, gli automi deterministici che riconoscono un certo linguaggio non si inseriranno in un ciclo infinito, che è una proprietà utile.

Dimostreremo che l'heap può contenere al massimo solo un numero di token heap che è lineare nel numero di caratteri letti dall'input. Ciò esclude immediatamente che appare un numero esponenziale di volte sull'heap, il che completa la prova che non può essere riconosciuto dagli automi min-heap.$x$$EPAL$

Poiché abbiamo solo un numero finito di stati nel nostro automa e poiché un automa deterministico non si inserirà in un ciclo infinito, leggendo un segnale di input aggiungerà al massimo un numero costante di caratteri heap sull'heap. Allo stesso modo, consumando qualche simbolo di heap , può solo aggiungere al massimo un numero costante di caratteri heap che sono strettamente più grandi di e può solo ridurre il numero di simboli nello stack (altrimenti otteniamo un ciclo infinito).$y$$y$$y$

Il consumo di simboli heap può quindi causare un (enorme) accumulo di simboli heap più grandi, ma poiché esiste solo un numero costante di diversi tipi di simboli heap, questo è solo un numero costante non dipendente da . Ciò implica che il numero di simboli heap è al massimo alcune (grandi) costanti volte il numero di simboli di input letti finora. Questo completa la prova per il caso deterministico.$n$

Nel caso non deterministico, la dimostrazione è simile, ma un po 'più complicata: invece di aggiungere al massimo un numero costante di token heap all'heap, aggiunge un numero arbitrario di token heap all'heap. Tuttavia, il punto cruciale è che questo numero non dipende da . In particolare, se possiamo ottenere in modo non deterministico esattamente i simboli di heap giusti sull'heap dopo aver riconosciuto (giusto per riconoscere ), possiamo anche scegliere in modo non deterministico i simboli di heap che corrispondono ad altre parole , e quindi riconoscere , contraddicendo così che l'automa min-heap riconosce esattamente .$n$$w$$w^R$$w'$$w w'^R$$EPAL$

Aggiornamento 3: renderò rigoroso l'ultimo argomento (sul non determinismo). Con l'argomento precedente, deve esistere un insieme infinito di paroletale che per ogni, dopo aver riconosciuto, l'heap contieneelementi ( nota che possiamo parlare didato che abbiamo un insieme infinito di parole). Dato che non possiamo ottenere così tanti elementi sull'heap con mezzi deterministici, dobbiamo aver avuto una qualche forma di loop in cui abbiamo prima scelto in modo non deterministico di aggiungere più elementi all'heap (senza consumare input), e successivamente abbiamo scelto di uscire da questo loop, e dobbiamo aver attraversato questo loopvolte.$W \subseteq \{a,b\}^*$$w \in W$$w$$\omega(|w|)$$O(f(|w|))$$\omega(1)$

Prendere l'insieme di tutti questi loop utilizzati da . Poiché esistono solo stati , la dimensione di questo set è e anche l'insieme di tutti i suoi sottoinsiemi è . Ora nota che la parte "deterministica" dei percorsi di esecuzione può solo contribuire a dei token, il che significa che gran parte del numero esponenziale di parole diverse deve avere percorsi di esecuzione le cui parti "deterministiche" contribuiscono allo stesso token al mucchio. In particolare, l'unico modo per ottenere più token è prendere i loop che abbiamo identificato sopra.$W$$O(1)$$O(1)$$O(1)$$O(|w|)$

Combinando queste osservazioni, ciò significa che in , e devono essere presenti due parole distinte , la cui parte "deterministica" dei percorsi di esecuzione contribuisce con gli stessi token e che si differenziano prendendo alcuni sottogruppi dei loop sopra un numero diverso di volte, ma che usano lo stesso sottoinsieme di loop (ricordate che ci sono solo di questi loop).$W$$w_1$$w_2$$O(1)$

Ora possiamo mostrare che può essere riconosciuto anche dall'automa min-heap: seguiamo il percorso di esecuzione per come sopra, ma attraversiamo i loop lo stesso numero di volte che il percorso di esecuzione per li attraversa. Questo riempie il min-heap di token in modo tale che sia accettato come suffisso, completando così la prova.$w_1 w_2$$w_1$$w_2$$w_2$

Aggiornamento 2:

Mi è appena venuto in mente che quanto sopra significa che possiamo simulare un automa deterministico dell'heap min usando solo lo spazio logaritmico: manteniamo un contatore per ogni tipo di personaggio nell'heap min. Come mostrato sopra, questo contatore sarà al massimo e quindi può essere memorizzato usando solo lo spazio (poiché esiste solo un numero costante di questi contatori). Questo ci dà:$O(n)$$O(\log n)$

$\mathrm{DHAL} \subset \mathrm{L}$

$\mathrm{HAL} \subset \mathrm{NL}$

dove è l'insieme di lingue riconosciute da alcuni automi deterministici dell'heap min.$\mathrm{DHAL}$

Ecco cosa sappiamo (crediamo):

• $\mathrm{HAL} \setminus \mathrm{CFL} \neq \emptyset$ (tipo-1, tipo-2)
• $\mathrm{CFL} \setminus \mathrm{HAL} \neq \emptyset$ (tipo-1)
• $\mathrm{CFL} \subseteq \mathrm{HAL}$ (tipo-2, per definizione)
• $\mathrm{CSL} \setminus \mathrm{HAL} \neq \emptyset$ (tipo-1, tipo-2)

Vedi i dettagli e alcune altre note di seguito.

$\mathrm{HAL} \setminus \mathrm{CFL} \neq \emptyset$

Questa parte della risposta riguarda sia il tipo 1 che il tipo 2.

Un automa min-heap (HA) con alfabeto heap finito, totalmente ordinato accetta .$L = \{ a^nb^nc^n \mid n \in \mathbb{N} \} \in \mathrm{CSL} \setminus \mathrm{CFL}$

Presupposti: simile al PDA, la nostra funzione di transizione consuma il simbolo di heap più in alto e riscrive un numero arbitrario di simboli di heap. L'heap inizialmente contiene un simbolo distinto che è più grande di tutti gli altri simboli heap.$\$$

Sia un automa min-heap con$A = (Q,\Sigma_I, \Sigma_H, \rightarrow, q_0, Q_F)$

• $Q = \{q_0, q_1, q_2, q_f\}$ l'insieme di stati
• $\Sigma_I = \{a,b,c\}$ l'alfabeto di input.
• $\Sigma_H = {a,b,\$}$ l'alfabeto heap con l'ordinamento .$a \lt b \lt \$$
• $Q_F = \{q_f\}$
• $\rightarrow\ \subseteq (Q \times \Sigma_I \times \Sigma_H) \times (Q \times \Sigma_H^*)$ con
  • $(q_0,a,\sigma) \rightarrow (q_0, a\sigma)$ per tutti$\sigma \in \Sigma_H$
  • $(q_0,b,a) \rightarrow (q_1,b)$
  • $(q_1,b,a) \rightarrow (q_1,b)$
  • $(q_1,c,b) \rightarrow (q_2,\varepsilon)$
  • $(q_2,c,b) \rightarrow (q_2, \varepsilon)$
  • $(q_2,c,\$) \rightarrow (q_f, \varepsilon)$

L'automa scrive uno al mucchio per ogni nell'input. Quando si verifica una , consuma tante quante sono state , scrivendo una nell'heap per ogni trovata . Questo non disturba il conteggio perché l'heap mantiene convenientemente in cima. Solo dopo che tutte le sono state prese dall'heap sono accettate ; solo dopo quanti come (e con esso come ) si trovano, non accetta con mucchio vuoto e stato finale.$a$$a$$b$$b$$a$$b$$b$$a$$a$$c$$c$$b$$a$$A$

Pertanto, .$\cal{L}(A) = L$

$\mathrm{CFL} \setminus \mathrm{HAL} \neq \emptyset$

Questa parte della risposta riguarda solo il tipo 1.

Considerare l'insieme di palindromi pari e assumere c'è HA con .$\mathrm{EPAL} = \{ww^R \mid w \in \{a,b\}\}$$A$$\cal{L}(A) = L$

Congettura: troviamo con etale che è nello stesso stato e ha lo stesso contenuto di heap dopo aver letto rispettivamente e . Poiché accetta sia sia , accetta quindi anche (e ), che è una contraddizione in .$w_1, w_2 \in \{a,b\}^*$$w_1 \neq w_2$$|w_1| = |w_2|$$A$$w_1$$w_2$$A$ w 2 w R 2 w 1 w R 2 ∉ E P A L w 2 w R $w_1w_1^R$$w_2w_2^R$$w_1w_2^R \notin \mathrm{EPAL}$$w_2w_1^R$$\cal{L}(A) = \mathrm{EPAL}$

$\mathrm{CSL} \setminus \mathrm{HAL} \neq \emptyset$

Questa parte della risposta riguarda sia il tipo 1 che il tipo 2.

Lo stesso ragionamento che abbiamo usato su (per il tipo-1) può essere usato per mostrare che il linguaggio sensibile al contesto non è in . { w w ∣ w ∈ { a , b } ∗ } H A $\mathrm{EPAL}$$\{ww \mid w \in \{a,b\}^*\}$$\mathrm{HAL}$

$\mathrm{HAL} \overset{?}{\subseteq} \mathrm{CSL}$

Questo è ancora aperto sia per il tipo 1 che per il tipo 2.

Ulteriori Factoidi

L'HA sembra essere ortogonale a un sottoinsieme dei linguaggi leggermente sensibili al contesto accettati dagli Embedded Pushdown Automata : mentre l'HA può simulare un numero limitato di stack impilati, non possono simularne arbitrariamente molti (come l'EPA). Tuttavia, HA può accedere ai simboli principali delle pile attualmente non in cima (cosa che l'EPA non può).