DFA

A basic Implementation of a Deterministic Finite State Automaton (DFA)
A DFA is a quintuple ( $Q$ , $\Sigma$ , $\delta$ , $q_0$ , $F$ ):
- $Q$ is a non-empty, finite set of states.
- $\Sigma$ is non-empty, finite set of symbols (an alphabet).
- $\delta : Q \times \Sigma$ → $Q$ is the transition function.
- $q_0 \in Q$ is the start state.
- $F \in Q$ is the set of accept states.
A DFA accepts a string $w = w_1 w_2 ... w_n \in \Sigma^*$ if there is a sequence $r_0, r_1, ..., r_n$ of states such that
- $r_0 = q_0$
- $r_n \in F$
- $\delta$ (r_i,w_i+1) = r_i+1"> for every $0 <= i < n$

We make the following assumptions for simplicity.

The alphabet $\Sigma$ is always the binary alphabet {0,1}
The set of states $Q$ is always of the form The set of states {0, . . . , n}, for some $n \in N$ .
The start state is always state 0.

An object DFA is implemented, where:

DFA is created by calling the function construct_DFA which takes one parameter that is a string description of a DFA and returns a DFA instance.
A string describing a DFA is of the form P#S, where P is a prefix representing the transition function $\delta$ and S is a suffix representing the set $F$ ) of accept state.
P is a semicolon-separated sequence of triples of states: each triple is a comma-separated sequence of states. A triple i, j, k means that $\delta$ (i,0) = j and $\delta$ (i,1) = k
S is a comma-separated sequence of states.
For example, the DFA for which the state diagram appears below may have the following string representation: 0,0,1;1,2,1;2,0,3;3,3,3#1,3

run simulates the operation of the constructed DFA on a given binary string. It returns true if the string is accepted by the DFA and false otherwise.

NFA

An implementation of the classical algorithm for constructing a deterministic finite automaton (DFA) equivalent to a non-deterministic finite automaton (NFA).
A NFA is a quintuple ( $Q$ , $\Sigma$ , $\delta$ , $q_0$ , $F$ ):
- $Q$ is a non-empty, finite set of states.
- $\Sigma$ is non-empty, finite set of symbols (an alphabet).
- $\delta : Q \times {\Sigma \cup \epsilon}$ → $P(Q)$ is the transition function.
- $q_0 \in Q$ is the start state.
- $F \in Q$ is the set of accept states.
Given a description of an NFA, we will construct an equivalent DFA.
Same assumptions followed in DFA will hold in NFA

An object DFA is implemented, where:

DFA is created by calling the function decode_NFA which takes one parameter that is a string description of a NFA and returns a DFA instance.
A string describing an NFA is of the form Z#O#E#F, where Z, O, and E, respectively, represent the 0-transitions, the 1-transitions, and the $\epsilon$ -transitions. F represents the set of accept state.
Z, O, and E are semicolon-separated sequences of pairs of states. Each pair is a comma-separated sequence of two states. A pair i, j represents a transition from state i to state j. For Z this means that $\delta$ (i, 0) = j, similarly for O and E.
F is a comma-separated sequence of states.
For example, the NFA for which the state diagram appears below may have the following string representation: 0,0;1,2;3,3#0,0;0,1;2,3;3,3#1,2#3
run simulates the operation of the constructed DFA on a given binary string. It returns true if the string is accepted by the DFA and false otherwise.

An implementation of a fallback deterministic finite automaton with actions (FDFA) abstract data type.
A FDFA is a sextuple ( $Q$ , $\Sigma$ , $\delta$ , $q_0$ , $F$ , $A$ ):
- $Q$ is a non-empty, finite set of states.
- $\Sigma$ is non-empty, finite set of symbols (an alphabet).
- $\delta : Q \times \Sigma$ → $Q$ is the transition function.
- $q_0 \in Q$ is the start state.
- $F \in Q$ is the set of accept states.
- $A$ is function that maps every state in Q to an action.
Same assumptions followed in DFA will hold in FDFA

An object FDFA is implemented, where:

FDFA is created by calling the function construct_fdfa which takes one parameter that is a string description of a FDFA and returns a FDFA instance.
A string describing an FDFA is of the form P#S, where P is a prefix representing both the transition function $\delta$ and the action function $A$ and S is a suffix representing the set $F$ of accept state.
P is a semicolon-separated sequence of quadruples. Each quadruple is a comma-separated sequence of items: the first three items are states and the fourth is a binary string. A quadruple i, j, k, s means that $\delta$ (i, 0) = j, $\delta$ (i, 1) = k, and $A$ (i) = s.
S is a comma-separated sequence of states.
For example, consider the FDFA for which the state diagram appears below. Suppose that, for state i, A(i) is the two-bit binary representation of i. Thus, such an FDFA may have the following string representation: 0,0,1,00;1,2,1,01;2,0,3,10;3,3,3,11#0,1,2

run simulates the operation of the constructed FDFA on a given binary string. For example, running the above FDFA on the string 1011100 produces the output 1000.

An implementation of the Context Free Grammar (CFG) Left Recursion Elimination Algorithm.
a CFG is a quadruple ( $V$ , $\Sigma$ , $R$ , $S$ ) where:
- $V$ and $\Sigma$ are disjoint alphabets (respectively, containing variables and terminals).
- $R \subset V \times (V \cup \Sigma)^*$ is a set of rules.
- $S \in V$ is the start variable.

We make the following assumptions for simplicity:

A function LRE is implemented, which:

takes an input string encoding a CFG and returns a string encoding an equivalent CFG which is not left-recursive.
A string encoding a CFG is a semi-colon separated sequence of items. Each item represents a largest set of rules with the same left-hand side and is a comma-separated sequence of strings. The first string of each item is a member of $V$ , representing the common left-hand side. The first string of the first item is $S$ .
For example, consider the CFG ({S,T,L}, {i,a,b,c,d}, R, S), where R is given by the following productions:
S → ScT | T
T → aSb | iaLb | i
L → SdL | S
This CFG will have the following string encoding: S,ScT,T;T,aSb,iaLb,i;L,SdL,S
The function LRE will assume the ordering of variables as they appear in the string encoding of the CFG. Thus, in the above example, the variables are ordered thus: S, T, L.
LRE returns a string encoding the resulting CFG where a newly-introduced variable, for the elimination of immediate left-recursion for variable A, is the string A'. Thus, for the above example, the output should be as follows: S,TS';S',cTS',;T,aSb,iaLb,i;L,aSbS'dL,iaLbS'dL,iS'dL,aSbS',iaLbS',iS'