Lecture 22
This presentation is the property of its rightful owner.
Sponsored Links
1 / 28

Lecture 22 PowerPoint PPT Presentation


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

Lecture 22. Closure Properties for LFSA using NFA’s union (second proof) concatenation Kleene closure. LFSA closed under set union (again). LFSA closed under set union. Let L 1 and L 2 be arbitrary languages in LFSA Let M 1 and M 2 be NFA ’s s.t. L(M 1 ) = L 1 , L(M 2 ) = L 2

Download Presentation

Lecture 22

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


Lecture 22

Lecture 22

  • Closure Properties for LFSA using NFA’s

    • union (second proof)

    • concatenation

    • Kleene closure


Lfsa closed under set union again

LFSA closed under set union(again)


Lfsa closed under set union

LFSA closed under set union

  • Let L1 and L2 be arbitrary languages in LFSA

  • Let M1 and M2 be NFA’s s.t. L(M1) = L1, L(M2) = L2

    • M1 and M2 exist by definition of L1 and L2 in LFSA and the fact that every FSA is an NFA

  • Construct NFA M3 from NFA’s M1 and M2

  • Argue L(M3) = L1 union L2

  • There exists NFA M3 s.t. L(M3) = L1 union L2

  • L1 union L2 is in LFSA


Visualization

L1

L1 union L2

L2

M1

M3

M2

NFA’s

Visualization

  • Let L1 and L2 be arbitrary languages in LFSA

  • Let M1 and M2 be NFA’s s.t. L(M1) = L1, L(M2) = L2

    • M1 and M2 exist by definition of L1 and L2 in LFSA and the fact that every FSA is an NFA

  • Construct NFA M3 from NFA’s M1 and M2

  • Argue L(M3) = L1 union L2

  • There exists NFA M3 s.t. L(M3) = L1 union L2

  • L1 union L2 is in LFSA

LFSA


Algorithm specification

A

Algorithm Specification

  • Input

    • Two NFA’s M1 and M2

  • Output

    • NFA M3 such that L(M3) = L(M1) union L(M2)

NFA M1

NFA M2

NFA M3


Use l transition

a

l

a,b

l

a,b

a,b

A

M3

NFA M1

NFA M2

NFA M3

Use l-transition

a

M1

a,b

a,b

a,b

M2


General case

M2

M1

l

l

A

M3

NFA M1

NFA M2

NFA M3

General Case


Construction

Input

NFA M1 = (Q1, S1, q1, d1, A1)

NFA M2 = (Q2, S2, q2, d2, A2)

Output

NFA M3 = (Q3, S3, q3, d3, A3)

What is Q3?

Q3 = Q1 union Q2 union {p} where p is not in Q1 union Q2

Also, we need to rename states in Q2 if any share the same name with states in Q1

What is S3?

S3 = S1 = S2

What is q3?

q3 = p, the new state not in Q1 or Q2

A

NFA M1

NFA M2

NFA M3

Construction


Construction1

Input

NFA M1 = (Q1, S1, q1, d1, A1)

NFA M2 = (Q2, S2, q2, d2, A2)

Output

NFA M3 = (Q3, S3, q3, d3, A3)

What is A3?

A3 = A1 union A2

What is d3?

d3 = d1 union d2 union {(p,l,q1) ,(p,l,q2)}

That is, all the old transitions plus

d3(p,l) = {q1, q2}

A

NFA M1

NFA M2

NFA M3

Construction


Comments

Comments

  • You should be able to execute this algorithm

  • You should understand the idea behind this algorithm

  • You should understand how this algorithm can be used to simplify design

  • You should be able to design new algorithms for new closure properties

  • You should understand how this helps prove result that regular languages and LFSA are identical

    • In particular, you should understand how this is used to construct an NFA M from a regular expression r s.t. L(M) = L(r)

    • To be seen later


Lfsa closed under set concatenation

LFSA closed under set concatenation


Lfsa closed under set concatenation1

LFSA closed under set concatenation

  • Let L1 and L2 be arbitrary languages in LFSA

  • Let M1 and M2 be NFA’s s.t. L(M1) = L1, L(M2) = L2

    • M1 and M2 exist by definition of L1 and L2 in LFSA and the fact that every FSA is an NFA

  • Construct NFA M3 from NFA’s M1 and M2

  • Argue L(M3) = L1concatenate L2

  • There exists NFA M3 s.t. L(M3) = L1 concatenate L2

  • L1 concatenate L2 is in LFSA


Visualization1

L1

L1 concatenate L2

L2

M1

M3

M2

NFA’s

