Levantamento de Implementações Máquinas de Turing em 

Artigos, Livros e na Internet 
Danilo Matias1, Marstela Teixeira Souza Lopes1 ,Reginaldo de Matias1  Vinícius 
Torres
1
Departamento de Sistemas e Computação
Universidade do Estado de Santa Catarina (UDESC) – Joinville/SC ­ Brasil

1. 1. Introdução e Motivação do Estudo

A Máquina de Turing (MT) [Brookshear, 1989, Sipser, 1996, Divério, 1999] é um

modelo computacional sobre o qual são derivados vários conceitos fundamentais da
Ciência
da Computação. Os conceitos evidenciados e demonstrados por essa máquina, são
tais
como: algoritmo, computação, função computável, etc. Adicionalmente, enfatiza
questões clássicas como o problema da parada de programas computacionais [Sipser,
1996],
técnicas de programação em fitas uni-dimensionais, etc.

De maneira que é fundamental o entendimento de máquinas de Turing para o

cientista da computação, Entender o funcionamento delas nem sempre é tarefa fácil,
para auxiliar nessa tarefa desenvolveu-se simuladores de máquinas de Turing,
entretanto onde é possível encontrar bons simuladores ?
Com o intuito de apresentar alguns simuladores de máquinas de Turing
desenvolveu-se esse trabalho.
Procurou-se por simuladores independente de plataforma e com GUI – Grafic
User Interface (Interface gráfica para usuário) para facilitar a utlização do usuário
Certamente com o auxílio desse trabalho se optará pelos simuladores que mais
atendem as necessidades do aprendizado dos alunos, pois foi feito um levantamento
exaustivo sobre simuladores de código fonte livre, os que não funcionam e não tem
código fonte disponível procurou-se nem citar.
Esse estudo é essencial para o melhor aprendizado de máquinas de Turing,
pois cita as melhores ferramentas livres em termos de simulação de máquinas de
Turing.

2. Simulador Jastex

O Simulador Jastex, elaborado por Dweck (2008), é compacto e eficaz, e dispõe

de diversas funcionalidades em uma só aplicação, as quais são:
• Desenhar diagramas de estado;
• Gerar código-fonte em LaTex, a fim de que se possa imprimir a Máquina de
Turing dentro de um documento deste formato;
• Obter a descrição em 7-tupla para a Máquina de Tuuring, exceto para
algumas ambigüidades envolvendo a saída versus alfabeto de fita;
 • Traduzir automaticamente a Máquina em instruções úteis para um outro
simulador, de Suzanne Skinner (será descrito a seguir), o qual pode ser
executado dentro deste programa.

Seguem abaixo alguns screenshots da simulação da linguagem { anbncn | n > 0 }:

1.Desenha a Máquina, pela tecla de desenho Drawing.

Figura 1. 1: Desenho da Máquina

3. Geração do código-fonte em LaTex.

Figura 1. 2: Geração de código LaTex

3.Obtenção da 7-upla, através da tecla “Descrição da Máquina de Turing”

 Figura 1. 3: Obtenção da 7-upla

4. Execução do simulador de Suzanne Skinner dentro do Jastex:

 Figura 1. 4: Execução do simulador de Suzanne Skinner

Como pôde ser visto, o simulador Jastex é uma ferramenta poderosa de

simulação e construção de Máquinas de Turing e outros autômatos, com facilidade,
além de poder gerar código em LaTex, importante processador de textos para o meio
acadêmico.

1.2 Simulador de Hodges implementado em Java Script

Essa aplicação, elaborada por Hodges (2003) na linguagem JavaScript tem um

caráter exclusivamente didático, e o poder de simular apenas três exemplos de
máquina: Divisão unária, divisibilidade e primalidade. Em compensação, pode ser
executado diretamente do browser.
A manipulação é simples: Escolhe-se a máquina desejada, clica-se no botão
“Carregar” (Load). Pode-se escolher a opção Step para a máquina executar um passo
por vez, ou “Executar” (Run), para deixá-la executando até terminar o cálculo. A
execução pode ser executada com o botão “Parar” (Break) . Há a possibilidade de
retomar a execução, posteriormente.

1.2.1 As Máquinas Simuladas

 A primeira máquina ilustra as operações básicas. Ao longo das movimentações
da máquina, adiciona dois grupos de 1s em um grupo único.
A segunda realiza o teste de divisibilidade: A máquina parará com um X
impresso no quadrado vazio, separando os números se e somente se o numero à
esquerda é divisível com o da direita.
Finalmente, a terceira usa o teste da divisibilidade para o teste da primalidade: A
máquina pára com um X no quadrado original se o número da direita é primo. A
figura 2 abaixo mostra um screenshot deste simulador

Figura 2: Simulador de Hodges

1.3 Simulador implementado em C#

Este é um simulador rudimentar, no qual foi usada a tecnologia C#. Possui uma
interface basicamente dividida em duas porções: A primeira é a implementação da
máquina, usando vários estilos de interação, como botões e caixas de texto. A
segunda parte é a representação visual da máquina como um diagrama de transições
(Diagrama o qual consiste de círculos para representar estados e segmentos de linha
direcionados para representar as transições entre os estados. Uma ou mais ações
(saídas) podem ser associadas com cada transição.)

A interface é dividida em duas partes: O mostrador da máquina e o diagrama de

