The REND visualization tool is a complementary tool in learning the basic concept of Automata and Language Theory – Regular Language. Any finite automaton can be expressed in any notation and, therefore, can be converted from one form to another. Automation and Simulation with the Conversion System of four different notations (DFA, NFA, ε-NFA, Regular Expression) of Regular Language deals only with the basic concept of Automata - Finite Automata.
Some of the fields are the Finite Automaton and the Regular Expression which both describe a specific regular language. Studying the complexity of automata and language theory must first start at the heart or base: regular language. Another example is the opposite: the conversion of a finite automaton to a regular expression using the state elimination technique that is now widely used.
Regular languages and their various representations such as finite automata and regular expressions are mainly used as lexical analyzers, communication protocols and word search. If the language ω consisting of the set of all words is accepted by a deterministic finite automaton, then the image is said to be codable as a finite automaton.
THEORETICAL FRAMEWORK
Regular Language
- Finite Automaton
- A finite set of states, often denoted by Q
- A finite set of input symbols, often denoted by Σ
- A transition function that takes as argument a state and an input symbol and returns a state or group of states. The transition function will commonly be
- A start state, one of the states in Q
- A set of final or accepting states in F. The set F is a subset of Q
- A transition diagram, which is a graph with states represented by a circle and transition function represented by an arc
- A state in Q, and
- The union of two languages L and M, denoted L Ụ M, is the set of strings that are in either L or M, or both
- The concatenation of Language L and M is the set of strings that can be formed by taking any string in L and concatenating it with any string in M. We denote
- The closure( or star or Kleene closure) of a language L is denoted L * and represents the set of those strings that can be formed by taking any number of
- The constant ε and ø are regular expressions
- If a is any symbol, then a is a regular expression
- A variable, usually capitalized and italic such as L, is a variable, representing any language
- Conversion
A transition table, which is a tabular listing of the δ function, which by implication tells us the set of states and the input alphabet. It therefore takes somewhat the union of the states of the transition given an input a to state q. Another extension of the finite automaton is a new feature that allows a transition on ε, the empty string.
This law, the law of idempotence for union, says that if we take the union of two identical expressions, we can replace them with one copy of the expression. It is easy to verify that the only string produced by concatenating any number of copies of the empty string is the empty string itself. The transformation involves an important "construction" called subset construction because it involves the construction of all subsets of the set of NFA states.
Note that the input alphabets of the two automata are the same and that the start state of D is the set containing only the start state of N. The construction of the subset is very tedious to do, knowing that not all states in the subset are relevant or accessible from the starting state of the automaton.
S Start
Finite automata and regular expressions are known to accept the same language - the regular language. One of the methods used for the conversion is the state extraction technique using one of the expressions (R + SU*T)*SU* denoted by the generic two-state automaton:. P is the arc from state to successor. 3) If the initial state is also the accepting state, we also need to perform an elimination of the state from the original automaton, which gets rid of all states except the initial state.
3)If the start state is also an accepting state, then we must also perform a state elimination from the original automaton that gets rid of every state but the start state
Moreover, the term SU*T is equivalent to θ, since T is one of the terms of the chain of θ. All that remains is to add the two expressions to get the expression for the entire automaton.
- E-LEARNING
- DESIGN AND IMPLEMETATION
Pictorial Representation / Simulation
String of input symbols
Pictorial Representation
28USER
USER
- CREATE AUTOMATON
- TEST IF PART OF
- Input Handler
- Graphics Generator
- Converter
It is first implemented by generating a graphical interface with a radio button for the representation type (DFA, NFA, ε-NFA, Regular Expression, a combo box for the number of states. If the user selects a finite automaton (DFA, NFA, ε-NFA), the a table consisting of combo boxes visible where states and input symbols are the row and column respectively.In the simulation process it checks if the input string contains an invalid symbol or exceeds the maximum allowed length.
After the Input Handler processes the input sequence, a module called the Graphics Generator provides the graphical representation of the automaton, the conversion, and the simulation of the automaton's transition events upon input. Each state has a label for its name and transitions are represented by a direct line; above or below it is the input symbol, depending on the type of display. In the simulation part, the user cannot animate the progression of each state depending on the input string specified by the user, but it checks whether it is a member or not.
Also, a transition table, and log results (both in the side) and a thorough explanation (below) are available for the user to see. The converter handles the conversion of the four possible conversion processes – NFA to DFA, ε-NFA to DFA, DFA to Regular Expression and Regular Expression.
The converter handles the conversion of the four possible conversion processes – NFA to DFA, ε-NFA to DFA, DFA to Regular Expression and Regular Expression
From NFA to DFA
The system will provide new names for the DFA states in the transition diagram and have labels below to avoid conflict.
From ε-NFA to DFA
From DFA to Regular Expression
The conversion is done by elimination method. Following this method, the predecessor of the state to be eliminated connects to the successor of the
From Regular Expression to ε-NFA
The system defined graph handling the possible terms in the regular expression (concatenation, union and Kleene star) for this kind of conversion
RESULTS
The main page of the system (shown in Figure 4) allows you to open the REND Visualization Tool (Figure 5), Reference, Usage and Evaluation. The REND visualization toolbox displays the main functionalities of the system: to create a Finite Automaton to populate the transition table, to convert the created automaton to its equivalent representation, to create a Regular Expression and return it in equivalent NFA. This will serve as a transition table and the user must complete the table.
By clicking the View Diagram button, the result of creating an automaton will be displayed in a panel (as shown in Figure 8). After selecting the desired regular expression of each of the combo boxes, the text field will automatically update by concatenating the combo box entries. The position of the diagram is not static and therefore the user can click the view diagram several times until the desired layout of the graphical representation is filled.
Input String can also be tested to check whether it is a member of the language described by a finite automaton or regular expression (Figure 13). If an input string is part of the language, the system informs the user (Figure 14).
DISCUSSION
The system also includes an interactive reference that can be used by the user to review lessons on plain language. The system has a certain limit on the number of states of finite automata and also on the number of terms in regular expressions to be executed. It can be assumed that the user will no longer perform manual calculation, which is important for developing skills.
- CONCLUSION
- RECOMMENDATION
- BIBLIOGRAPHY
- APPENDIX (Source Code)
- Acknowledgement
