Complexity and computability theory i
This presentation is the property of its rightful owner.
Sponsored Links
1 / 44

Complexity and Computability Theory I PowerPoint PPT Presentation


  • 56 Views
  • Uploaded on
  • Presentation posted in: General

Complexity and Computability Theory I. Lecture #6 Instructor: Rina Zviel-Girshin Lea Epstein. Overview. Regular expressions Examples Properties of regular languages Transforming regular expressions into FA Transforming FA into regular expressions Examples. Algebraic expressions.

Download Presentation

Complexity and Computability Theory I

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Complexity and computability theory i

Complexity and Computability Theory I

Lecture #6

Instructor: Rina Zviel-Girshin

Lea Epstein


Overview

Overview

  • Regular expressions

  • Examples

  • Properties of regular languages

  • Transforming regular expressions into FA

  • Transforming FA into regular expressions

  • Examples

Rina Zviel-Girshin @ASC


Algebraic expressions

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


Regular operations

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


Formal definition

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


Examples over a b

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


Examples over 0 1

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


Examples over 0 11

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


Examples over 0 12

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)*(010+101)(0+1)* = *(010+101)*

 L9 = { w | w starts and ends with the same letter }

r9 = 0(0+1)*0 + 1(0+1)*1 + 0 +1 = 0*0 + 1*1 + 0 +1

Rina Zviel-Girshin @ASC


Regular languages and regular expressions

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


Properties of regular expressions 1

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


Properties of regular expressions 2

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


Equivalence of regular expressions

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


Example

Example

Are r and s equivalent?

r=+(0+1)*1

s=(0*1)*

Rina Zviel-Girshin @ASC


L s l r

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-100001 with zero or more 0.

     But w’= x1x2..xn-10000L[(0+1)*].

     So wL[r].

Rina Zviel-Girshin @ASC


L r l s

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


Another example

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


Equivalence with fa

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


Converting re into fa

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


Re to fa algorithm

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


Re to fa algorithm cont

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


Re to fa algorithm cont1

RE to FA Algorithm (cont.)

2.Transform any diagram of the type

into the diagram

Rina Zviel-Girshin @ASC


Re to fa algorithm cont2

RE to FA Algorithm (cont.)

3.Transform any diagram of the type

into the diagram

Rina Zviel-Girshin @ASC


Re to fa algorithm cont3

RE to FA Algorithm (cont.)

4.Transform any diagram of the type

into the diagram

Rina Zviel-Girshin @ASC


Example1

Example

Construct an NFA for the regular expression b*+ ab.

We start by drawing the diagram:

Rina Zviel-Girshin @ASC


Example cont

Example (cont.)

Next we apply rule 2 for b*+ab:

Rina Zviel-Girshin @ASC


Example cont1

Example (cont.)

Next we apply rule 3 for ab:

Rina Zviel-Girshin @ASC


Example cont2

Example (cont.)

Next we apply

rule 4 for b*:

Rina Zviel-Girshin @ASC


Transforming a fa into re

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


Transforming a fa into re1

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


Algorithm fa to re

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


Algorithm fa to re cont

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


Algorithm fa to re cont1

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


Algorithm fa to re cont2

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


Algorithm fa to re cont3

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


Algorithm fa to re cont4

Algorithm FA to RE (cont.)

new(i,j)=old(i,j) + old(i,k)old(k,k)*old(k,j)

Rina Zviel-Girshin @ASC


Algorithm fa to re cont5

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


Algorithm fa to re cont6

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


Example2

Example

  • Transform into regular expression the following DFA

Rina Zviel-Girshin @ASC


Example3

Example

The result of first three steps of the algorithm:

  • new start state

  • new final state

  • unify multiple edges

Rina Zviel-Girshin @ASC


Example4

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


Example5

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


Example6

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


Complexity and computability theory i

Any Questions?

Rina Zviel-Girshin @ASC


  • Login