Determinando recursos de máquinas de estado min-heap (ou outras exóticas)

Veja o final deste post para obter alguns esclarecimentos sobre as definições de autômatos de min-heap.

Pode-se imaginar o uso de uma variedade de estruturas de dados para armazenar informações para uso por máquinas de estado. Por exemplo, autômatos push-down armazenam informações em uma pilha e as máquinas de Turing usam uma fita. As máquinas de estado que usam filas e aquelas que usam duas pilhas ou fitas múltiplas mostraram ser equivalentes em potência às máquinas de Turing.

Imagine uma máquina min-heap. Funciona exatamente como um autômato push-down, com as seguintes exceções:

1. Em vez de examinar a última coisa que você adicionou ao heap, apenas o menor elemento (com a ordem definida por máquina) atualmente no heap.
2. Em vez de remover a última coisa que você adicionou ao heap, você só pode remover um dos menores elementos (com a ordem definida por máquina) atualmente no heap.
3. Em vez de adicionar um elemento à parte superior do heap, você pode adicionar apenas um elemento ao heap, com sua posição sendo determinada de acordo com os outros elementos no heap (com a ordem definida por máquina).

Esta máquina pode aceitar todos os idiomas comuns, simplesmente não usando o heap. Ele também pode aceitar o idioma adicionando 's ao heap, e remover 's da pilha quando lê 's. Pode aceitar uma variedade de outras linguagens sem contexto. No entanto, ele não pode aceitar, por exemplo, (declarado sem prova). EDIT: ou pode? Acho que não, mas já fiquei surpreso antes, e tenho certeza de que ficarei surpreso quando minhas suposições continuarem me fazendo um ... bem.$\displaystyle \{a^{n}b^{n} \in \{a, b\}^{*} \mid n \ge 0\}$$a$$a$$b$$\displaystyle \{w \in \{a, b\}^{*} \mid w = w^{R}\}$

Ele pode aceitar qualquer linguagem sensível ao contexto ou completa de Turing?

De maneira mais geral, que pesquisa, se houver alguma, foi realizada nessa direção? Que resultados existem, se houver? Também estou interessado em outras variedades de máquinas de estado exóticas, possivelmente aquelas que usam outras estruturas de dados para armazenamento ou vários tipos de restrições de acesso (por exemplo, como os LBAs são TMs restritos). Referências são apreciadas. Peço desculpas antecipadamente se esta pergunta está demonstrando ignorância.

Definição formal:

Fornecemos aqui algumas definições mais detalhadas de autômatos de min-heap, a fim de esclarecer uma discussão mais aprofundada em questões que fazem referência a este material.

Definimos um autômato de heap não-determinístico tipo 1 como uma tupla de 7 que ...