transições. O mostrador inclui a fita a qual é carregada com o problema, usando o
botão “Carregar” (Load). A opção “Velocidade” (Speed) pode ser devagar (Slow),
rápida (Fast) ou computar (Compute). A última opção é executada o mais rápido
possível, sem mostar nenhuma das operações da fita. No meio da interface há uma
lista com alguns exemplos de maquias a serem rodados. Seguem, abaixo, alguns
screenshots deste simulador.

Figura 3.1: Tela Principal

Figura 3.2: Execução da máquina

 Figura 3.3: Geração do Diagrama de Transições

1.4 Simulador de Skinner

Esta aplicação, desenvolvida por Skinner (2008) e implementada em linguagem

Java tem o poder de executar apenas três tipos de máquina, as quais são: Subtração,
detecção de palíndromos e Busy Beavers de vários estados (Segundo Skinner
(2008), são Máquinas de Turing como um certo número de estados que escrevem o
maior número de caracteres não-brancos na fita.). Uma vantagem desse simulador, é
que ele pode ser carregado diretamente do browser.
 A aplicação divide-se em duas grandes partes: A mostrador da máquina e os
controles. O mostrador inclui a fita (com a célula corrente no centro), setas para
rolagem manual e alguns controles usados na execução do programa. As teclas são
“Iniciar” (Start), a qual reinicia a máquina e a executa, “Step”, para executar uma
única transição. A velocidade de execução pode ser devagar, rápida, muito rápida,
ou computar, esta que executa a máquina o mais rápido possível, sem que sejam
mostradas as operações da máquina. Existe uma tela no canto inferior direito, na
qual são detalhadas todas as operações do simulador, e caso a máquina tenha parado,
é mostrada a razão da parada. Há uma outra tela, a qual mostra o diagrama de
transições. Abaixo, segue um screenshot deste simulador.

Figura 4: Simulador de Skinner

1.5. Simulador de Eck

O simulador xTuring Machine, desenvolvido por Eck (2008) é uma applet em
Java a fim de mostrar máquinas de Turing em ação. A máquina com que ele trabalha
possui um máximo de vinte e cinco estados, e eles somente usam os símbolos 0,1,x,y,z e
$. Apesar disso, ela pode realizar alguns cálculos não triviais.
Quanto sua interface, um menu pop-up na parte superior do simulador é usado
para selecionar as máquinas pré-existentes ou que foram criadas pelo usuário.
Selecionando “Novo” (New) o primeiro item no menu, criará uma nova máquina, que
estará vazia. Na parte superior está a máquina, cuja fita é infinita. A fita é dividida em
células, e cada célula contém um símbolo, ou branco. A máquina trata uma célula por
vez e mostra apenas seu estado corrente. Por convenção, o primeiro estado de máquina é
zero. Quando ela atinge o estado de parada, é mostrada na tela a letra “h”. No lado
esquerdo, estão os controles. O primeiro é um menu pop-up o qual controla a
velocidade de execução da applet, assim como aos oustros simuladores acima. Existem
dois botões adicionais, sendo que um limpa e fita e um outro que apaga um item da
tabela de transições, a qual está na seção inferior direita da applet. A coluna “Mover”
(Move) diz qual a direção será tomada pela máquina: “L” para a esquerda e “R” para a
direita. é possível editar as colunas “Escrever” (Write), “Mover” (Move) e “Novo
Estado”. As colunas com rótulos “Leitura” (Reading) e “Escrita” (Write) podem conter
os símbolos $,0,1,x,y e z. Elas podem também conter o caracter “#”, o qual é usado para
representar uma célula em branco. A coluna “Leitura” pode também conter “outro”
(other) , o qual representa o valor padrão o qual significa “nenhum outro símbolo para
qual nenhuma transição explícita é dada. Se ela apresenta o valor “Mesmo” (Same), o
qual diz à máquina para escrever o mesmo caractere lido. Acima da trabela de
transições, está um editor de transições (rule maker), com um botão “Editar transição”
(Make Rule), o qual são usados para adicionar novas transições à tabela. O retângulo
azul entre o editor de transições é uma paleta a qual é usada para gerenciar transições,
mudar o conteúdo da fita e mudar o estado corrente da máquina.
A vantagem desse simulador é estar disponível diretamente do browser , bem
como é possível criar novas máquinas e simula-las. Abaixo, há um screenshot deste
simulador.

1.6 Simulador de Cousineau com peças de LEGO

 Cousineau (2005) idealizou um modelo de Máquina de Turing com peças de
LEGO baseando-se numa construção “binária”, isto é, ela necessitava ser capaz de
empilhar e desempilhar um e somente um elemento da pilha, e isso necessitaria
acontecer por um período indefinido de tempo. Abaixo, segue uma descrição mais
minuciosa de seu modelo:

Parte Física

Os Símbolos

Os símbolos são feitos de cilindros. Usando pratos, ele pode codificar em

binário. Por exemplo, o cilindro da figura 1 abaixo é (1,0,1), ou o número 5. Usou-se
uma detector de luz para identificar cada símbolo.

Figura 1: Cilindro representando o número 5

A Memória

A pilha é uma espécie de torre vazada, na qual os símbolos caem horizontalmente. Ela é,
portanto, uma memória “compacta”, contendo aproximadamente dez bytes por seis
polegadas. Necessita-se assegurar que os símbolos sempre permanecerão horizontais, o
que implica numa fricção homogênea em todo lugar. Abaixo, na figura 2, é mostrada
apenas uma seção, porém muitas podem ser conectadas juntas.

