Implementao de Autmatos Finitos

Paulo Renato Kinjo1 Curso de Cincia da Computao - Pontifcia Universidade Catlica do Rio Grande do Sul (PUCRS) Av. Ipiranga, 6681 - Partenon - Porto Alegre/RS - CEP: 90619-900
(paulo.kinjo)@acad.pucrs.br

Resumo. Este artigo descreve um conjunto de classes, desenvolvidas em Java para a construo de Autmatos Finitos (AF). As classes apresentadas neste texto representam autmatos finitos determinsticos e exemplos de utilizao destas classes sero apresentados de forma sucinta ao longo da breve descrio e ou implementao dos mesmos. Este trabalho faz parte da disciplina 4642C-04 Linguagens Formais[4]. Palavras-chaves: Java; Conjunto de Classes; Autmatos Finitos Determinsticos; Linguagens Formais.

Implementation of Finite Automata

Abstract. This article describes a set of classes, developed in Java for building Finite Automata (FA). The classes presented in this text represent deterministic finite automata and examples of use of these classes will be presented succinctly throughout of this brief description or implementation thereof. This work is part of the discipline 4642C-04 Formal Languages[4]. Keywords: Java; Set Classes; Deterministic Finite Automata; Formal Languages.

1 Introduo
Um autmato Finito Determinstico (DFA) ou simplesmente Autmato Finito (AF) pode ser visto como uma mquina composta, basicamente, de trs partes:[1] a) Fita. Dispositivo de entrada que contm a informao a ser processada; b) Unidade de Controle. Reflete o estado corrente da mquina c) Programa ou Funo de Transio. Funo que comanda as leituras e define o estado da mquina. Segundo (HOPCROFT, John E. Seattle, 7 de outubro de 1939), as definies mais importantes dos termos que permeiam a teoria de autmatos, so os conceitos que incluem o alfabeto ( um conjunto de smbolos), strings (uma lista de smbolos de um alfabeto) e linguagem (um conjunto de strings de um mesmo alfabeto)[2]. Portanto autmatos so mquinas utilizadas para tratar diversos problemas computacionais. Neste artigo, sero apresentados atravs de trs classes: Estado, Transio e Autmato, a soluo para implementao das expresses regulares: . . . . . . . .......................

c) (0 + 1)* 1 (0 + 1) (0 + 1) b) Conjunto de todos as strings com nmero par de 0's e mpar de 1's .[4] Estas classes foram implementadas em Java, com o intuito de explorar os recursos da orientao a objetos, usando deste paradigma para a construo de um simulador de Autmatos.

2 Classes
O uso do paradigma da orientao a objetos tornou mais fcil a construo e a manipulao das unidades necessrias para a implementao dos DFAs. As trs classes modeladas, encapsulam os conceitos e escondem os detalhes de implementao, o que facilita a utilizao da estrutura. 2.1 Classe Estado A classe Estado (State figura 2.1.1) a modelagem da classe que ser utilizada por todos os estados do DFA. A cada novo estado adicionado ao DFA, corresponder um novo objeto da classe Estado que ser armazenado na representao do DFA. O novo objeto possuir: um identificador (id:int); o nome (name:String) do estado formado da juno da string q com o identificador; e o rtulo (label) que pode ser um comentrio referente ao estado.

Figura 2.1.1: Definio da classe Estado (State) com seus atributos e mtodos.

A seguir mostrada a classe da figura 2.1.0 implementada em Java (Importante observar que no ser apresentado neste artigo a implementao do comportamento dos mtodos)
public class State { private int id; private String name; private String label; public State(int id){} public int getId() {} public void setId(int id) {} public String getName() {} public void setName(String name) {} public String getLabel() {} public void setLabel(String label) {} }

2.2 Classe Transio A classe Transio (Transition) a modelagem da classe que ser utilizada por todas as transies do DFA. A cada nova transio adicionada pelo usurio, corresponder um novo objeto da classe transio. O novo objeto possuir estado de origem, estado de destino (destiny) e smbolo (symbol).

Figura 2.2.1: Definio da classe Transio (Transition) com seus atributos e mtodos.

