Scribd
Upload
36 views

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

Regular expressions provide a notation for specifying formal languages. They are equivalent to non-deterministic finite automata (NFAs) and can describe the same languages. Regular expressions use operators like union, concatenation, and Kleene closure. It is shown that finite automata and regular expressions are equivalent by converting between the two representations. A finite automaton can be converted to a regular expression using state elimination, and a regular expression can be converted to a non-deterministic finite automaton using an inductive construction. Algebraic laws describe the properties of operations on regular expressions.

Uploaded by

Himañshu Bhatt
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
36 views

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

Regular expressions provide a notation for specifying formal languages. They are equivalent to non-deterministic finite automata (NFAs) and can describe the same languages. Regular expressions use operators like union, concatenation, and Kleene closure. It is shown that finite automata and regular expressions are equivalent by converting between the two representations. A finite automaton can be converted to a regular expression using state elimination, and a regular expression can be converted to a non-deterministic finite automaton using an inductive construction. Algebraic laws describe the properties of operations on regular expressions.

Uploaded by

Himañshu Bhatt
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 23

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

You might also like