Figura 2: A memória da máquina

O Leitor

O leitor está no fundo da memória. É um mecanismo que expulsa um símbolo

por vez. O símbolo expulso passa na frente de um detector de luz (não mostrado), então
o código de barras pode ser lido. É composto pela parte inferior da pilha de memória
que desempilha o símbolo, e de uma alavanca ativada por dentro e por fora através de
um eixo vermelho. A figura 3 mostra essa parte da máquina e a alavanca.
 Figura 3: Leitor e alavanca

O Empilhador

O empilhador está no topo. Sua função é colocar novos símbolos da pilha.

Funciona usando duas pás azuis. Toda vez que a pá rotaciona 90 graus, um símbolo cai
na memória. A figura 4 abaixo o ilustra

Figura 4: Empilhador

Parte Computacional: Implementação

         A implementação fundamenta­se em três sub­rotinas, sendo que uma é 
selecionar qual símbolo será posto no topo da memória, outra para girar a peça 
que fornece os símbolos um quarto de volta, e a última é para desempilhar o 
símbolo para a memória. A linguagem utilizada para tal é Pro­Bot. 

A sub-rotina Empilhador gira a peça que fornece os símbolos um quarto de volta. Usa
um sensor para ligá-lo e desiligá-lo.

A segunda sub-rotina seleciona qual símbolo será posto no topo da pilha. Usa
duas variáveis globais: Uma indica e localização corrente e a outra indica qual o
símbolo desejado. Compara a posição atual com a posição desejada e move o motor
“Seletor” .

A última sub-rotina remove um símbolo do fundo da pilha de memória, lendo-a

pelo caminho, retornando numa variável “símbolo” o número de barras pretas nele.
 Máquina Pronta

1.7. Simulador Visual Turing 2.0

O Simulador Visual Turing 2.0, desenvolvido por Gajo Csaba (19-06-2005) é
uma aplicação Java que possui a finalidade de mostrar máquinas de Turing. A máquina é
implementada de maneira totalmente gráfica, utilizando-se de grafos.
 Esse simulador é totalmente flexível, pois permite que um cada estado da
máquina possa ser uma outra máquina de Turing como pode-se observar na película de
tela do próprio projeto, observe abaixo:

Obseve que o estado “S” é na verdade uma Máquina de Turing S.

Quanto a interface é relevante destacar alguns itens e não fazer uma descrição
detalhada do software. Existem duas regiões para a construção das máquinas, uma onde
o usuário constrói efetivamene a máquina, desenhando o grafo dela, e outra Onde
existem as ferramentas (grafos) para a construção efetiva da máquina. Nas ferramenas
que mencionei existem os símbolos (Symbols), é importante salientar que é possível
acrescentar símbolos clicando com o botão direito do mouse em Symbols e escolhendo
a opção apropriada. As instruções são unicamente as que aparecem na imagem acima,
que é mover a cabeça para a direita ( [ R ] Right ), para a esquerda ( [ L ] Left ) e fazer
nada ( [ ? ] Do Nothing ). Ainda é possível visualizar que existem outras máquinas
criadas, e pode-se utilizar essas máquinas anteriormente criadas como subrotinas da
máquina que está sendo editada. No exemplo acima existem 10 máquinas que podem
ser utilizadas como subrotinas.
A grande vantagem dessa máquina é o fato de poder utilizar outras máquinas
criadas anteriormente como subrotinas.

A próxima figura mostra uma sub máquina, seus respectivos estados, os símbolos
reconhecidos em execução (Observe que no local onde a cabeça da máquina está,
destacada a fita) :
A próxima figura mostra como o programa aparece após ser executado:
Esse software é um sotware livre, que possui licença licença GNU versão 2 de 1991.
É póssivel Visualizar o código fonte do projeto de forma online no browser acessando o
link:

http://sourceforge.krugle.com/kse/codespaces/Eh68i5

Ou baixe o código fonte em:

http://downloads.sourceforge.net/visualturing/Turing-2.0-
src.zip?modtime=1180543569&big_mirror=0

Para baixar o arquivo compactado apenas com o .jar, “executável” java acesse o link:

http://downloads.sourceforge.net/visualturing/Turing-
2.0.zip?modtime=1180543350&big_mirror=0

Para obter mais informações a respeito do projeto, acesse a página dele no SourceForge
em:

http://sourceforge.net/projects/visualturing/
 É importante salientar ainda que esse projeto não possui documentação oficial,
algo que dificulta muito a sua utilização, isso se deve a o autor acreditar que o software
é intuitivo por si só, entretanto podem ocorrer dificuldades devido a falta de
documentação oficial.
Um detalhe que não pode passar desapercebido é o fato de, como rodar em java,
através de um arquivo. Jar, esse software não necessita de instalação. Os único pré-
requisitos são:
− Ter a Máquina Virtual Java 1.4 (JRE – Java Runtime Envoirement ) ou posterior
instalada no computador.

Abaixo menciono como rodar essa máquina no computador usando o sistema

operal Ubuntu 8.0.4.

Para rodar a aplicação baixe o arquivo. zip em:

http://downloads.sourceforge.net/visualturing/Turing-
2.0.zip?modtime=1180543350&big_mirror=0

Descompacte o arquivo na pasta de sua preferência

