Lecture 5 Sept 06, 2012 Regular expressions – examples Converting DFA to regular expression. (same...

Lecture 5 Sept 06, 2012

• Regular expressions – examples

• Converting DFA to regular expression. (same works for NFA to r.e. conversion.)

• Converting R.E. to NFA

RE’s: Introduction

Regular expressions are an algebraic way to describe languages.

They describe exactly the regular languages.

If E is a regular expression, then L(E) is the language it defines.

We’ll describe RE’s and their languages recursively.

RE’s: Definition

Basis 1: If a is any symbol, then a is a RE, and L(a) = {a}.Note: {a} is the language containing

one string, and that string is of length 1.

Basis 2: ε is a RE, and L(ε) = {ε}.Basis 3: is a RE, and L() = { }.

RE’s: Definition – (2)

Induction 1: If E1 and E2 are regular expressions, then E1+E2 is a regular expression, and L(E1+E2) = L(E1)L(E2).

Induction 2: If E1 and E2 are regular expressions, then E1E2 is a regular expression, and L(E1E2) = L(E1)L(E2).Concatenation : the set of strings wx such that w

Is in L(E1) and x is in L(E2).

RE’s: Definition – (3)

Induction 3: If E is a RE, then E* is a RE, and L(E*) = (L(E))*.

Closure, or “Kleene closure” = set of stringsw1w2…wn, for some n > 0, where each wi isin L(E).Note: when n=0, the string is ε.

Precedence of Operators

Parentheses may be used wherever needed to influence the grouping of operators.

Order of precedence is * (highest), then concatenation, then + (lowest).

Examples: RE’s

L(01) = {01}.L(01+0) = {01, 0}.L(0(1+0)) = {01, 00}.

Note order of precedence of operators.L(0*) = {ε, 0, 00, 000,… }.L((0+10)*(ε+1)) = all strings of 0’s

and 1’s without two consecutive 1’s.

Theorem: A language is regular if and only if it is accepted by a regular expression.

Proof: Show how to convert from regular expression to NFA and vice-versa.

Let L be accepted by a regular expression. We prove that it is regular, i.e., there is a NFA for L.

Cases to consider: (1) empty-set (2) single symbol {a} (3) {}(4) (a) R1 + R2 (b) R1 . R2 (c) R1*

(1), (2) and (3) are easy base cases. For (4), inductively construct NFA’s for R1 and R2, and from it construct an NFA for R.

Induction step is shown in the next theorem.

Theorem: The set of Regular languages is closed under the three operations concatenation, union and Kleene star.

Proof: (by construction)Union: Given DFA’s M1 and M2 for L1 and L2, we design a NFA for L1 U L2.

s1

s2

s

M1

M2

Concatenation:

Concatenation – Formal Proof

Closure under Kleene star – informal proof

DFA for a language L is shown on the left. The NFA for L* can be constructed as shown on the right.

Converse is shown as follows:

Given a DFA (or NFA), we remove states one by one until we have one state left. At this point, we can write down the regular expression.

The idea is to use generalized NFA, one in which the transitions are labeled not by a single symbol, but by a regular expression.

Example of GNFA:

Conversion from DFA to regular expression

Key step: how to remove a state of a GNFA

So far, we have seen how to design DFA, NFA or regular expressions for various languages.

We also learned how to convert:• e-NFA NFA• NFA -> DFA• DFA regular expression• Regular expression NFA