Regular Expressions

Midterm Logistics

● Midterm next Tuesday, May 8 from 7PM – 10PM.

● Test location by last name:

● A – J: Go to 200-002

● K – Z: Go to Hewlett 201

● Covers material up through and including today's lecture.

● Open-book, open-note, open-computer, closed-network.

● SCPD: Exam will be emailed out Tuesday morning. You can start the exam any time within a 24-hour window.

● If you cannot make the normal exam time, please let us know no later than Friday.

Regular Languages

● A language is called a regular language iff:

● It is accepted by some DFA. ● It is accepted by some NFA. ● Regular languages are closed under various operations:

● Complement ● Union ● Intersection

Concatenation

● The concatenation of two languages L1 and L2 over the alphabet Σ is the language

L1 L2 = { wx | w ∈ L1 ∧ x ∈ L2 } ● The set of strings that can be split into two

pieces: a string in L1 and a string in L2.

Concatenation Example

● Example: Let Σ = { a, b, …, z, A, B, …, Z }

● Noun = { Velociraptor, Rainbow, Whale, … } ● Verb = { Eats, Juggles, Loves, … } ● The = { The } ● The language TheNounVerbTheNoun is

● { TheVelociraptorEatsTheVelociraptor, TheWhaleLovesTheRainbow, TheRainbowJugglesTheVelociraptor, … }

Concatenating Regular Languages

● If L1 and L2 are regular languages, is L1L2?

● Intuition – can we split a string w into two strings x and y such

that w = xy, x ∈ L1, and y ∈ L2?

● Idea: Run the automaton for L1 on w, and whenever L1

reaches an accepting state hand the rest off w to L2.

● If L2 accepts the remainder, then L1 accepted the first part and the

string is in L1L2.

● If L2 rejects the remainder, then the split was incorrect.

Concatenating Regular Languages

start

Concatenating Regular Languages

start start

Concatenating Regular Languages

ε start

Concatenating Regular Languages

ε start

Lots and Lots of Concatenation

● Consider the language L = { aa, b }

● LL is the set of strings formed by concatenating pairs of strings in L.

● { aaaa, aab, baa, bb }

● LLL is the set of strings formed by concatenating triples of strings in L.

● { aaaaaa, aaaab, aabaa, aabb, baaaa, baab, bbaa, bbb }

● LLLL is the set of strings formed by concatenating quadruples of strings in L

● { aaaaaaaa, aaaaaab, aaaabaa, aaaabb, aabaaaa, aabaab, aabbaa, aabbb, baaaaaa, baaaab, baabaa, baabb, bbaaaa, bbaab, bbbaa, bbbb }

Language Exponentiation

● We can define what it means to “exponentiate” a language as follows:

● L0 = { ε }

● The set containing just the empty string. ● Idea: Any string formed by concatenating zero strings together is the empty string. ● Ln + 1 = LLn

● Idea: Concatenating (n + 1) strings together works by concatenating n strings, then concatenating one more.

The Kleene Closure

● An important operation on languages is the Kleene Closure, which is defined as ∞ L* = ∪Li i = 0

● Intuitively, all possible ways of concatenating any number of copies of strings in L together.

The Kleene Closure

● An important operation on languages is the Kleene Closure, which is defined as ∞ L* = ∪Li i = 0

● Intuitively,This is an infinite all possible union of ways of concatenating sets. It is defined as “the anyset number of all x contained of copies in Li of strings in L together. for any natural number i.”

The Kleene Closure

● An important operation on languages is the Kleene Closure, which is defined as ∞ L* = ∪Li i = 0

● Intuitively, all possible ways of concatenating any number of copies of strings in L together.

Reasoning about Infinity

● How do we prove properties of this infinite union? ● A Bad Line of Reasoning:

● L0 = { ε } is regular. ● L1 = L is regular. ● L2 = LL is regular ● L3 = (LL)L is regular ● … ● So their infinite union is regular.

Reasoning about Infinity

x Reasoning about Infinity

x Reasoning About the Infinite

● If a series of finite objects all have some property, their infinite union does not necessarily have that property!

● No matter how many times we zigzag that line, it's never straight. ● Concluding that it must be equal “in the limit” is not mathematically precise. ● (This is why calculus is interesting). ● A better intuition: Can we convert an NFA for the language L to an NFA for the language L*?

The Kleene Star

start

The Kleene Star

start ε

The Kleene Star

start ε

The Kleene Star

ε ε

start ε

Kleene Star in Action L = { ma, mom, mommy, mum }

a start m o m m y

u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Kleene Star in Action L = { ma, mom, mommy, mum }

a start ε m o m m y

u m

ε ε

m a m o m m u m

Summary

● NFAs are a powerful type of automaton that allows for nondeterministic choices.

● NFAs can also have ε-transitions that move from state to state without consuming any input.

