# Difference between revisions of "FSAs and Regular Expressions"

Marc Brown (talk | contribs) (→Basics) |
|||

Line 20: | Line 20: | ||

:2. If the string a is in the input alphabet, then it is a RE. | :2. If the string a is in the input alphabet, then it is a RE. | ||

:3. if a and b are both REs, then so are the strings built up using the following rules: | :3. if a and b are both REs, then so are the strings built up using the following rules: | ||

::a. CONCATENATION. | ::a. CONCATENATION. ''ab'' (a followed by b). | ||

::b. UNION. | ::b. UNION. ''aUb'' or ''a|b'' (a or b). | ||

::c. CLOSURE. | ::c. CLOSURE. ''a*'' (a repeated zero or more times). This is known as the Kleene Star. | ||

Identities for Regular Expressions appear in the next section. The order of precedence for Regular Expression operators is: Kleene Star, concatenation, and then union. | Identities for Regular Expressions appear in the next section. The order of precedence for Regular Expression operators is: Kleene Star, concatenation, and then union. | ||

Similar to standard Algebra, parentheses can be used to group subexpressions. For example, ''(ab)*'' generates the strings λ, ab, abab, ababab, and so on; whereas ''ab*'' generates strings a, ab, abb, abbb, and so on. | |||

If we have a Regular Expression, then we can mechanically build an FSA to accept the strings which are generated by the Regular Expression. Conversely, if we have an FSA, we can mechanically develop a Regular Expression which will describe the strings which can be parsed by the FSA. For a given FSA or Regular Expression, there are many others which are equivalent to it. A “most simplified” Regular Expression or FSA is not always well defined. | If we have a Regular Expression, then we can mechanically build an FSA to accept the strings which are generated by the Regular Expression. Conversely, if we have an FSA, we can mechanically develop a Regular Expression which will describe the strings which can be parsed by the FSA. For a given FSA or Regular Expression, there are many others which are equivalent to it. A “most simplified” Regular Expression or FSA is not always well defined. | ||

Typical problems in the category will include: translate an FSA to a Regular Expression; simplify a Regular Expression; determine which Regular Expressions or FSAs are equivalent; and determine which strings are accepted by either an FSA or a Regular Expression. | Typical problems in the category will include: translate an FSA to a Regular Expression; simplify a Regular Expression; determine which Regular Expressions or FSAs are equivalent; and determine which strings are accepted by either an FSA or a Regular Expression. |

## Revision as of 16:43, 3 October 2018

A Finite State Automaton (FSA) is a mathematical model of computation comprising: a finite number of *states*, of which exactly one is *active* at any given time; *transition rules* to change
the active state; an *initial state*; and one or more *final states*. We can draw an FSA by representing each state as a circle; the final state as a double circle; the start state as the only state with an incoming arrow; and the transition rules as labeled-edges connecting the states. When labels are assigned to states, they appear inside the circle representing the state.

In this category, FSAs will be limited to parsing strings. That is, determining if a string is valid or not.

# Basics

Here is a drawing of an FSA that is used to parse strings consisting of x's and y's:

In the above FSA, there are three states: A, B, and C. The initial state is A; the final state is C. The only way to go from state A to B is by *seeing* the letter x. Once in state B, there are two transition rules: Seeing the letter y will cause the FSA to make C the active state, and seeing an x will keep B as the active state. State C is a final state so if the string being parsed is completed and the FSA is in State C, the input string is said to be *accepted* by the FSA. In State C, seeing any additional letter y will keep the machine in state C. The FSA above will accept strings composed of one or more x’s followed by one or more y’s (e.g., xy, xxy, xxxyy, xyyy, xxyyyy).

A Regular Expression (RE) is an algebraic representation of an FSA. For example, the regular expression corresponding to the first FSA given above is xx*yy*.

The rules for forming a Regular Expression (RE) are as follows:

- 1. The null string (λ) is a RE.
- 2. If the string a is in the input alphabet, then it is a RE.
- 3. if a and b are both REs, then so are the strings built up using the following rules:
- a. CONCATENATION.
*ab*(a followed by b). - b. UNION.
*aUb*or*a|b*(a or b). - c. CLOSURE.
*a**(a repeated zero or more times). This is known as the Kleene Star.

- a. CONCATENATION.

Identities for Regular Expressions appear in the next section. The order of precedence for Regular Expression operators is: Kleene Star, concatenation, and then union.

Similar to standard Algebra, parentheses can be used to group subexpressions. For example, *(ab)** generates the strings λ, ab, abab, ababab, and so on; whereas *ab** generates strings a, ab, abb, abbb, and so on.

If we have a Regular Expression, then we can mechanically build an FSA to accept the strings which are generated by the Regular Expression. Conversely, if we have an FSA, we can mechanically develop a Regular Expression which will describe the strings which can be parsed by the FSA. For a given FSA or Regular Expression, there are many others which are equivalent to it. A “most simplified” Regular Expression or FSA is not always well defined.

Typical problems in the category will include: translate an FSA to a Regular Expression; simplify a Regular Expression; determine which Regular Expressions or FSAs are equivalent; and determine which strings are accepted by either an FSA or a Regular Expression.

# Regular Expression Identities

1. (a*)* = a* |

2. aa* = a*a |

3. aa* U λ = a* |

4. a(b U c) = ab U ac |

5. a(ba)* = (ab)*a |

6. (a U b)* = (a* U b*)* |

7. (a U b)* = (a*b*)* |

8. (a U b)* = a*(ba*)* |

# Sample Problems

## Problem 1

Find a simplified Regular Expression for the following FSA:

**Solution:**

The expression 01*01 is read directly from the FSA. It is in its most simplified form.

## Problem 2

Which of the following strings are accepted by the following Regular Expression "00*1*1U11*0*0" ?

- A. 0000001111111
- B. 1010101010
- C. 1111111
- D. 0110
- E. 10

**Solution:**

This Regular Expression parses strings described by the union of 00*1*1 and 11*0*0. The RE 00*1*1 are strings starting with one or more 0s followed by one or more 1s: 01, 001, 0001111, and so on. The RE 11*0*0 are strings with one or more 1s followed by one or more 0s: 10, 1110, 1111100, and so on. In other words, strings of the form: 0s followed by some 1s; or 1s followed by some 0s. Choice A and E following this pattern.

## Problem 3

Which, if any, of the following Regular Expressions are equivalent?

- A. (a U b)(ab*)(b* U a)
- B. (aab* U bab*)a
- C. aab* U bab* U aaba U bab*a
- D. aab* U bab* U aab*a U bab*a
- E. a* U b*

**Solution:**

Choice B can be discarded because it is the only RE whose strings **must** end with an a. Choice E can be discarded since it is the only RE that can accept a null string. Choices C and D are not equal. After expanding choice A, we must compare it to choices C and D. It is equal to choice D, but not to choice C. The only REs that are equivalent are choices A and D.

# Video Resources

Nice two-part video showing the relationship between FSAs and REs.

1 - Convert Regular Expression to Finite-State Automaton (Barry Brown)
| |

2 - Convert Regular Expression to Finite-State Automaton (Barry Brown)
This video uses the symbol "+" to mean "1 or more matches of the previous term". For example, "ab+" is the same as "abb*". In terms of the Kleene Star, zz* = z*z = z+. |