Entre na pasta criada pela descompactação, se estiver utilizando o sistema operacional

linux, que é o meu caso, estou utilizando o Ubuntu 8.0.4, abra o terminal de comando
(Shell ou console) e utilize o comando # cd Turing-2.0
No meu caso o comando foi:
# cd /home/danilomatias/Documentos/UDESC/TEC/Java/MT/Turing-2.0

Verifique se o arquivo "Turing.jar" se encontra nessa pasta, no meu caso eu usei o

comando ls para ver o que arquivos estão na pasta
# ls

De o comando para a Máquina Virtual Java (JVM) executar esse programa (.jar) No
windows basta dar um duplo clique, no linux clique com o botão direito do mouse e
selecione com um clique simples a opção Abrir com o "Sun Java runtime", ou ainda
simplesmente digite o comando " java -jar Turing.jar " na shell

# java -jar Turing.jar

Pronto o software deve estar rodado com interface gráfica.

O autor da a entender que ele desenvolveu esse software utilizando a tecnologia

java no sistema operacional Microsoft Windows Xp.

1.8. Visual Automata Simulador

 Semelhante ao Visual Turing esse software foi escrito em java, porém esse mais
simples de usar, o autor usou a interface proporcionada pelo pacote swing do java.
De acordo com o autor esse software só existe graças a um professor que
transmitiu a paixão por autômatos para ele.
Como esse software também rodar a partir de um arquivo .jar ele também não
necessita de instalação no computado.
A grande vantagem desse software além de ser multiplataforma, dispensar a
instalação na máquina, é a interface que foi muito bem elaborada, possui procedimentos
semelhantes ao Visual Turing .

O único pré-requisitos é ter a máquina virtual java instalada no computador.

Abaixo menciono como “rodei” essa máquina aqui no computador usando o
sistema operal Ubuntu 8.0.4

Para rodar a aplicação baixe o arquivo. zip em:

http://www.cs.usfca.edu/~jbovet/vas/download/generic.zip

Descompacte o arquivo na pasta de sua preferência

Entre na pasta criada pela descompactação, se estiver utilizando o sistema operacional

linux, que é o meu caso, estou utilizando o Ubuntu 8.0.4, abra o terminal de comando
(Shell ou console) e utilize o comando # cd generic, vá dando o comando cd e o
comando ls até achar o arquivo .jar
No meu caso os comandos foram:
# cd /home/danilomatias/Documentos/UDESC/TEC/Java/MT/generic

danilomatias@danilomatias-laptop:#~/Documentos/UDESC/TEC/linux/generic# ls

generic __MACOSX

danilomatias@danilomatias-laptop:#~/Documentos/UDESC/TEC/linux/generic# cd
generic

danilomatias@danilomatias-laptop:~/Documentos/UDESC/TEC/linux/generic/generic#
ls

Visual Automata Simulator

danilomatias@danilomatias-
laptop:#~/Documentos/UDESC/TEC/linux/generic/generic# ls -a

. .. .DS_Store Visual Automata Simulator

danilomatias@danilomatias-laptop:~/Documentos/UDESC/TEC/linux/generic/generic#
cd Visual\ Automata\ Simulator
danilomatias@danilomatias-
laptop:~/Documentos/UDESC/TEC/linux/generic/generic/Visual Automata Simulator#
ls

Examples Quick Start Guide.pdf vas.jar

Observe que nessa pasta existe o arquivo .jar

“Executaremos” esse arquivo .jar na máquina virtual java através do comando java -jar
arquivo.jar
danilomatias@danilomatias-
laptop:~/Documentos/UDESC/TEC/linux/generic/generic/Visual Automata Simulator#
java -jar vas.jar

26/06/2008 15:11:23 java.util.prefs.FileSystemPreferences#2 run

INFO: Created user preferences directory.

Machine halted after 1 steps on tape: #[#]

Machine halted after 1 steps on tape: ##[#]

Machine halted after 4 steps on tape: #aaa[#]

O Automata possui as mesmas características do simulador anterior porém o que muda é

a interface que é mais amigável.
 Diferente do software anterior, esse software possui apenas uma região onde o
usuário monta graficamente a máquina de turing deseada, o usuário vai inserindo os
movimentos da cabeça da máquina, no exemplo acima ele começa inserindo o
movimento da cabeça para a direito clicando no botão [→] , se o usuário desejasse que a
cabeça da fita se movimenta-se para a esquerda ele arrastaria o botão [←], para a área
de trabalho dele.
Quando se deseja que a cabeça da máquina escreva na fita se arrasta para a área
de trabalho o botão do lápis.
A ligação dos estados se estabelece após o usuário clicar no botão [ Ω ], que
mais parece o símbolo de fone de ouvido, clicar no estado de origem da transição e
clicar no estado destino da transição partindo do estado de origem.
A característica bastante peculiar desse software é ter que colocar um estado de
aceitação e marcar um estado com o botão direito do mouse para que seja o estado
inicial (initial). O estado inicial é marcado com ( > ).
O estado de aceitação é aquele botão que mais parece o símbolo de certo verde,
já o botão para inserir o estado de rejeição é o [ x ]

É possível utilizar-se de uma outra máquina de Turing como sub rotina

utilizando o botão que mais parece um R quadrado, na próxima figura isso será
exemplificado só que na construção de um enumerador.
Para simular a máquina de Turing basta clicar no botão: ( Run )