1. $Q$ é um conjunto de estados finito e não vazio;
2. $q_0 \in Q$ é o estado inicial;
3. $A \subseteq Q$ é o conjunto de estados que aceitam;
4. $\Sigma$ é um alfabeto de entrada finito e não vazio;
5. γ ∈ Γ w ( γ ) ∈ N w ( γ 1 ) = w ( γ 2$\Gamma$ é um alfabeto de entrada finito e não vazio, em que o peso de um símbolo , , é tal que ;$\gamma \in \Gamma$$w(\gamma) \in \mathbb{N}$$w(\gamma_1) = w(\gamma_2) \iff \gamma_1 = \gamma_2$
6. $Z_0 \notin \Gamma$ é o símbolo especial da parte inferior da pilha;
7. $\delta : Q \times (\Sigma \cup \{\epsilon\}) \times (\Gamma \cup \{Z_0\}) \rightarrow \mathcal{P}({Q \times \Gamma^*})$ é a função de transição.

A função de transição funciona assumindo um heap inicialmente vazio que consiste apenas em . A função de transição pode adicionar à pilha uma coleção arbitrária (finita, mas possivelmente vazia ou com repetições) de elementos . Como alternativa, a função de transição pode remover uma instância do elemento com o menor peso de todos os elementos restantes na pilha (ou seja, o elemento na parte superior da pilha). A função de transição pode usar apenas a instância do símbolo mais alto (ou seja, de peso mínimo) para determinar qualquer transição.γ 1 , y 2 , . . . , γ k ∈ Γ γ w ( γ $Z_0$$\gamma_1, \gamma_2, ..., \gamma_k \in \Gamma$$\gamma$$w(\gamma)$

Além disso, defina um autômato min-heap determinístico do tipo 1 como um autômato min-heap não-determinístico do tipo 1 que satisfaça a seguinte propriedade: para todas as seqüências de caracteres modo que e , .| x | = n σ ∈ Σ | δ n + 1 ( q 0 , x σ y , Z 0 ) | ≤ $x{\sigma}y \in \Sigma$$|x| = n$$\sigma \in \Sigma$$|\delta^{n+1}(q_0, x{\sigma}y, Z_0)| \leq 1$

Defina também um autômato de pilha mínima não-determinística tipo 2 exatamente o mesmo que um autômato de pilha mínima não-determinística tipo 1, exceto as seguintes alterações:

1. γ ∈ Γ w ( γ ) ∈ N w ( γ 1 ) = w ( γ 2 ) γ 1 = γ $\Gamma$ é um alfabeto de entrada finito e não vazio, em que o peso de um símbolo , , é tal que não implica necessariamente ; em outras palavras, diferentes símbolos de heap podem ter o mesmo peso.$\gamma \in \Gamma$$w(\gamma) \in \mathbb{N}$$w(\gamma_1) = w(\gamma_2)$$\gamma_1 = \gamma_2$
2. Quando instâncias de símbolos de heap distintos com o mesmo peso são adicionadas ao heap, sua ordem relativa é preservada de acordo com uma ordem de pilha do tipo LIFO (último a entrar, primeiro a sair).

Agradecemos a Raphael por apontar essa definição mais natural, que captura (e amplia) as linguagens sem contexto.

Alguns resultados demonstrados até agora:

1. O autômato de pilha mínima do tipo 1 reconhece um conjunto de idiomas que não é um subconjunto nem um superconjunto dos idiomas sem contexto. [ 1 , 2 ]
2. Os autômatos de heap mínimo do tipo 2, por sua definição, reconhecem um conjunto de idiomas que é um superconjunto adequado das linguagens sem contexto, bem como um superconjunto adequado dos idiomas aceitos pelos autômatos de heap min do tipo 1.
3. Os idiomas aceitos pelos autômatos de pilha mínima tipo 1 parecem estar fechados sob a união, concatenação e estrela Kleene, mas não sob complementação [ 1 ], interseção ou diferença;
4. Os idiomas aceitos pelos autômatos de pilha mínima não-determinística do tipo 1 parecem ser um superconjunto adequado de idiomas aceitos pelos autômatos de pilha mínima determinística do tipo 1.

Pode haver alguns outros resultados que eu perdi. Mais resultados estão (possivelmente) a caminho.

Perguntas de acompanhamento

1. Fechamento sob reversão? -- Abrir
2. Encerramento sob complementação? -- Não!
3. O não determinismo aumenta o poder? -- Sim?
4. O do tipo 2? $HAL \subsetneq CSL$-- Abrir
5. A adição de pilhas aumenta a potência do tipo 1? - para (?) k > $HAL^1 \subsetneq HAL^2 = HAL^k$$k > 2$
6. A adição de uma pilha aumenta a potência do tipo 1? -- Abrir

Você pode reconhecer a linguagem canônica não isenta de contexto (mas sensível ao contexto) com esse tipo de máquina de estado. O ponto crucial é que você adicionar fichas para a pilha para cada caráter, e ao analisar os caracteres, você adiciona os tokens 'maiores' para a pilha, para que eles só acabam no fundo do poço quando você ter analisado todos os personagens.a b $\{ a^n b^n c^n\ |\ n \geq 1 \}$$a$$b$$b$

Símbolos heap são e , onde . Nós consumimos todos os símbolos na entrada e adicionar símbolo para a pilha. Se encontrarmos um , alternamos as estratégias: para cada que encontramos subsequentemente, removemos a do heap e adicionamos ao heap. Quando encontramos um , deveríamos ter ficado sem s para remover e, em seguida, para cada na entrada restante, removemos um do heap. Se o heap estiver vazio no final, a sequência estará no idioma. Obviamente, rejeitamos se algo der errado.b a < b a a b b a b c a c $a$$b$$a < b$$a$$a$$b$$b$$a$$b$$c$$a$$c$$b$

Atualizar:

A linguagem não pode ser reconhecido pelos autômatos de min-heap. Suponha que tenhamos um autômato min-heap que possa reconhecer o . Observamos o 'estado' em que o autômato está depois de ler (a primeira parte da entrada, então é o próximo). O único estado que temos são o conteúdo da pilha e o estado particular do autômato que se encontra. Isto significa que depois de reconhecer , este necessidades 'estado' para manter informações suficientes para corresponder .$EPAL = \{ ww^R | w \in \{a, b\}^* \}$$EPAL$$w$$w^R$$w$$w^R$

Em particular, a fim de fazer isso, deve haver possível diferente 'do estado (onde ), uma vez que existem palavras possíveis que consistem de e caracteres. Como há apenas um número finito de estados e apenas um número finito de caracteres de heap, isso implica que existe alguma palavra para a qual o heap contém um número exponencial de algum caractere de heap, digamos .$2^n$$n = |w|$$2^n$$a$$b$$w$$x$

Primeiro, provamos o teorema dos autômatos determinísticos de minheap e, em seguida, estendemos essa prova aos autômatos não determinísticos de minheap. Em particular, autômatos determinísticos que reconhecem alguma linguagem não se colocarão em um loop infinito, que é uma propriedade útil.

Devemos provar que o heap pode conter apenas no máximo um número de tokens de heap lineares no número de caracteres lidos na entrada. Isso exclui imediatamente que aparece um número exponencial de vezes no heap, o que completa a prova de que o não pode ser reconhecido pelos autômatos de min-heap.$x$$EPAL$

Como temos apenas um número finito de estados em nosso autômato e como um autômato determinístico não se coloca em um loop infinito, ao ler um sinal de entrada, ele adicionará no máximo um número constante de caracteres de heap no heap. Da mesma forma, ao consumir algum símbolo de heap , ele só pode adicionar no máximo um número constante de caracteres de heap estritamente maiores que e só pode diminuir o número de símbolos na pilha (caso contrário, obtemos um loop infinito).$y$$y$$y$

Portanto, consumir símbolos de heap pode causar um (enorme) acúmulo de símbolos de heap maiores, mas como há apenas um número constante de tipos diferentes de símbolos de heap, esse é apenas um número constante, não dependente de . Isso implica que o número de símbolos de heap é no máximo algumas vezes (grandes) constantes do número de símbolos de entrada lidos até o momento. Isso completa a prova para o caso determinístico.$n$

No caso não determinístico, a prova é semelhante, mas um pouco mais complicada: em vez de adicionar no máximo algum número constante de tokens de heap ao heap, ele adiciona um número arbitrário de tokens de heap ao heap. No entanto, o ponto crucial é que esse número não depende de . Em particular, se pudermos obter de maneira não determinística exatamente os símbolos de heap corretos após reconhecer (certo para reconhecer ), também poderemos escolher de forma não determinística os símbolos de heap que correspondam a alguma outra palavra e, assim, reconhece , contradizendo assim que o autômato min-heap reconhece exatamente .$n$$w$$w^R$$w'$$w w'^R$$EPAL$

Atualização 3: tornarei o último argumento (sobre não determinismo) rigoroso. Pelo argumento acima, deve existir um conjunto infinito de palavraspara que para cada, após reconhecer, o heap contenha elementos( note que podemos falar sobrepois temos um conjunto infinito de palavras). Como não podemos colocar tantos elementos no heap por meios determinísticos, devemos ter algum tipo de loop no qual escolhemos, de maneira não determinística, adicionar mais elementos ao heap (sem consumir entrada) e depois optamos por sair desse loop, e devemos ter atravessado esse loopvezes.$W \subseteq \{a,b\}^*$$w \in W$$w$$\omega(|w|)$$O(f(|w|))$$\omega(1)$

Tomar o conjunto de todas essas ansas utilizados por . Como existem apenas estados , o tamanho deste conjunto é e o conjunto de todos os seus subconjuntos também é . Agora observe que a parte 'determinística' dos caminhos de execução só pode contribuir para dos tokens, o que significa que muito do número exponencial de palavras diferentes deve ter caminhos de execução cujas partes 'determinísticas' contribuem da mesma forma. tokens para a pilha. Em particular, a única maneira de obter mais tokens é usando os loops identificados acima.$W$$O(1)$$O(1)$$O(1)$$O(|w|)$

Combinando essas observações, isso significa que deve haver duas palavras distintas em , e digamos, cuja parte 'determinística' dos caminhos de execução contribui com os mesmos tokens para o heap, e que são diferenciadas ao fazer parte de um subconjunto dos loops acima um número diferente de vezes, mas que usam o mesmo subconjunto de loops (lembre-se de que existem apenas desses loops).$W$$w_1$$w_2$$O(1)$

Agora podemos mostrar que também pode ser reconhecido pelo autômato min-heap: seguimos o caminho de execução de como acima, mas percorremos os loops o mesmo número de vezes que o caminho de execução de percorre. Isso preenche o min-heap com tokens, de forma que seja aceito como sufixo, completando assim a prova.$w_1 w_2$$w_1$$w_2$$w_2$

Atualização 2:

Apenas me ocorreu que o acima exposto significa que podemos simular um autômato de min-heap determinístico usando apenas espaço logarítmico: mantemos um contador para cada tipo de caractere na min-heap. Como mostrado acima, esse contador será no máximo e, portanto, pode ser armazenado usando apenas espaço (pois há apenas um número constante desses contadores). Isso nos dá:$O(n)$$O(\log n)$

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

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

onde é o conjunto de idiomas reconhecidos por alguns autômatos determinísticos de min-heap.$\mathrm{DHAL}$

Aqui está o que (acreditamos) sabemos:

• $\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, por definição)
• $\mathrm{CSL} \setminus \mathrm{HAL} \neq \emptyset$ (tipo 1, tipo 2)

Veja detalhes e outras notas abaixo.

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

Esta parte da resposta está relacionada ao tipo 1 e ao tipo 2.

Um autômato de pilha mínima (HA) com alfabeto de pilha finito e totalmente ordenado aceita .$L = \{ a^nb^nc^n \mid n \in \mathbb{N} \} \in \mathrm{CSL} \setminus \mathrm{CFL}$

Pressupostos: Semelhante ao PDA, nossa função de transição consome o símbolo mais importante de heap e grava de volta um número arbitrário de símbolos de heap. O heap contém inicialmente um símbolo distinto que é maior que todos os outros símbolos de heap.$\$$

Seja um autômato de com$A = (Q,\Sigma_I, \Sigma_H, \rightarrow, q_0, Q_F)$

• $Q = \{q_0, q_1, q_2, q_f\}$ o conjunto de estados
• $\Sigma_I = \{a,b,c\}$ o alfabeto de entrada.
• $\Sigma_H = {a,b,\$}$ o alfabeto da pilha com a ordem .$a \lt b \lt \$$
• $Q_F = \{q_f\}$
• $\rightarrow\ \subseteq (Q \times \Sigma_I \times \Sigma_H) \times (Q \times \Sigma_H^*)$ com
  • $(q_0,a,\sigma) \rightarrow (q_0, a\sigma)$ para todos$\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)$