● The subset construction shows that NFAs are not more powerful than DFAs, because any NFA can be converted into a DFA that accepts the same language.

● The union, intersection, difference, complement, concatenation, and Kleene closure of regular languages are all regular languages.

Rethinking Regular Languages

● We currently have several tools for showing a language is regular.

● Construct a DFA for it. ● Construct an NFA for it. ● Apply closure properties to existing languages. ● We have not spoken much of this last idea.

Constructing Regular Languages

● Idea: Build up all regular languages as follows:

● Start with a small set of simple languages we already know to be regular. ● Using closure properties, combine these simple languages together to form more elaborate languages. ● A bottom-up approach to the regular languages.

Regular Expressions

● Regular expressions are a family of descriptions that can be used to capture the regular languages. ● Often provide a compact and human-readable description of the language. ● Used as the basis for numerous software systems (Perl, flex, grep, etc.)

Atomic Regular Expressions

● The regular expressions begin with three simple building blocks. ● The symbol Ø is a regular expression that represents the empty language Ø. ● The symbol ε is a regular expression that represents the language { ε }

● This is not the same as Ø! ● For any a ∈ Σ, the symbol a is a regular expression for the language { a }

Compound Regular Expressions

● We can combine together existing regular expressions in four ways.

● If R1 and R2 are regular expressions, R1R2 is a regular expression represents the concatenation of the

languages of R1 and R2.

● If R1 and R2 are regular expressions, R1 | R2 is a regular

expression representing the union of R1 and R2.

● If R is a regular expression, R* is a regular expression for the Kleene closure of R.

● If R is a regular expression, (R) is a regular expression

with the same meaning as R. Operator Precedence

● Regular expression operator precedence is (R) R*

R1R2

R1 | R2 ● So ab*c|d is parsed as ((a(b*))c)|d

Regular Expression Examples

● The regular expression trick|treat represents the regular language { trick, treat } ● The regular expression booo* represents the regular language { boo, booo, boooo, … } ● The regular expression candy!(candy!)* represents the regular language { candy!, candy!candy!, candy!candy!candy!, … }

Regular Expressions, Formally

● The language of a regular expression is the language described by that regular expression.

● Formally:

● ℒ(ε) = {ε} ● ℒ(Ø) = Ø ● ℒ(a) = {a}

● ℒ(R1 R2) = ℒ (R1) ℒ (R2)

● ℒ(R1 | R2) = ℒ (R1) ∪ ℒ (R2) ● ℒ(R*) = ℒ (R)* ● ℒ((R)) = ℒ (R)

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | w contains 00 as a substring }

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | w contains 00 as a substring }

(0 | 1)*00(0 | 1)*

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | w contains 00 as a substring }

(0 | 1)*00(0 | 1)*

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | w contains 00 as a substring }

(0 | 1)*00(0 | 1)*

11011100101 0000 11111011110011111

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | w contains 00 as a substring }

(0 | 1)*00(0 | 1)*

11011100101 0000 11111011110011111

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | |w| = 4 }

Regular Expressions are Awesome

Let Σ = {0, 1} Let L = { w | |w| = 4 }

Regular Expressions are Awesome

Let Σ = {0, 1} Let L = { w | |w| = 4 }

TheThe lengthlength ofof aa stringstring ww isis denoteddenoted ||ww||

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | |w| = 4 }

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | |w| = 4 }

(0|1)(0|1)(0|1)(0|1)

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | |w| = 4 }

(0|1)(0|1)(0|1)(0|1)

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | |w| = 4 }

(0|1)(0|1)(0|1)(0|1)

0000 1010 1111 1000

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | |w| = 4 }

(0|1)(0|1)(0|1)(0|1)

0000 1010 1111 1000

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | |w| = 4 }

(0|1)4

0000 1010 1111 1000

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | |w| = 4 }

(0|1)4

0000 1010 1111 1000

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | w contains at most one 0 }

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | w contains at most one 0 }

1*(0 | ε)1*

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | w contains at most one 0 }

1*(0 | ε)1*

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | w contains at most one 0 }

1*(0 | ε)1*

11110111 111111 0111 0

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | w contains at most one 0 }

1*(0 | ε)1*

11110111 111111 0111 0

Regular Expressions are Awesome

● Let Σ = {0, 1} ● Let L = { w | w contains at most one 0 }

1*0?1*

11110111 111111 0111 0

Regular Expressions are Awesome

● Let Σ = { a, ., @ }, where a represents “some letter.” ● A regular expression for email addresses is

aa* (.aa*)* @ aa*.aa* (.aa*)*

Regular Expressions are Awesome

● Let Σ = { a, ., @ }, where a represents “some letter.” ● A regular expression for email addresses is

aa* (.aa*)* @ aa*.aa* (.aa*)*

[email protected] [email protected] [email protected]

Regular Expressions are Awesome

● Let Σ = { a, ., @ }, where a represents “some letter.” ● A regular expression for email addresses is