*
A figura acima é da construção do enumerador para a linguagem: (a+b) onde,
como já mencionado o botão [ R ] é na verdade uma máquina de Turing definida em
outro lugar.
 O botão da mão segurando o lápis é para gerar uma saída em outro lugar que não
seja a fita, que é o caso do enumerador. A saída na figura está em outra região e indicada
pela palavra OUTPUT.
Na figura seguinte é exemplificada uma MT – Máquina de Turing com sur
rotinas que possuem outras máquinas de Turing.

Na página do projeto há pelo menos dois vídeos que não explicam muito bem
como operar o software, entretanto já é alguma documentação.
Os links dos vídeos são:
http://www.cs.usfca.edu/~jbovet/vas/videos/video_b.wmv
e http://www.cs.usfca.edu/~jbovet/vas/videos/video_c.wmv
Ele possui alguns aspectos interessantes tais como:
− É capaz de Criar AFDs – Autômatos Finitos Determinísticos e AFNs– Autômatos
Finitos Não Determinísticos
− É capaz de corverter AFDs e AFNs
− Fácil utilização devido a interface gráfica
− Pode-se salvar as máquinas em documentos específicos da aplicação
− Pode-se depurar facilmente o modo como a máquina irá operar, já que cada passo
possui cores diferentes

Para mais informações é interessante visitar a página oficial do projeto em:

http://www.cs.usfca.edu/~jbovet/vas.html
Entretanto vale a pena salientar que essa documentação está mais completa que a
página do projeto, a documentação lá é quase que inexistente e toda em língua inglesa.
1.9. Simulador da Universidade de Boa Vista
Particularmente o mais interessante de todos, pois além de funcionar a partir do
browser em uma applet, evitando o aborrecimento de esperar baixar o aplicativo, ele
possui interface gráfica muito intuitiva e com algumas máquinas de turing pré
carregadas. As máquinas de turing que ele possui pré carregadas são: a máquina que
escreve welcome ( Bem vindo em Inglês ) na fita, a máquina que realiza a adição de
números binários, a máquina que realiza a multiplicação de números e a máquina que
reconhece a linguagem a^n b^n.
Outra característica interessante dessa máquina é que aparece a figura do Alan
Turing dizendo frases em inglês.

Esse simulador pode ser facilmente visualizado acessando a página:

http://web.bvu.edu/faculty/schweller/Turing/Turing.html

A figura abaixo é a película de tela dessa página:

Pode-se observar que no espaço onde o usuário entra com a função programa da
máquina de Turing, ele entra com a entrada no seguinte formato; estado de origem,
símbolo lido da fita, estado destino, símbolo a ser escrito na fita se a cabeça se
movimentar para a direita se não > ou se não for escrever nada na fita <, onde > indica
que a cabeça se movimenta para a direita e < se movimenta para a esquerda.
Para carregar a máquina cuja função programa o usuário digitou basta ele clicar
no botão [ Load ]
Caso o usuário não faça a mínima idéia de que MT deva colocar para simular e
visualizar seu comportamento. Esse simulador de MT possui as máquinas pré
carregadas, para carregar uma delas basta carregar uma delas no botão ali do lado
esquerdo do botão [ Load ]
Para visualizar o comportamento da máquina basta clicar no botão [ Auto ] e
visualizar o comportamento. Entretanto se o usuário deseja fazer passo a passo as
transições, basta ele clicar no botão [ Step ] e visualizar o comportamento da cabeça da
fita em cada estado, lembrando que para cada transição ele tem que clicar em [ Step ]
O botão [ FastAuto ] faz o que o botão [ Auto ] faz, mas de maneira bem veloz.
O botão [ Stop ] pára a Máquina
O botão [ Clear ] limpa tudo o que foi feito.
O botão [ Talk ] serve para o Turing dizer algo.
O botão [ Change State] serve para mudar o estado que a cabeça da MT se
encontra, para mudar o usuário necessita inserir o estado que deseja posicionar a cabeça
da MT no lado direito do botão.
O botão [ Update] serve para mudar o estado que a cabeça da MT se encontra,
para mudar o usuário necessita inserir o estado que deseja posicionar a cabeça da MT
no lado direito do botão. A diferença é que o Update realiza a transição do estado que se
deseja, dando a impressão que vai para o estado exatamente posterior ao desejado.

Para escrever na fita, sem ser com a MT, basta clicar na fita e digitar os
caracteres que deseja que a fita contenha.

Nas próximas figuras se mostrará alguns passos na execução de algumas

máquinas pré-carregadas
Nessa máquina acima se escreverá na fita welcome.
Como pode-se observar a máquina é bem documentada, porém é toda em Inglês, algo
que nem todos os cientistas da computação dominam, infelizmente.
1.10. Simulador da Warthman
Esse simulador simula apenas as MT que realizam a soma e a multiplicação. A
animação mostra o fluxo dos eventos no cálculo (a escrita e a leitura dos símbolos em
uma fita infinita) e nas réguas de decisão usadas para processar cada etapa no cálculo.

Esse simulador possui o incoveniente de simualar apenas duas máquinas de

Turing a da soma e da multiplicação, entretanto ele mostra as simulações passo a passo,
é possível inclusive controlar a velocidade das simulações através da barra de rolagem
[ <| | | |> ] : Speed Control

