- 113 Views
- Uploaded on
- Presentation posted in: General

Lecture 22

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 - - - - - - - - - - - - - - - - - - - - - - - - - -

- Closure Properties for LFSA using NFA’s
- union (second proof)
- concatenation
- Kleene closure

- 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

L1

L1 union L2

L2

M1

M3

M2

NFA’s

- 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

A

- 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

a

l

a,b

l

a,b

a,b

A

M3

NFA M1

NFA M2

NFA M3

a

M1

a,b

a,b

a,b

M2

M2

M1

l

l

A

M3

NFA M1

NFA M2

NFA M3

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

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

- 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

- 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

L1

L1 concatenate L2

L2

M1

M3

M2

NFA’s

- 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

A

- 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

a

l

a,b

a,b

a,b

A

M3

NFA M1

NFA M2

NFA M3

a

M1

a,b

a,b

a,b

M2

M2

M1

l

l

A

M3

NFA M1

NFA M2

NFA M3

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

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

- 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

- 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

L1

L1*

M1

M2

NFA’s

- 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

A

- Input
- NFA M1

- Output
- NFA M2 such that L(M2) = L(M1)*

NFA M1

NFA M2

NFA M1

NFA M2

l

a

l

M2

A

a

M1

NFA M1

NFA M2

l

M1

A

l

M3

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

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

- 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