aa* (.aa*)* @ aa*.aa* (.aa*)*

[email protected] [email protected] [email protected]

Regular Expressions are Awesome

● Let Σ = { a, ., @ }, where a represents “some letter.” ● A regular expression for email addresses is

aa* (.aa*)* @ aa*.aa* (.aa*)*

[email protected] [email protected] [email protected]

Regular Expressions are Awesome

● Let Σ = { a, ., @ }, where a represents “some letter.” ● A regular expression for email addresses is

aa* (.aa*)* @ aa*.aa* (.aa*)*

[email protected] [email protected] [email protected]

Regular Expressions are Awesome

● Let Σ = { a, ., @ }, where a represents “some letter.” ● A regular expression for email addresses is

a+ (.aa*)* @ aa*.aa* (.aa*)*

[email protected] [email protected] [email protected]

Regular Expressions are Awesome

● Let Σ = { a, ., @ }, where a represents “some letter.” ● A regular expression for email addresses is

a+ (.a+)* @ a+.a+ (.a+)*

[email protected] [email protected] [email protected]

Regular Expressions are Awesome

● Let Σ = { a, ., @ }, where a represents “some letter.” ● A regular expression for email addresses is

a+ (.a+)* @ a+.a+ (.a+)*

[email protected] [email protected] [email protected]

Regular Expressions are Awesome

● Let Σ = { a, ., @ }, where a represents “some letter.” ● A regular expression for email addresses is

a+ (.a+)* @ a+ (.a+)+

[email protected] [email protected] [email protected]

Regular Expressions are Awesome

● Let Σ = { a, ., @ }, where a represents “some letter.” ● A regular expression for email addresses is

a+(.a+)*@a+(.a+)+

[email protected] [email protected] [email protected]

Regular Expressions are Awesome a+(.a+)*@a+(.a+)+ @, . a, @, . @, . @, . q 2 q8 q7 @ ., @ . a @ @, . . a start q a q @ q a . a 0 1 3 q04 q5 q6 a a a

Extensions to Regular Expressions

● To simplify regular expressions, we introduce the following shorthand (which is just syntax sugar for some other regular expression). ● Rn represents the language RR...R (n times). ● R? represents R | ε.

● Either zero or one copies of R. ● R+ represents RR*.

● n ≥ 1 copies of R. ● Sometimes called Kleene Plus.

Regular Expressions and Languages

● So far, we have two characterizations of regular languages:

● Any language accepted by some DFA.

● Any language accepted by some NFA. ● Theorem: A language is regular iff it is described by some regular expression.

● Need to show if a regular expression exists for L, L is regular.

● Need to show that if L is regular, there is a regular expression for L. ● The second direction is not obvious!

A Marvelous Construction

● To show that any language described by a regular expression is regular, we show how to convert a regular expression into an NFA.

● Theorem: For any regular expression R, there is an NFA N such that

● ℒ(R) = ℒ (N)

● N has exactly one accepting state.

● N has no transitions into its start state.

● N has no transitions out of its accepting state.

start

A Marvelous Construction

To show that any language described by a regular expression is regular, we show how to convert a regular expression into an NFA. Theorem: For any regular expression R, there is an NFA N such that ℒ(R) = ℒ (N)

● N has exactly one accepting state.

● N has no transitions into its start state.

● N has no transitions out of its accepting state.

start

A Marvelous Construction

To show that any language described by a regular expression is regular, we show how to convert a TheseregularThese are areexpression strongerstronger into an NFA. requirementsrequirements thanthan areare necessary for a normal NFA. Theorem: For any regular expressionnecessary R, there for isa annormal NFA NNFA. such that WeWe enforceenforce thesethese rulesrules toto simplify the construction. ℒ(R) = ℒ (N) simplify the construction.

● N has exactly one accepting state.

● N has no transitions into its start state.

● N has no transitions out of its accepting state.

start

Base Cases

start ε

Automaton for ε

start

Automaton for Ø

start a

Automaton for single character a

Construction for R1R2

start start

R1 R2

Construction for R1R2

start

R1 R2

Construction for R1R2

ε start

R1 R2

Construction for R1R2

ε start

R1 R2

Construction for R1 | R2

start

R 2 Construction for R1 | R2

start

start R1

start

R 2 Construction for R1 | R2

start R1

R 2 Construction for R1 | R2

start R1

R 2 Construction for R1 | R2

ε ε

start R1

ε ε

R 2 Construction for R1 | R2

ε ε

start R1

ε ε

R 2 Construction for R*

Construction for R*

start

Construction for R*

start start

Construction for R*

start start

Construction for R*

start ε ε

Construction for R*

ε start ε ε

Construction for R*

ε start ε ε

The Other Direction

● Proving that if L is regular, there is a regular expression R for L is much trickier. ● Idea: Convert an NFA for L into a regular expression for L. ● How do we do this?