A seguir mostrada a classe da figura 2.2.1 implementada em Java.

public class Transition { private State origin; private State destiny; private String symbol; public Transition(State origin, State destiny, String symbol) {} public State getOrigin() {} public void setOrigin(State origin) {} public State getDestiny() {} public void setDestiny(State destiny) {} public String getSymbol() {} public void setSymbol(String symbol) {} public boolean equals(Object object) {} }

2.3 Classe Autmato A classe Autmato (Automata) permite ao usurio criar e manipular Autmatos Finitos determinsticos utilizando as classes Estado (State) e Transio (Transition). Aps a criao de um objeto da classe Autmato, o usurio poder realizar todas as operaes necessrias para a manipulao de Autmatos.

Figura 2.3.1: Definio da classe Autmato (Automata) com seus atributos e mtodos.

A seguir mostrada a classe da figura 2.3.1 implementada em Java.

public class Automata { private HashMap<Integer, State> states; private HashMap<Integer, State> finalState; private HashSet<Transition> transitions; private State startState; private static int startStateLimit = 0; public Automata() {} public void setState(int id) {} public void setFinalstate(int id) {} public void setStartState(int id) {} public void setTransition(int origin, int destiny, String symbol) {} public Transition getTransition(int origin, String symbol) {} public State getStartState() {} public State getFinalState(int id){} public int getFinalStateSize() {} public State getState(int id){} public boolean isStartState(int id){} public boolean isFinalState(int id) {} private void message(String msg) {} }

3 Expresses Regulares
As expresses regulares oferecem algo que os autmatos no oferecem: um modo declarativo de expressar os strings que queremos aceitar. Dessa maneira, as expresses regulares servem como a linguagem de entrada para muitos sistemas que processam strings. Essas expresses, so outro tipo de notao para a definio de linguagens. Assumindo que o leitor j est familiarizado com o estudo de autmatos no sero apresentados mais detalhes sobre os assuntos abordados neste texto em relao ao que diz

respeito a definio e funcionamento de autmatos finitos determinsticos (DFA), autmatos finitos no determinsticos (NFAs), autmatos finitos no determinstico com transies (NFA- ) e expresses regulares (ER). 3.1 De Expresso Regular para Autmato Finito No Determinstico (NFA) Dada expresso regular c) (0 + 1)* 1 (0 + 1) (0 + 1)[4] transformar esta, em um NFA, utilizando dos recursos da ferramenta JFlap (www.jflap.org)[3], obtemos o NFA da figura 3.1.1:

Figura 3.1.1: Converso da Expresso Regular (0 + 1)* 1 (0 + 1) (0 + 1) em um NFA- .

Como o objetivo deste artigo implementar um DFA utilizando a linguagem Java devemos converter o NFA gerado na figura 3.1.1 em um DFA, tal converso mostrada abaixo:

Figura 3.1.2 DFA gerado apartir do NFA da figura 3.1.1

Com o resultado obtido at o momento poderamos partir para a fase de modelagem do projeto. Porm a seguinte tcnica pode ajudar a minimizar e a melhorar a clareza do nosso projeto. 3.2 Minimizao de Autmatos Pr-requisitos para um DFA ser minimizado: a) Ser determinstico b) No pode ter estados inacessveis c) deve ser total (cada estado deve possuir transies para todos os elementos do alfabeto de entrada). Deve ser um DFA no senso estrito.[2] Caso o DFA no possua algum dos requisitos acima necessrio gerar um DFA equivalente. O resultado de minimizao mostrado na figura 3.2.3:

Figura 3.2.3: Autmato minimizado gerado de acordo com as definies de minimizao de autmatos.

De forma anloga, utilizamos o processo de converso mostrado acima para obter o autmato da figura 3.2.4 referente a expresso regular: b) Conjunto de todos as strings com nmero par de 0's e mpar de 1's[4]

Figura 3.2.4: Autmato minimizado gerado de acordo com as definies de minimizao de autmatos.

Aps obtermos um Autmato minimizado vamos utiliza-lo para realizarmos a modelagem do nosso projeto.