Visualization

  • Let L1 and L2 be arbitrary languages in LFSA

  • Let M1 and M2 be NFA’s s.t. L(M1) = L1, L(M2) = L2

    • M1 and M2 exist by definition of L1 and L2 in LFSA and the fact that every FSA is an NFA

  • Construct NFA M3 from NFA’s M1 and M2

  • Argue L(M3) = L1concatenate L2

  • There exists NFA M3 s.t. L(M3) = L1 concatenate L2

  • L1 concatenate L2 is in LFSA

LFSA


Algorithm specification1

A

Algorithm Specification

  • Input

    • Two NFA’s M1 and M2

  • Output

    • NFA M3 such that L(M3) = L(M1) concatenate L(M2)

NFA M1

NFA M2

NFA M3


Use l transition1

a

l

a,b

a,b

a,b

A

M3

NFA M1

NFA M2

NFA M3

Use l-transition

a

M1

a,b

a,b

a,b

M2


General case1

M2

M1

l

l

A

M3

NFA M1

NFA M2

NFA M3

General Case


Construction2

Input

NFA M1 = (Q1, S1, q1, d1, A1)

NFA M2 = (Q2, S2, q2, d2, A2)

Output

NFA M3 = (Q3, S3, q3, d3, A3)

What is Q3?

Q3 = Q1 union Q2

Also, we need to rename states in Q2 if any share the same name with states in Q1

What is S3?

S3 = S1 = S2

What is q3?

q3 = q1, the initial state of Q1

A

NFA M1

NFA M2

NFA M3

Construction


Construction3

Input

NFA M1 = (Q1, S1, q1, d1, A1)

NFA M2 = (Q2, S2, q2, d2, A2)

Output

NFA M3 = (Q3, S3, q3, d3, A3)

What is A3?

A3 = A2

What is d3?

d3 = d1 union d2 union {(p,l,q2) | p in A1}

That is, all the old transitions plus

d3(p,l) = {q2} for all p in A1

A

NFA M1

NFA M2

NFA M3

Construction


Comments1

Comments

  • You should be able to execute this algorithm

  • You should understand the idea behind this algorithm

  • You should understand how this algorithm can be used to simplify design

  • You should be able to design new algorithms for new closure properties

  • You should understand how this helps prove result that regular languages and LFSA are identical

    • In particular, you should understand how this is used to construct an NFA M from a regular expression r s.t. L(M) = L(r)

    • To be seen later


Lfsa closed under kleene closure

LFSA closed under Kleene Closure


Lfsa closed under kleene closure1

LFSA closed under Kleene Closure

  • Let L be arbitrary language in LFSA

  • Let M1 be an NFA s.t. L(M1) = L

    • M1 exists by definition of L1 in LFSA and the fact that every FSA is an NFA

  • Construct NFA M2 from NFA M1

  • Argue L(M2) = L1*

  • There exists NFA M2 s.t. L(M2) = L1*

  • L1* is in LFSA


Visualization2

L1

L1*

M1

M2

NFA’s

Visualization

  • Let L be arbitrary language in LFSA

  • Let M1 be an NFA s.t. L(M1) = L

    • M1 exists by definition of L1 in LFSA and the fact that every FSA is an NFA

  • Construct NFA M2 from NFA M1

  • Argue L(M2) = L1*

  • There exists NFA M2 s.t. L(M2) = L1*

  • L1* is in LFSA

LFSA


Algorithm specification2

A

Algorithm Specification

  • Input

    • NFA M1

  • Output

    • NFA M2 such that L(M2) = L(M1)*

NFA M1

NFA M2


Use l transition2

NFA M1

NFA M2

l

a

l

M2

A

Use l-transition

a

M1


General case2

NFA M1

NFA M2

l

M1

A

l

M3

General Case


Construction4

Input

NFA M1 = (Q1, S1, q1, d1, A1)

Output

NFA M2 = (Q2, S2, q2, d2, A2)

What is Q2?

Q2 = Q1 union {p} where p is not in Q1

What is S2?

S2 = S1

What is q2?

q3 = p, the state not in Q1

NFA M1

NFA M2

A

Construction


Construction5

Input

NFA M1 = (Q1, S1, q1, d1, A1)

Output

NFA M2 = (Q2, S2, q2, d2, A2)

What is A2?

A2 = {p}

What is d2?

d2 = d1 union {(p,l,q1)} union {(q,l,p) | q in A1}

That is, all the old transitions plus

d2(p,l) = {q1} and

d2(q,l) = d1(q,l) union {p} for all q in A1

NFA M1

NFA M2

A

Construction


Comments2

Comments

  • You should be able to execute this algorithm

  • You should understand the idea behind this algorithm

    • Why do we need to make an extra state p?

  • You should understand how this algorithm can be used to simplify design

  • You should be able to design new algorithms for new closure properties

  • You should understand how this helps prove result that regular languages and LFSA are identical

    • In particular, you should understand how this is used to construct an NFA M from a regular expression r s.t. L(M) = L(r)

    • To be seen later


  • Login