![Page 1: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/1.jpg)
CSE 311: Foundations of Computing
Lecture 25: Pattern Matching, DFA≣NFA≣Regex
Languages vs Representations
![Page 2: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/2.jpg)
Last time: NFA to DFA
c
a
b
0
ɛɛɛɛ
0,1
1
0
NFA
a,b
DFA
0
c
1
b
b,c
1
0
a,b,c
∅∅∅∅
1
0,1
0
0
1
10
![Page 3: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/3.jpg)
Exponential Blow-up in Simulating Nondeterminism
• In general the DFA might need a state for every
subset of states of the NFA
– Power set of the set of states of the NFA
– �-state NFA yields DFA with at most �� states
– We saw an example where roughly �� is necessary
“Is the �th char from the end a 1?”
The famous “P=NP?” question asks whether a
similar blow-up is always necessary to get rid of
nondeterminism for polynomial-time algorithms
![Page 4: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/4.jpg)
Pattern matching
• Given
– a string s of � characters
– a pattern p of � characters
– usually � ≪ �
• Find
– all occurrences of the pattern p in the string s
• Obvious algorithm:
– try to see if p matches at each of the positions in s
stop at a failed match and try matching at the next
position
![Page 5: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/5.jpg)
pattern p = x y x y y x y x y x x
string s = x y x x y x y x y y x y x y x y y x y x y x x
![Page 6: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/6.jpg)
x y x y y x y x y x xstring s = x y x x y x y x y y x y x y x y y x y x y x x
![Page 7: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/7.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
x y x y y x y x y x x
![Page 8: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/8.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
xx y x y y x y x y x x
![Page 9: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/9.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
xx y
x y x y y x y x y x x
![Page 10: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/10.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
xx y
x y x y yx y x y y x y x y x x
![Page 11: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/11.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
xx y
x y x y yx
x y x y y x y x y x x
![Page 12: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/12.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
xx y
x y x y yx
x y x y y x y x y x xx y x y y x y x y x x
![Page 13: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/13.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
xx y
x y x y yx
x y x y y x y x y x xx
x y x y y x y x y x x
![Page 14: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/14.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
xx y
x y x y yx
x y x y y x y x y x xx
x y xx y x y y x y x y x x
![Page 15: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/15.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
xx y
x y x y yx
x y x y y x y x y x xx
x y xx
x y x y y x y x y x x
![Page 16: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/16.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
xx y
x y x y yx
x y x y y x y x y x xx
x y xx
xx y x y y x y x y x x
![Page 17: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/17.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
xx y
x y x y yx
x y x y y x y x y x xx
x y xx
xx y x y y
x y x y y x y x y x x
![Page 18: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/18.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
xx y
x y x y yx
x y x y y x y x y x xx
x y xx
xx y x y y
xx y x y y x y x y x x
Worst-case time
�(��)
![Page 19: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/19.jpg)
x y x ystring s = x y x x y x y x y y x y x y x y y x y x y x x
x y x y y x y x y x x
Lots of wasted work
![Page 20: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/20.jpg)
Better pattern matching via finite automata
• Build a DFA for the pattern (preprocessing) of size
�(�)
– Keep track of the ‘longest match currently active’
– The DFA will have only � + 1 states
• Run the DFA on the string � steps
• Obvious construction method for DFA will be
�(��) but can be done in �(�) time.
• Total �(� + �) time
![Page 21: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/21.jpg)
Building a DFA for the pattern
pattern p=x y x y y x y x y x x
x y x y y x y x y x x
![Page 22: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/22.jpg)
x y x y y x y x y x x
Building a DFA for the pattern
pattern p=x y x y y x y x y x x
x
y
y
x
x
![Page 23: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/23.jpg)
x y x y y x y x y x x
Building a DFA for the pattern
pattern p=x y x y y x y x y x x
x
y
y
y
y
x
x
xx
![Page 24: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/24.jpg)
x y x y y x y x y x x
Building a DFA for the pattern
pattern p=x y x y y x y x y x x
x
y
y
y
y
y
y
x
x
x
x
x
y
![Page 25: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/25.jpg)
Generalizing
• Can search for arbitrary combinations of patterns
– Not just a single pattern
– Build NFA for pattern then convert to DFA ‘on the fly*’.
* Only add states when the input string actually needs to
use them
(Compare DFA constructed above with subset
construction for the obvious NFA.)
![Page 26: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/26.jpg)
DFAs ≡ NFAs ≡ Regular expressions
We have shown how to build an optimal DFA for every regular expression
– Build NFA
– Convert NFA to DFA using subset construction
– Minimize resulting DFA
Theorem: A language is recognized by a DFA (or NFA) if and only if it has a regular expression
You need to know this fact but we won’t ask you anything about the “only if” direction from DFA/NFA to regular expression. For fun, we sketch the idea.
![Page 27: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/27.jpg)
Generalized NFAs
• Like NFAs but allow
– Parallel edges
– Regular Expressions as edge labels
NFAs already have edges labeled ɛɛɛɛ or a
• An edge labeled by AAAA can be followed by reading a
string of input chars that is in the language
represented by AAAA
• Defn: A string x is accepted iff there is a path from
start to final state labeled by a regular expression
whose language contains x
![Page 28: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/28.jpg)
Starting from an NFA
Add new start state and final state
ɛɛɛɛ
ɛɛɛɛ
ɛɛɛɛ
A
Then eliminate original states one by one,
keeping the same language, until it looks
like:
Final regular expression will be AAAA
![Page 29: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/29.jpg)
Only two simplification rules
• Rule 1Rule 1Rule 1Rule 1: For any two states q1 and q2 with parallel
edges (possibly q1=q2), replace
• Rule 2Rule 2Rule 2Rule 2: Eliminate non-start/final state q3 by
replacing all
for every pair of states q1, q2 (even if q1=q2)
q1q2
A
B
byA⋃⋃⋃⋃B
q1q2
AB
C AB*Cq1 q3 q2 q1q2by
![Page 30: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/30.jpg)
Converting an NFA to a regular expression
Consider the DFA for the mod 3 sum
– Accept strings from {0,1,2}* where the digits
mod 3 sum of the digits is 0
t0 t2
t1
0
0
0
1 1
1
2
22
![Page 31: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/31.jpg)
Splicing out a state t1
Regular expressions to add to edges
t0 t2
t1
0
0
1 1
1
2
22
t0→t1→t0 : 10*2
t0→t1→t2 : 10*1
t2→t1→t0 : 20*2
t2→t1→t2 : 20*1
0
sɛɛɛɛ
f
ɛɛɛɛ
![Page 32: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/32.jpg)
Splicing out a state t1
Regular expressions to add to edges
t0 t2
0 ∪ 20*12 ∪ 10*1
t0→t1→t0 : 10*2
t0→t1→t2 : 10*1
t2→t1→t0 : 20*2
t2→t1→t2 : 20*1
0 ∪ 10*2
sɛɛɛɛ
f
ɛɛɛɛ1 ∪ 20*2
![Page 33: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/33.jpg)
Splicing out state t2 (and then t0)
t0 t2
R1
R1: 0 ∪ 10*2
R2: 2 ∪ 10*1
R3: 1 ∪ 20*2
R4: 0 ∪ 20*1
R5: R1 ∪ R2R4*R3
R4R2
R3
Final regular expression: R5*=
(0 ∪ 10*2 ∪ (2 ∪ 10*1)(0 ∪ 20*1)*(1 ∪ 20*2))*
f
ɛɛɛɛ
sɛɛɛɛ
t0
R5f
ɛɛɛɛ
sɛɛɛɛ
![Page 34: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/34.jpg)
What languages have DFAs? CFGs?
All of them?
![Page 35: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/35.jpg)
Languages and Representations!
All
Context-Free
Regular
Finite
{001, 10, 12}
0*DFA
NFA
Regex
![Page 36: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/36.jpg)
Languages and Representations!
All
Context-Free
Regular
Finite
{001, 10, 12}
0*DFA
NFA
Regex
Warmup:Warmup:Warmup:Warmup:
All finite
languages
are regular.
![Page 37: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/37.jpg)
DFAs Recognize Any Finite Language
![Page 38: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/38.jpg)
DFAs Recognize Any Finite Language
Construct a DFA for each string in the language.
Then, put them together using the union construction.
![Page 39: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/39.jpg)
Languages and Machines!
All
Context-Free
Regular
Finite
{001, 10, 12}
0*DFA
NFA
Regex
Warmup 2:Warmup 2:Warmup 2:Warmup 2:
Surprising
example here
![Page 40: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/40.jpg)
An Interesting Infinite Regular Language
L = {xxxx∊∊∊∊ {{{{0, 1}}}}****:::: xxxx has an equal number of substrings 01 and 10}.
L is infinite.
0, 00, 000, …
L is regular. How could this be?
(It seems to be comparing counts and counting seems
hard for DFAs.)
![Page 41: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/41.jpg)
An Interesting Infinite Regular Language
L = {xxxx∊∊∊∊ {{{{0, 1}}}}****:::: xxxx has an equal number of substrings 01 and 10}.
L is infinite.
0, 00, 000, …
L is regular. How could this be? It is just the set of binary strings
that are empty or begin and end with the same character!
s0
0
1 s4s3
0
1
01
s2s1
1
0
10
![Page 42: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/42.jpg)
Languages and Representations!
All
Context-Free
Regular
Finite
0*DFA
NFA
Regex
??? Main Event:Main Event:Main Event:Main Event:
Prove there is
a context-free
language
that isn’t
regular.
{001, 10, 12}
![Page 43: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/43.jpg)
The language of “Binary Palindromes” is Context-Free
S → ε | 0 | 1 | 0S0 | 1S1
![Page 44: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/44.jpg)
Is the language of “Binary Palindromes” Regular ?
![Page 45: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/45.jpg)
Is the language of “Binary Palindromes” Regular ?
Intuition (NOT A PROOF!):
QQQQ: What would a DFA need to keep track of to decide the
language?
AAAA: It would need to keep track of the “first part” of the input
in order to check the second part against it
…but there are an infinite # of possible first parts and we
only have finitely many states.
![Page 46: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/46.jpg)
B = {binary palindromes} can’t be recognized by any DFA
The general proof strategy is:
– Assume (for contradiction) that it’s possible.
– Therefore, some DFA (call it M) exists that
recognizes B
![Page 47: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/47.jpg)
B = {binary palindromes} can’t be recognized by any DFA
The general proof strategy is:
– Assume (for contradiction) that it’s possible.
– Therefore, some DFA (call it M) exists that
recognizes B
– Our goal is to show that M must be “confused”...
we want to show it “does the wrong thing”.
How can a DFA be “wrong”?
– when it accepts or rejects a string it shouldn’t.
![Page 48: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/48.jpg)
B = {binary palindromes} can’t be recognized by any DFA
The general proof strategy is:
– Assume (for contradiction) that it’s possible.
– Therefore, some DFA (call it M) exists that
recognizes B
– Our goal is to show that M must be “confused”...
we want to show it “does the wrong thing” accepts
or rejects a string it shouldn’t.
![Page 49: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/49.jpg)
B = {binary palindromes} can’t be recognized by any DFA
The general proof strategy is:
– Assume (for contradiction) that it’s possible.
– Therefore, some DFA (call it M) exists that recognizes B
– We want to show: M accepts or rejects a string it shouldn’t.
Key Idea 1: Key Idea 1: Key Idea 1: Key Idea 1: If two strings “collide” at any point, a
DFA can no longer distinguish between them!0i1
?
0j1
![Page 50: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/50.jpg)
The general proof strategy is:
– Assume (for contradiction) that it’s possible.
– Therefore, some DFA (call it M) exists that recognizes B
– We want to show: M accepts or rejects a string it shouldn’t.
Key Idea 1: Key Idea 1: Key Idea 1: Key Idea 1: If two strings “collide” at any point, a
DFA can no longer distinguish between them!
Key Idea 2: Key Idea 2: Key Idea 2: Key Idea 2: Our machine M has a finite number of
states which means if we have infinitely many
strings, two of them must collide!
B = {binary palindromes} can’t be recognized by any DFA
0a1?
0b1
![Page 51: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/51.jpg)
The general proof strategy is:
– Assume (for contradiction) that it’s possible.
– Therefore, some DFA (call it M) exists that recognizes B
– We want to show M accepts or rejects a string it shouldn’t.
We choose an INFINITEINFINITEINFINITEINFINITE set S of “half strings” (which
we intend to complete later). It is imperative that for
every pairevery pairevery pairevery pair of strings in our set there is an “accept”
completion that the two strings DO NOT SHARE.
B = {binary palindromes} can’t be recognized by any DFA
1
01
001
0001
00001
.............
______
______
______
______
______
![Page 52: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/52.jpg)
B = {binary palindromes} can’t be recognized by any DFA
Suppose for contradiction that some DFA, M, recognizes B.
We show M accepts or rejects a string it shouldn’t.
Consider S={1, 01, 001, 0001, 00001, ...} = {0n1 : n ≥ 0}.
Key Key Key Key Idea 2: Idea 2: Idea 2: Idea 2: Our machine has a finite number of states which means
if we have infinitely many strings, two of them must collide!
![Page 53: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/53.jpg)
B = {binary palindromes} can’t be recognized by any DFA
Suppose for contradiction that some DFA, M, recognizes B.
We show M accepts or rejects a string it shouldn’t.
Consider S={1, 01, 001, 0001, 00001, ...} = {0n1 : n ≥ 0}.
Since there are finitely many states in M and infinitely many
strings in S, there exist strings 0a1 ∈ S and 0b1 ∈ S with a≠b that
end in the same state of M.
SUPER IMPORTANT POINTSUPER IMPORTANT POINTSUPER IMPORTANT POINTSUPER IMPORTANT POINT: You do not get to choose
what a and b are. Remember, we’ve proven they
exist…we have to take the ones we’re given!
![Page 54: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/54.jpg)
B = {binary palindromes} can’t be recognized by any DFA
Suppose for contradiction that some DFA, M, accepts B.
We show M accepts or rejects a string it shouldn’t.
Consider S = {0n1 : n ≥ 0}.
Since there are finitely many states in M and infinitely many
strings in S, there exist strings 0a1 ∈ S and 0b1 ∈ S with a≠b that
end in the same state of M.
Now, consider appending 0a to both strings.
Key Idea 1: Key Idea 1: Key Idea 1: Key Idea 1: If two strings “collide” at any point, a DFA can no longer
distinguish between them!
![Page 55: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/55.jpg)
B = {binary palindromes} can’t be recognized by any DFA
Suppose for contradiction that some DFA, M, recognizes B.
We show M accepts or rejects a string it shouldn’t.
Consider S = {0n1 : n ≥ 0}.
Since there are finitely many states in M and infinitely many strings in S, there exist strings 0a1 ∈ S and 0b1 ∈ S with a≠b that end in the same state of M.
Now, consider appending 0a to both strings.
Then, since 0a1 and 0b1 end in the same state, 0a10a and 0b10a also end in the same state, call it q. But then M must make a mistake: q needs to be an accept state since 0a10a ∈ B, but then M would accept 0b10a ∉ B which is an error.
0aa1
q0a
0b1
![Page 56: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/56.jpg)
B = {binary palindromes} can’t be recognized by any DFA
Suppose for contradiction that some DFA, M, recognizes B.
We show M accepts or rejects a string it shouldn’t.
Consider S = {0n1 : n ≥ 0}.
Since there are finitely many states in M and infinitely many strings in S, there exist strings 0a1 ∈ S and 0b1 ∈ S with a≠b that end in the same state of M.
Now, consider appending 0a to both strings.
Then, since 0a1 and 0b1 end in the same state, 0a10a and 0b10a also end in the same state, call it q. But then M must make a mistake: qneeds to be an accept state since 0a10a ∈ B, but then M would accept 0b10a ∉ B which is an error.
This is a contradiction, since we assumed that M recognizes B. Since M was arbitrary, there is no DFA that there is no DFA that there is no DFA that there is no DFA that recognizes B.B.B.B.
0aa1
q0a
0b1
![Page 57: Lecture 25: Pattern Matching, DFA NFA Regex Languages vs ......– Regular Expressions as edge labels NFAs already have edges labeled ɛɛɛɛor a • An edge labeled by AAAcan be](https://reader036.vdocuments.site/reader036/viewer/2022063015/5fd3982cf0339653e45d2a6b/html5/thumbnails/57.jpg)
Showing that a Language L is not regular
1. “Suppose for contradiction that some DFA M recognizes L.”
2. Consider an INFINITEINFINITEINFINITEINFINITE set S of “half strings” (which we
intend to complete later). It is imperative that for every pairevery pairevery pairevery pair
of strings in our set there is an “accept” completion that
the two strings DO NOT SHARE.
3. “Since SSSS is infinite and MMMM has finitely many states, there
must be two strings ssssaaaa and ssssbbbb in SSSS for some ssssaaaa ≠ ssssbbbb that end
up at the same state of MMMM.”
4. Consider appending the (correct) completion to each of the
two strings.
5. “Since ssssaaaa and ssssbbbb both end up at the same state of MMMM, and
we appended the same string tttt, both ssssaaaatttt and ssssbbbbtttt end at the
same state q of M. M. M. M. Since ssssaaaatttt ∈ L L L L and ssssbbbbtttt ∉ L, L, L, L, M M M M does not
recognize LLLL.”
6. “Since MMMM was arbitrary, no DFA recognizes LLLL.”