4 Um exemplo de utilizao
Dentre as muitas funes que o sistema oferece, foi implementada a soluo para o DFA Minimizado da figura 3.2.3 O objetivo determinar se o DFA reconhece a expresso regular: (0 + 1)* 1 (0 + 1) (0 + 1)[4]. Utilizando os recursos das classes que modelamos, podemos implementar um exemplo de autmato reconhecedor da expresso regular acima, a palavra a ser lida pelo nosso autmato de exemplo a seguinte: 11101100100. Comeamos definindo a varivel newAutomata que uma instncia da classe Autmato (Automata figura 2.3.1), em seguida declaramos a varivel que ir armazenar a string a ser reconhecida pelo autmato e fazemos uma verificao que finaliza o programa caso a string fornecida seja vazia pois o nosso autmato no reconhece strings vazias. Feitas a verificaes de consistncia inicial, so declaradas variveis que iro manipular as nossas classes Estado(State figura 2.1.1) e Transio(Transition figura 2.2.1), feito isto precisamos definir os estados do autmato, qual o estado inicial e qual o conjunto de estados finais, bem como as suas respectivas transies. Por fim utilizando um lao enquanto (while), iteramos pela string fornecida, efetuando chamadas ao mtodo da classe Transition que retorna qual o estado do autmato aps ler um simbolo. Um exemplo da implementao deste exemplo mostrado em seguida. /** * Exemplo de utilizao das classes Estado(State), Transio(Transition) e Autmato (Automata) * DFA reconhecedor da expresso regular (0 + 1)* 1 (0 + 1) (0 + 1) * lendo a palavra: "11101100100" * @author Paulo Renato Kinjo * */ public class ExemploC { public static void main(String[] args) { // inicializa um novo autmato Automata newAutomata = new Automata(); // faz a leitura da palavra a ser reconhecida String symbol = 11101100100; // finaliza a aplicao caso no haja entra de simbolos

if (symbol.isEmpty()) { System.out.println("Este autmato no aceita transies vazias!"); System.exit(0); } Transition transition; State destiny; // Definio dos estados do autmato newAutomata.setState(0); newAutomata.setState(1); newAutomata.setState(2); newAutomata.setState(3); newAutomata.setState(4); newAutomata.setState(5); newAutomata.setState(6); newAutomata.setState(7); // Definindo qual estado Inicial e quais so estados Finais newAutomata.setStartState(0); newAutomata.setFinalstate(2); newAutomata.setFinalstate(4); newAutomata.setFinalstate(6); newAutomata.setFinalstate(7); int finalStates[] = {2,4,6,7}; // Definindo todas as transies do autmato // (origem, destino, simbolo) newAutomata.setTransition(0, 0, "0"); newAutomata.setTransition(0, 1, "1"); newAutomata.setTransition(1, 3, "0"); newAutomata.setTransition(1, 5, "1"); newAutomata.setTransition(2, 0, "0"); newAutomata.setTransition(2, 1, "1"); newAutomata.setTransition(3, 2, "0"); newAutomata.setTransition(3, 4, "1"); newAutomata.setTransition(4, 3, "0"); newAutomata.setTransition(4, 5, "1"); newAutomata.setTransition(5, 6, "0");

newAutomata.setTransition(5, 7, "1"); newAutomata.setTransition(6, 2, "0"); newAutomata.setTransition(6, 4, "1"); newAutomata.setTransition(7, 6, "0"); newAutomata.setTransition(7, 7, "1"); // uma mensagem de apresentao da aplicao headerMessage(symbol, newAutomata, finalStates); int i = 0; int origin = 0; while (i < symbol.length()) { if (!(symbol.charAt(i) == ' ')) { transition = newAutomata.getTransition(origin, "" + symbol.charAt(i)); destiny = transition.getDestiny(); origin = destiny.getId(); System.out.println("Leu o smbolo \"" + symbol.charAt(i) + "\" foi para o \"" + newAutomata.getState(origin).getName() + "\" - " + newAutomata.getState(origin).getLabel()); i++; } else { System.out.println("Este autmato no aceita transies vazias!!!"); System.exit(0); } } // end while // Exibe o estado em que o autmato se encontra ao final da leitura da palavra. finalStateOfAutomata(symbol, newAutomata, origin); } // end main // Mensagem de apresentao da aplicao public static void headerMessage(String symbol, Automata myAutomata, int finalStates[]) { System.out.println("\nDFA reconhecedor da expresso regular (0+1)*1(0+1)(0+1) ");

System.out.println("Verifica a entrada \"" + symbol + "\"\n"); System.out.println("Definio dos Estados:\n\t" + myAutomata.getStartState().getName() + " - " + myAutomata.getStartState().getLabel()); for (int j = 0; j < myAutomata.getFinalStateSize(); j++) { System.out.println("\n\t" + myAutomata.getFinalState(finalStates[j]).getName() +"-"+ myAutomata.getFinalState(finalStates[j]).getLabel() + "\n"); } // for } // Exibe a estado final do autmato e indica o reconhecimento ou no da palavra fornecida. public static void finalStateOfAutomata(String symbol, Automata myAutomata, int origin) { if (myAutomata.isFinalState(origin)) { System.out.println("\nA entrada \"" + symbol + "\" foi aceita !!!\n"); } else { System.out.println("\nA entrada \"" + symbol + "\" foi rejeitada !!!\n"); } } } // class Ao final o sistema ira mostrar a frase: A entrada 11101100100 foi aceita!!! para a palavra utilizada neste exemplo.
DFA reconhecedor da expresso regular (0+1)*1(0+1)(0+1) Verifica a entrada "11101100100" Definio dos Estados: Estado Inicial - q0 Estado Final - q2 Estado Final - q4 Estado Final - q6 Estado Final - q7 Leu Leu Leu Leu Leu Leu Leu Leu o o o o o o o o smbolo smbolo smbolo smbolo smbolo smbolo smbolo smbolo "1" "1" "1" "0" "1" "1" "0" "0" foi foi foi foi foi foi foi foi para para para para para para para para o o o o o o o o "Estado "Estado "Estado "Estado "Estado "Estado "Estado "Estado Simples" Simples" Final" Final" Final" Simples" Final" Final" q1 q5 q7 q6 q4 q5 q6 q2

Leu o smbolo "1" foi para o "Estado Simples" - q1 Leu o smbolo "0" foi para o "Estado Simples" - q3 Leu o smbolo "0" foi para o "Estado Final" - q2 A entrada "11101100100" foi aceita !!!

Observe que apenas modificando as definies de estados e transies do autmato implementado no exemplo acima, podemos definir o autmato da figura 3.2.4 que lndo a mesma mensagem (11101100100) declarada no exemplo anterior, aprensentaria a mensagem:
A entrada "11101100100" foi rejeitada !!!

5 Concluso
Na prtica, aplicaes de DFAs podem ser tediosas, principalmente quando os DFAs so muitos grandes. As 3 classes implementadas auxiliam desenvolvedores de aplicaes que utilizam DFAs, pois tornam mais simples sua manipulao. A classe Autmato (Automata) por possuir mtodos que manipulam os estados e as transies do autmato claramente apresenta uma maior complexidade no seu desenvolvimento. Tendo como objetivo a implementao de um DFA no houve motivos para se preocupar com o desenvolvimento de mtodos (comportamentos) mais robustos que possam implementar autmatos finitos no determinsticos (NFAs), mas podemos observar que para que possamos aplicar esta melhora em nosso projeto teramos que realizar pequenas mudanas em uma ou outra classe, mantendo a estrutura do projeto sem grandes mudanas.

6 Referncias
[1] MENEZES, Paulo B. Linguagens Formais e Autmatos. 4 ed. Porto Alegre: SagraLuzzatto, 2001. 165p. [2] HOPCROFT, John E.; MOTWANI, Rajeev; ULLMAN, Jeffrey D. Introduo teoria de autmatos, linguagens e computao. Rio de Janeiro: Elsevier, 2003. 560 p. [3] http://www.jflap.org [4] 4642C-04 Linguagens Formais Turma 128 2012/2 Prof. Flavio Oliveira. Notas de Aulas e Trabalho(T1)