1. Complexity and Computability Theory I
Lecture #6
Instructor: Rina Zviel-Girshin
Lea Epstein

2. Rina Zviel-Girshin @ASC
Overview
Regular expressions
Examples
Properties of regular languages
Transforming regular expressions into FA
Transforming FA into regular expressions
Rina Zviel-Girshin @ASC

3. Algebraic expressions
Regular languages are often described by means of algebraic expressions called regular expressions.
In arithmetic we use the +, * operations to construct expressions:
(2+3)*5
The value of the arithmetic expression is the number 25.
Rina Zviel-Girshin @ASC

4. Rina Zviel-Girshin @ASC
Regular operations
We can use regular operations to construct expressions describing regular languages:
(0+1)* 0*
where :
+ means OR
* Kleene star
 concatenation
The value of a regular expression is a regular language.
Rina Zviel-Girshin @ASC

5. Formal definition
A set of regular expressions over an alphabet  is defined inductively as follows:
Basis:
, , and  (for all ) are regular expressions.
Induction:
If r and s are regular expressions then the following expressions are also regular:
(r) , r+s, r  s and r*.
Rina Zviel-Girshin @ASC

6. Rina Zviel-Girshin @ASC
Examples over ={a,b}
, a, a+b, b*, (a+b)b, ab*, a*+b*
To avoid using to many parentheses, we assume that the operations have the following priority hierarchy:
* - highest (do it first) 
+ - lowest (do it last)
So:
(b+(a (b*)) = b + ab*
Rina Zviel-Girshin @ASC

7. Rina Zviel-Girshin @ASC
Examples over ={0,1}
L1 = { w | w has a single 1}
r1 = 0*10*
L2 = { w | w has at least one 1}
r2 = (0+1)*1 (0+1)*= *1*
L3 = { w | w contains the string 110}
r3 = (0+1)*110(0+1)* = *110*
Rina Zviel-Girshin @ASC

8. Rina Zviel-Girshin @ASC
Examples over ={0,1}
L4 = { w | |w| mod 2 =0}
r4 = ((0+1) (0+1))* = ()*
L5 = { w | w starts with 1}
r5 = 1(0+1)* = 1*
L6 = { w | w ends with 00}
r6 = (0+1)*00 = *00
Rina Zviel-Girshin @ASC

9. Rina Zviel-Girshin @ASC
Examples over ={0,1}
L7 = { w | w starts with 0 and ends with 10}
r7 = 0(0+1)*10 = 0*10   
L8 = { w | w contains the string 010 or the string 101 }
r8 = (0+1)* 010 (0+1)* + (0+1)* 101 (0+1)*=
(0+1)*( )(0+1)* = *( )*
 L9 = { w | w starts and ends with the same letter }
r9 = 0(0+1)*0 + 1(0+1)* = 0*0 + 1*
Rina Zviel-Girshin @ASC

10. Regular languages and regular expressions
We associate each regular expression r with a regular language L(r) as follows:
L()=,
L()={},
L()={} for each ,
L(r+s)=L(r)L(s),
L(r  s)=L(r)  L(s),
L(r*)=(L(r))*.
Rina Zviel-Girshin @ASC

11. Properties of regular expressions 1
Some useful properties of regular expressions
r+s=s+r
r+=+r
r+r=r
r=r=
rr*=r+
r=r=r
Rina Zviel-Girshin @ASC

12. Properties of regular expressions 2
r(s+t)=rs+rt
r+(s+t)=(r+s)+t
r(st)=(rs)t
r+r*=(r*)*=r*r*=r*
r*+r+=r*
Rina Zviel-Girshin @ASC

13. Equivalence of regular expressions
To prove that two regular expressions r and s are equivalent we have to prove that
L[r]L[s] and L[s]L[r].
To show that two regular expressions are not equivalent we have to find a word that belongs to one expression and does not belong to the other.
Rina Zviel-Girshin @ASC

14. Rina Zviel-Girshin @ASC
Example
Are r and s equivalent?
r=+(0+1)*1
s=(0*1)*
Rina Zviel-Girshin @ASC

15. Rina Zviel-Girshin @ASC
L[s]L[r]
Let wL[s] =(0*1)*.
w= or w=x1x2..xn , n0 such that xiL[0*1], i=0,..n.
If w= then wL[r].
If w=x1x2..xn than we can represent w=w’1=x1x2..xn with zero or more 0.
 But w’= x1x2..xn-10000L[(0+1)*].
 So wL[r].
Rina Zviel-Girshin @ASC

16. Rina Zviel-Girshin @ASC
L[r]L[s]
Let wL[r]=+(0+1)*1.
If w= then wL[s] (by definition of *).
If w then can be represented as w=w’1 where w’L[(0+1)*]. Assume that in w’ contains k instances of the letter 1. That means that w’ can be represented as w’= x11x21.. 1xk+1 where xi0*
 But then w=w’1= (x11)(x21).. 1)(xk+1 1)
 So wL[(0*1)*].
Rina Zviel-Girshin @ASC

17. Rina Zviel-Girshin @ASC
Another example
Are r and s equivalent?
r=(0+1)*1+0*
s=(1+0)(0*1)*
No.
We choose a word w = .
wL[r]=(0+1)*1+0*, because w0*.
But wL[s] =(1+0)(0*1)*, as all words in L[s] have at least one letter.
Rina Zviel-Girshin @ASC

18. Rina Zviel-Girshin @ASC
Equivalence with FA
Regular expressions and finite automata are equivalent in terms of the languages they describe.
Theorem:
A language is regular if”f some regular expression describes it.
This theorem has two directions. We prove each direction separately.
Rina Zviel-Girshin @ASC