O botão [ Stop ] pára a simulação que pode ser reiniciada do estado que parou
clicando no botão [ Start ]

O botão [ Resset ] reinicia a simulação, deixa no estado de inicialização da

simulação

É possível escolher qual máquina ( a da soma ou da multiplicação) se deseja

simular através do botão [ Multiply ] ou [ Add ], para simular a soma deixe o botão em
[ Add ], já para simular a multiplicação coloque em [ Multiply ], apenas escolha os
valores da operação clicando nos dois botões a direita do botão de escolha da MT.
O botão [Step ] tem funcionamento análogo ao das outras Mts.
Como pôde-se observar a grande vantagem desse simulador reside no fato da execução
passo a passo, com os passo representados pela cor vermelha, para chamar a atenção.
 Esse simulador possui uma interface que realmente chama a atenção do usuário
para o que está acontecendo com a máquina de Turing, a interface dos demais não
chamava a atenção para os detalhes da MT como esse simulado. Outro diferencial que
chama a atenção, e portanto auxilia mais no aprendizado das MT s que os outros
simuladores é o fato da função programa estar em uma caixa rosa, ademais abaixo
também de rosa fica representado os movimentos da cabeça o último movimento lido
(Last Read), o último escrito na fita (Last Write) e o útimo movimento ( Last Move).
Outro aspecto muito positivo reside no fato do funcionamento desse simulador
ter documentação do seu funcionamento, entretanto essa documentação está toda no
idioma Inglês, mas existe e se encontra em:
http://www.warthman.com/turing_app/symbols.html

Algo que prende a atenção do usuário nesse simulador é o fato das cores da
interface gráfica terem sido muito bem pensadas, além de principalmente possui
inteface simples, não tornando muito necessário estudar o funcionamento do simulador.

Certamente essa Applet é uma excelente ferramenta no ensino de MT s.

1.11. MUST: Mais Um Simulador da Máquina de Turing

O seguinte simulador foi escrito em prolog, o que é uma desvantagem enorme

quando comparado aos simuladores acima, pois necessita instalar o insterpretador do
prolog, o usuário precisa aprender a utilizar o interpretador do prolog, apesar de após o
trauma do aprendizado ser facilmente interpretada a máquina de turing, demorou-se me
méia 3 dias para conseguir instalar o prolog e “rodar” os programas no interpretador
através do Consult, entretanto os resultados teóricos obtidos nesse simulador valem a
pena o aprendizado, o simulador do Professor Cláudio Cesar de Sá da Universidade do
Estado de Santa Catarina é realmente muito bom, quando comparado aos demais apesar
da ausência de GUI – Grafic User Interface (Interface Gráfica para Usuário).
A documentação do simulador é quase que inexistente, o que existe são alguns
arquivos em .txt na página:
http://www2.joinville.udesc.br/~coca/cursos/teoria_da_computacao/simulador_mt/

Olhando esses arquivos o usuário tem que adivinhar que os arquivos

arquivo_pl.txt, são na verdade arquivos que devem ser salvos unicamente com a
extensão típica do prolog ( .pl ) ( arquivo.pl), para poderem ser interepretador pelo
interpretador do prolog.
Outro aspecto que se aconselha ao usuário na utilização desse simulador é salvar
todos os arquivos .pl e txt que estão na página citada acima, pois na primeira simulação
ocorreu um erro e um warning devido a falta do arquivo copia_a_b_direita.txt', o
resultado da primeira simulação pode ser visto logo abaixo:
Observe que é necessário dar o comando consult('tm_MUST.pl').
no interpretador de comandos do prolog para que o simulador de MT seja carregado.
?- consult('tm_MUST.pl').

==============================================================
=

Este é um simulador da Máquina de Turing

Há um arquivo de codificação do pgm a ser simulado

Veja um arquivo tipico em: teste_exemplo.txt

já inicializado neste demo....ou digite consult('seu_exemplo.txt').

Há estados especiais como: a: aceitação, r:rejeição

Movimentacao do cabecote: l: left, r:right e n:neutral (não move)

Edite apenas a entrada da sua fita, no predicado iniciar, logo acima

A esquerda de sua string, a fita terá símbolos: @, e a direita: #

Ou seja, ...@@@ sua entrada ###...

Boa sorte .... e

"iniciar." para repetir a simulação

==============================================================
=

ERROR:
/home/danilomatias/Documentos/UDESC/TEC/Prolog/Bigode/tm_MUST.pl:267:

