Notation To Specify A Language: Theory of Computation - Regular Expressions

Theory of Computation - Regular
Expressions
 Notation to specify a language
Declarative
 Sort of like a programming language.

Fundamental in some languages like perl nda
applications like grep or lex
 Capable of describing the same thing as a NFA
 The two are actually equivalent, so RE =
NFA = DFA
Algebra for Languages
 Previously we discussed these
operators:
 Union (+)
 Concatenation (.)
 Kleene Star/Closure (*)
Def init ion of a
Expressio
Regular
n R is a regular expression if it

1.is: a for some a in the alphabet , standing for
the language {a}
2. ε, standing for the language {ε}
3. Ø, standing for the empty language
4. R1+R2where R1and R2are regular expressions,
and
+ signifies union (sometimes | is used)
5. R1R2where R1and R2are regular expressions and
this signifies concatenation
6. R* where R is a regular expression and
signifies closure
7. (R) where R is a regular expression, then a
RE Examples:
 L(001) = {001}
 L(0+10*) = { 0, 1, 10, 100, 1000, 10000, … }
 L(0*10*) = {1, 01, 10, 010, 0010, …} i.e. {w | w has
exactly a single 1}
 L()* = {w | w is a string of even length}
 L((0(0+1))*) = { ε, 00, 01, 0000, 0001, 0100, 0101,
…}
 L((0+ε)(1+ ε)) = {ε, 0, 1, 01}
 L(1Ø) = Ø ; concatenating the empty set to any
set yields the empty set.
 Rε = R
 R+Ø = R
Equivalence of FA and
RE
 Finite Automata and Regular Expressions
are equivalent. To show this:
 Show we can express a DFA as an equivalent
RE
 Show we can express a RE as an NFA.
Turning a DFA into a RE
 Theorem: If L=L(A) for some DFA , then
there is a regular expression R such that
L=L(R).
 State Elimination
 We’ll see how to do this next, easier than
inductive construction, there is no
exponential number of expressions
DFA t o RE:
St at e
Elimination
Eliminates states of the automaton and
replaces the edges with regular expressions
that includes the behavior of the eliminated
states.
Eventually we get down to the situation
with just a start and final node, and this is
easy to express as a RE
DFA to RE via State
Elimination (1)
1. Starting with intermediate states and then
moving to accepting states, apply the
eliminatio process to produce
state
n an automaton with
equivalent labels
expression regular
on the edges.
• The result will be a one or two
automaton with a start state
state
and accepting state.
DFA to RE
State
Elimination
2. If the two states are different, we will have
( 2):
an automaton that looks like the following:
R U
S
Start
We can describe this automaton as:

(R+SU*T)*SU*
DFA to RE
State
Elimination ( 3)
3. If the start state is also an accepting state, then
we
must also perform a state elimination from the
original automaton that gets rid of every
state but the state. This leaves
start following: the
R
Start
We can describe this automaton as simply R*.

DFA to RE State Elimination
(4)
4. If there are n accepting states, we must repeat
the above steps for each accepting states to get
n different regular expressions, R1, R2, … Rn.
For each repeat we turn any other
accepting
state to non-accepting. The desired regular
expression for the automaton is then the union
of each of the n regular expressions: R1
R2…
 RN
DFA RE
Example
 Convert the following to a
0,1
RE
0
1 1
S ta rt 3 1 2
 First convert the edges to RE’s:

0+ 1
0
1 1
Start 3 1 2
0
DFA  RE Example
(Eliminate
 2) State 1:
0 0+1
1 1
Start 3 1 2
0+10 0+1
11
Start 3 2
Answer: (0+10)*11(0+1)*
Convert ing a RE t o
an Automata
 We have shown we can convert an automata to
aRE. To show equivalence we must also go
the other direction, convert a RE to an
automaton.
 We can do this easiest by converting a RE to
an NFA
Inductive construction
 Startwith a simple basis, use that to build
more complex parts of the NFA
RE t o
NFA:
 Basi
s: R=a
a
R=ε ε
R=Ø
ε S ε
R=S+T
ε ε
T
R=ST ε
S T
ε ε
R=S*
S
ε
RE t o NFA
Example
 Convert R= (ab+a)* to an NFA
 We proceed in stages, starting from simple elements
and working our way up
a
a
b
b
a ε b
ab
RE to NFA Example
( 2):
ab+a
a ε b
ε ε
a
ε ε
(ab+a)*
a ε b
ε ε
ε ε
a
ε ε
ε
Algebraic Laws f or
RE’
 Justslike we have an algebra for arithmetic, we
also have an algebra for regular expressions.
 While there are some similarities to arithmetic
algebra, it is a bit different with regular
expressions.
Algebra for RE’s:
Commutative law for union:
 L + M= M+ L
Associative law for union:
 ( L + M) + N = L + (M + N)
Associative law for concatenation:
 (LM)N = L(MN)
 Note that there is no commutative law for
concatenation, i.e. LM  ML
Algebra f or RE’ s
(2L):+ Ø = Ø + L = L
T h e identity for union is:

 The identity for concatenation is:
 L ε = εL = L
 T h e annihilator for concatenation
is:
 Ø L = LØ = Ø
 Left distributive law:
 L(M + N) = LM + LN
 Right distributive law:
 ( M + N)L = LM + LN
 Idempotent law:
 L + L= L
Laws Involving Closure:
 (L*)* = L*
 i . e . closing an already closed expression does
not change the language
 Ø* =ε
 ε* =
ε
 = LL* =
 L * L*L
= L ++
L+
ε
End of
23
Slides

Notation To Specify A Language: Theory of Computation - Regular Expressions

Uploaded by

Copyright:

Available Formats

Notation To Specify A Language: Theory of Computation - Regular Expressions

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Notation To Specify A Language: Theory of Computation - Regular Expressions

Uploaded by

Copyright:

Available Formats

Theory of Computation - Regular

 Sort of like a programming language.

We can describe this automaton as:

We can describe this automaton as simply R*.

 First convert the edges to RE’s:

You might also like