19. Rina Zviel-Girshin @ASC
Converting RE into FA
If a language is described by a regular expression, then it is regular.
Proof idea:
Transformation of some regular expression r into a finite automaton N that accepts the same language L(r).
Rina Zviel-Girshin @ASC

20. Rina Zviel-Girshin @ASC
RE to FA Algorithm
Given r we start the algorithm with N having a start state, a single accepting state and an edge labeled r:
Rina Zviel-Girshin @ASC

21. RE to FA Algorithm (cont.)
Now transform this machine into an NFA N by applying the following rules until all the edges are labeled with either a letter  from  or :
1.If an edge is labeled , then delete the edge.
Rina Zviel-Girshin @ASC

22. RE to FA Algorithm (cont.)
2.Transform any diagram of the type
into the diagram
Rina Zviel-Girshin @ASC

23. RE to FA Algorithm (cont.)
3.Transform any diagram of the type
into the diagram
Rina Zviel-Girshin @ASC

24. RE to FA Algorithm (cont.)
4.Transform any diagram of the type
into the diagram
Rina Zviel-Girshin @ASC

25. Rina Zviel-Girshin @ASC
Example
Construct an NFA for the regular expression b*+ ab.
We start by drawing the diagram:
Rina Zviel-Girshin @ASC

26. Rina Zviel-Girshin @ASC
Example (cont.)
Next we apply rule 2 for b*+ab:
Rina Zviel-Girshin @ASC

27. Rina Zviel-Girshin @ASC
Example (cont.)
Next we apply rule 3 for ab:
Rina Zviel-Girshin @ASC

28. Rina Zviel-Girshin @ASC
Example (cont.)
Next we apply
rule 4 for b*:
Rina Zviel-Girshin @ASC

29. Transforming a FA into RE
If a language is regular , then it is described by a regular expression.
Proof idea:
transformation of some finite automaton N into a regular expression r that represents the regular language accepted by the finite automaton L(N).
Rina Zviel-Girshin @ASC

30. Transforming a FA into RE
The algorithm will perform a sequence of transformations into new machines with edges labeled with regular expressions.
It stops when the machine has :
two states:
start
finish
one edge with regular expression on it.
Rina Zviel-Girshin @ASC

31. Rina Zviel-Girshin @ASC
Algorithm FA to RE
Assume we have a DFA or an NFA N=(Q, , , q0, F).
Perform the following steps.
1. Create a new start state s and draw a new edge labeled with  from s to the q0. (s,)= q0 .
Rina Zviel-Girshin @ASC

32. Algorithm FA to RE (cont.)
2. Create a new accepting state f and draw new edges labeled with  from all the original accepting states to f. For each qF (q,)= f .
Rina Zviel-Girshin @ASC

33. Algorithm FA to RE (cont.)
3. For each pair of states i and j that have more than one edge from i to j, replace all the edges from i to j by a single edge labeled with the regular expression formed by the sum of the labels of all edges from i to j.
Rina Zviel-Girshin @ASC

34. Algorithm FA to RE (cont.)
4. Construct a sequence of new machines by eliminating one state at a time until the only two states remaining are s and f.
As each state is eliminated a new machine is constructed in the following way:
Rina Zviel-Girshin @ASC

35. Algorithm FA to RE (cont.)
Eliminating state k
Let old(i,j) denote the label on edge <i,j> of the current machine.
If there is no an edge <i,j> then old(i,j)=. Now for each pair of edges <i,k> and <k,j>, where ik and jk, calculate a new edge labeled new(i,j) as follows:
new(i,j)=old(i,j) + old(i,k)old(k,k)*old(k,j)
Rina Zviel-Girshin @ASC

36. Algorithm FA to RE (cont.)
new(i,j)=old(i,j) + old(i,k)old(k,k)*old(k,j)
Rina Zviel-Girshin @ASC

37. Algorithm FA to RE (cont.)
For all other edges <i,j> where ik and jk,
new(i,j)=old(i,j).
The states of the new machine are those of the current machine with state k eliminated. The edges of the new machine are those edges <i,j> for which new(i,j) has been calculated.
Rina Zviel-Girshin @ASC

38. Algorithm FA to RE (cont.)
Now s and f are two remaining states. Regular expression new(s,f) represents the language of the original automaton.
Rina Zviel-Girshin @ASC

39. Rina Zviel-Girshin @ASC
Example
Transform into regular expression the following DFA
Rina Zviel-Girshin @ASC

40. Rina Zviel-Girshin @ASC
Example
The result of first three steps of the algorithm:
new start state
new final state
unify multiple edges
Rina Zviel-Girshin @ASC

41. Example Eliminate state 2
No paths pass through 2. There are no states that connect through 2. So no need to change anything after deletion of state 2.
new(i,j)=old(i,j) for all i,j.
Rina Zviel-Girshin @ASC

42. Example Eliminate state 0 The only path through it is s  q1.
We delete q0 and edges sq0 and q0q1.
Instead we add an edge that is labeled by regular expression associated with the deleted edges.
new(s,q1)=old(s,q1)+old(s,q0)old(q0,q0)*old(q0,q1)=+*a=a
Rina Zviel-Girshin @ASC

43. Rina Zviel-Girshin @ASC
Example
Eliminate state q1
The only path through it is s  f.
new(s,f)=old(s,f) + old(s,q1)old(q1,q1)*old(q1,f) =+a(a+b)* = a(a+b)*
Rina Zviel-Girshin @ASC

44. Rina Zviel-Girshin @ASC
Any Questions?
Rina Zviel-Girshin @ASC