O autômato escreve um para a pilha para cada na entrada. Quando um ocorre, ele consome como muitos como tem havido , escrever um para a pilha para cada encontrados . Isso não atrapalha a contagem, porque o heap mantém convenientemente no topo. Só depois de tudo são tomadas a partir da pilha são aceito; somente depois que tantos como (e com isso ) forem encontrados, aceitará com heap vazio e estado final.$a$$a$$b$$b$$a$$b$$b$$a$$a$$c$$c$$b$$a$$A$

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

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

Esta parte da resposta refere-se apenas ao tipo 1.

Considere o mesmo conjunto de palindromes e assumir que existe HA com .$\mathrm{EPAL} = \{ww^R \mid w \in \{a,b\}\}$$A$$\cal{L}(A) = L$

Conjectura: encontramos com ede modo que esteja no mesmo estado e tenha o mesmo conteúdo de heap depois de ler e , respectivamente. Como aceita e , também aceita (e ), que é uma contradição para .$w_1, w_2 \in \{a,b\}^*$$w_1 \neq w_2$$|w_1| = |w_2|$$A$$w_1$$w_2$$A$$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$

Esta parte da resposta está relacionada ao tipo 1 e ao tipo 2.

O mesmo raciocínio usado em (para o tipo 1) pode ser usado para mostrar que a linguagem sensível ao contexto não está em . { w w ∣ w ∈ { a , b } ∗ } H A $\mathrm{EPAL}$$\{ww \mid w \in \{a,b\}^*\}$$\mathrm{HAL}$

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

Isso ainda está aberto para o tipo 1 e o tipo 2.

Factoids adicionais

O HA parece ser ortogonal a um subconjunto das linguagens levemente sensíveis ao contexto aceitas pelo Embedded Pushdown Automata : Embora o HA possa simular um número limitado de pilhas empilhadas, ele não pode simular arbitrariamente muitos (como o EPA). No entanto, o HA pode acessar os principais símbolos das pilhas que atualmente não estão na parte superior (que a EPA não pode).