source_sink `copia_a_b_direita.txt' does not exist

Warning:
/home/danilomatias/Documentos/UDESC/TEC/Prolog/Bigode/tm_MUST.pl:267:

Goal (directive) failed: user:iniciar

% tm_MUST.pl compiled 0.01 sec, 12,164 bytes

true.
 As simulações seguintes foram feitas tendo todos os arquivos que estavam na
página mencionada acima no diretório corrente.
Abaixo estão mais algumas simulações da máquina de Turing do Professor
Cláudio, ele fez baseado em outra, mas mudar 90 % do código é praticamente construir
uma nova.

?- iniciar.

==============================================================
=

Este é um simulador da Máquina de Turing

Há um arquivo de codificação do pgm a ser simulado

Veja um arquivo tipico em: teste_exemplo.txt

já inicializado neste demo....ou digite consult('seu_exemplo.txt').

Há estados especiais como: a: aceitação, r:rejeição

Movimentacao do cabecote: l: left, r:right e n:neutral (não move)

Edite apenas a entrada da sua fita, no predicado iniciar, logo acima

A esquerda de sua string, a fita terá símbolos: @, e a direita: #

Ou seja, ...@@@ sua entrada ###...

Boa sorte .... e

"iniciar." para repetir a simulação

==============================================================
=

% copia_a_b_direita.txt compiled 0.01 sec, 0 bytes

Digite a entrada + <Enter>:: consult('teste_exemplo').

Confirmando em ASCII o digitado: [99, 111, 110, 115, 117, 108, 116, 40, 39, 116,
101, 115, 116, 101, 95, 101, 120, 101, 109, 112, 108, 111, 39, 41, 46]

Fita: @consult('teste_exemplo').#
 ^ Agora o estado corrente é: 0

Fita: @consult('teste_exemplo').#

^ Agora o estado corrente é: r

Uma rejeição PROGRAMADA ocorreu ...

A máquina parou, rejeitando a entrada !

(PREVISTO PELO PGMDR)

Final da Fita Conteúdo (R):

@consult('teste_exemplo').#

Deslocamento do Cabecote(R): 3

true .

?- iniciar.

==============================================================
=

Este é um simulador da Máquina de Turing

Há um arquivo de codificação do pgm a ser simulado

Veja um arquivo tipico em: teste_exemplo.txt

já inicializado neste demo....ou digite consult('seu_exemplo.txt').

Há estados especiais como: a: aceitação, r:rejeição

Movimentacao do cabecote: l: left, r:right e n:neutral (não move)

Edite apenas a entrada da sua fita, no predicado iniciar, logo acima

A esquerda de sua string, a fita terá símbolos: @, e a direita: #

Ou seja, ...@@@ sua entrada ###...

Boa sorte .... e

"iniciar." para repetir a simulação

==============================================================
=

% copia_a_b_direita.txt compiled 0.00 sec, 0 bytes

@@@@@@@111111100000000@@@@@@@@##########

Confirmando em ASCII o digitado: [64, 64, 64, 64, 64, 64, 64, 49, 49, 49, 49, 49, 49,
49, 48, 48, 48, 48, 48, 48, 48, 48, 64, 64, 64, 64, 64, 64, 64, 64, 35, 35, 35, 35, 35, 35,
35, 35, 35, 35]

Fita: @@@@@@@@111111100000000@@@@@@@@###########

^ Agora o estado corrente é: 0

Parada com algo desconhecido: entrada rejeitada logo estado r

Leia-se: estado REJEIÇÃO por default... de seu pgm para esta entrada... Então estado
de r de rejeição por default ... !

true

Unknown action: i (h for help)

Action? ;

fail.

?- iniciar.

==============================================================
=
Este é um simulador da Máquina de Turing

Há um arquivo de codificação do pgm a ser simulado

Veja um arquivo tipico em: teste_exemplo.txt

já inicializado neste demo....ou digite consult('seu_exemplo.txt').

Há estados especiais como: a: aceitação, r:rejeição

Movimentacao do cabecote: l: left, r:right e n:neutral (não move)

Edite apenas a entrada da sua fita, no predicado iniciar, logo acima

A esquerda de sua string, a fita terá símbolos: @, e a direita: #

Ou seja, ...@@@ sua entrada ###...

Boa sorte .... e

"iniciar." para repetir a simulação

==============================================================
=

% copia_a_b_direita.txt compiled 0.00 sec, 0 bytes

Digite a entrada + <Enter>::

@@@@@@@@@111111111100000000000111111100000001010101#########0000
100001010101010#########

Confirmando em ASCII o digitado: [64, 64, 64, 64, 64, 64, 64, 64, 64, 49, 49, 49, 49,
49, 49, 49, 49, 49, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 49, 49, 49, 49, 49,
49, 48, 48, 48, 48, 48, 48, 48, 48, 49, 49, 49, 49, 49, 48, 48, 48, 48, 48, 48, 49, 48, 48,
48, 48, 49, 48, 49, 48, 49, 48, 49, 48, 49, 48, 49, 48, 49, 48, 49, 48, 49, 48, 49, 35, 35,
35, 35, 35, 35, 35, 35, 35]

Fita:
@@@@@@@@@@11111111110000000000011111110000000011111000000100001
010101010101010101##########

^ Agora o estado corrente é: 0

Parada com algo desconhecido: entrada rejeitada logo estado r

Leia-se: estado REJEIÇÃO por default... de seu pgm para esta entrada... Então estado
de r de rejeição por default ... !

true

Unknown action: i (h for help)

Action? .

?- iniciar.

==============================================================
=

Este é um simulador da Máquina de Turing

Há um arquivo de codificação do pgm a ser simulado

Veja um arquivo tipico em: teste_exemplo.txt

já inicializado neste demo....ou digite consult('seu_exemplo.txt').

Há estados especiais como: a: aceitação, r:rejeição

Movimentacao do cabecote: l: left, r:right e n:neutral (não move)

Edite apenas a entrada da sua fita, no predicado iniciar, logo acima

A esquerda de sua string, a fita terá símbolos: @, e a direita: #

Ou seja, ...@@@ sua entrada ###...

Boa sorte .... e

"iniciar." para repetir a simulação

==============================================================
=

% copia_a_b_direita.txt compiled 0.00 sec, 0 bytes

Digite a entrada + <Enter>:: @@@11100010101010101111000011000010000000###

Confirmando em ASCII o digitado: [64, 64, 64, 49, 49, 49, 48, 48, 48, 49, 48, 49, 48,
49, 48, 49, 48, 49, 48, 49, 49, 49, 49, 48, 48, 48, 48, 49, 49, 48, 48, 48, 48, 49, 48, 48,
48, 48, 48, 48, 48, 35, 35, 35]

Fita: @@@@11100010101010101111000011000010000000####

^ Agora o estado corrente é: 0

Parada com algo desconhecido: entrada rejeitada logo estado r

Leia-se: estado REJEIÇÃO por default... de seu pgm para esta entrada... Então estado
de r de rejeição por default ... !

true

Olhando os exemplos acima observa-se a grande flexibilidade do simulador, ele

permite que se edie a fita em um arquivo ou simplesmente entre com ela na console.
Esse simualdor é bom pois com ele é possível utilizar:
− Ilustração da técnica de marcadores em Mts;

− Uso de movimentações do cabeçote

− Procedimento intrinsecamente recursivo;
− Procedimento intrinsecamente recursivo;

1.12. Alguns links para Simuladores que não forma

mencionados nesse trabalho
Como existem uma série de simuladores de MT s na internet sendo grande parte
deles multiplataforma e com características que fogem ao escopo desse trabalho, mas a
principal dela explicá-las mencionar-se-á alguns projetos e suas respectivas páginas no
Source Fourge.
Como esses simuladores abaixo são todos software livre é muito relevante
mencionar eles, pois é possível obter o código fonte deles nas respectivas páginas de
seus projetos, além de claro a aquisição deles ser totalmente gratuita
 Outra possibilidade é a construção do próprio simulador baseado no código fonte
de algum desses simuladores.
Abaixo estão mencionados os projetos e suas respectivas páginas:

- Projeto PHPTuring ( Em desenvolvimento )– Um simulador de MT

implementado em php5 Orientado a Objetos, com documentação de classes do código
fonte
http://phpturing.sourceforge.net/

− Projeto Kturing - KTuring is a Turing machine for KDE – É o projeto de uma

interface gráfica de uma máquina de Turing no KDE do Linux
http://kturing.sourceforge.net/

− Projeto Turing and Post Machines: C++ Simulators - É um simulador de MT e

Máquina de Post feito em C++ que funciona na console, ele simula tanto máquinas
determinísticas como não determinísticas, é multiplataforma
http://sourceforge.net/projects/turing-machine/

− Projeto Alan - A Turing Machine in Java – Um simulador documentado, porém em

lingua alemã
http://alan.sourceforge.net/

Um aspecto interessante de mencionar é que a interface no Alan é intuitiva e não

precisa instalar ele para o programa “rodar”.

Conclusões
Analisando os aspectos expostos até aqui observa-se que existem ferramentas
boas para o auxílio do aprendizado de máquinas de Turing.
Existem simuladores para cada necessidade, o do professor Cláudio ( MUST:
Mais Um Simulador da Máquina de Turing
) para aprendender ou treinar formalismos, o Warthman para quem deseja visualizar de
maneira gráfica e no navegador (Browser) da internet, os passos das operações da
máquina de Turing, o Simulador da Universidade de Boa Vista para quem deseja
entender um pouco mais da parte teórica da Máquina de Turing e quer “rodar” a
aplicação do browser, sem perder em nada em termos de interface gráfica, e com
exemplos de MT pré-carregadas no simualdor, o Visual Automata Simulador, para quem
deseja construir a MT de maneira visual e entendendo apenas do grafo da máquina de
Turing, com a vantagem de poder usar outras máquinas de Turing como subrotinas e
sem instalar a aplicação no computador, além de ser multiplataforma, o Simulador de
Cousineau com peças de LEGO para quem deseja montar a máquina fisicamente e ver os
resultador de forma física. Pôde-se observar que há simuladores de MT s para todos os
perfis de usuários, basta o usuário observar que perfil é o mais adequado para ele e ir a
busca para utilizar o simulador. Como buscou-se não escrever muito sobre cada simulador
esse documento pode servir de consulta rápida para a escolha do simulador mais
adequado a determinado perfil de usuário.
Um aspecto que levou-se em conta na escolha dos simuladores foi o fato de
possuir o código disponível para baixar, o que possibilita a implementação de novas
ferramentas baseadas nas já existentes, outro fator que a escolha por máquinas de código
livre possibilita é a explicação através do código fonte por parte do professor do que
acontece em uma máquina de Turing, trabalho esse que agregaria muito valor se aliado ao
ensino de linguagens de programaçao, pois se aplica muito os conceitos de orientação a
objetos, ponteiros a assim sucessivamente.

Referências

Brookshear, G. J. (1989). Theory of Computation: Formal Languages, Automata, and

Complexity. The Benjamin/Cummings Publishing Company, United States.

Divério, T. A.; Menezes, P. F. B. (1999). Teoria da Computação: Máquinas Universais

e Computabilidade. Sagra-Luzzatto, . Porto Alegre - RS. Série Livros Didáticos do

Instituto de Informática da UFRGS, n.5.

Sipser, M. (1996). Introduction to the Theory of Computation. PWS Publishing

Company,

2nd. edition edition. Errata url: http://www-math.mit.edu/ ̃ipser/itoc-errs1.2.html.