# Complexity and Computability Theory I

Shared by:
Categories
-
Stats
views:
11
posted:
9/5/2011
language:
English
pages:
44
Document Sample

```							Complexity and Computability
Theory I

Lecture #11
Instructor: Rina Zviel-Girshin
Lea Epstein
Overview

•   Models and limitations
•   Examples
•   Nondeterministic PDA
•   Examples
•   Equivalence of PDA’s models

Rina Zviel-Girshin @ASC   2
Finite automata
• A finite automaton has a huge limitation.
• It can count only by changing states.
• So the highest number FA can remember is
not more than number of it's states.
• This limitation confined the class of
languages that FA can recognize to a rather
small category - that of regular languages.

Rina Zviel-Girshin @ASC        3
Turing machine
• Infinite memory can allow us recognition of
larger class of languages.
• If we put no constrains on the use of this
memory, i.e. the automaton can read and
write in any location in the memory, then
we have the most potent automaton
- Turing machine.

Rina Zviel-Girshin @ASC     4
Power of TM

• We claim that Turing machine (TM) can
perform any computation the most powerful
computer can.

Rina Zviel-Girshin @ASC    5
The stack model
• If we add to FA an unlimited memory but
limit the use of it we get a machine which is
stronger than FA but less powerful than
TM.
• Our limitation - the memory will be a stack.
• We can read/write only at the top of the
stack, obliterating the previous content.

Rina Zviel-Girshin @ASC      6
The stack model (cont.)
• We still have states to remember the
previous contents (if we wish to do so).
• But as the number of states is finite we can
remember only finite contents while our
stack is infinite.

Rina Zviel-Girshin @ASC         7
Pushdown automata
• Informally a pushdown automata (PDA) is a
FA+stack.

• To remember or to count we write to the
stack and read afterwards when we need the
information.

Rina Zviel-Girshin @ASC    8
Example
• For example the following language can be
recognized by PDA but not FA.
L = {aibi | i>0}

• The basic idea of recognition:
• remembering a's by pushing it to the stack
• comparing the number of b's to the number
of a's by popping one a for each b.
Rina Zviel-Girshin @ASC        9
Example (cont.)
• If the stack was emptied before the end of
input - we had more b's than a's.
• If the stack was not emptied at the end of
input - we had more a's than b's.
• The automaton will accept a word if at
exactly the end of input the stack is emptied
for the first time.

Rina Zviel-Girshin @ASC      10
Example (cont.)
• It gets stuck and rejects the word if the two
events -
– end of input and
– the first time stack becomes empty
- are not simultaneous.

Rina Zviel-Girshin @ASC         11
Acceptance by PDA
• There are several models of PDA with
different acceptance policies.
• All are equivalent.
– acceptance by an empty stack
– acceptance using accepting states
– acceptance by an empty stack and accepting
states

Rina Zviel-Girshin @ASC         12
Acceptance by an empty stack
• The automaton will accept a word if
exactly at the end of input the stack is
emptied for the first time.
• All states are the same, there are no
accepting states.

Rina Zviel-Girshin @ASC    13
Acceptance using accepting
states
• The automaton will accept a word if at
exactly the end of input the automaton is in
accepting state.
• Whether the stack is empty or not at that
time has no relevance.

Rina Zviel-Girshin @ASC         14
Acceptance by an empty stack
and accepting states
• The automaton will accept a word if three
events happen simultaneously:
– the end of input
– the stack is emptied for the first time
– automaton is in accepting state.

Rina Zviel-Girshin @ASC    15
Transition function in PDA
• There are two differences between the
transition functions of PDA and FA.
• In PDA we move using
– A state,
– A letter of input and
– A letter of stack
• The transition function output is a state and
a letter or string to be written into the stack.

Rina Zviel-Girshin @ASC      16
Formal definition of PDA
• A pushdown automaton is a 6-tuple (Q, ,
, , q0, F) where:
• Q – a finite set of states
•  - a finite input alphabet
•  - a finite stack alphabet
• : Q  (U)    P(Q  *)
• q0  Q the start state
• F – a finite set of accepting states.

Rina Zviel-Girshin @ASC      17
The possible stack
transformations
• Consider different possibilities of transition
function:
• (q,,X) = (q', Y)
• where
(q - current state, - input letter, X - top of the
stack) = (q' - next state, Y - string to write into the
stack)

Rina Zviel-Girshin @ASC            18
Popping the stack
• Popping the stack:
• (q,,X) = (q', )
• write an empty word to the stack, i.e.
deleting the X at the top of the stack and
moving the top pointer one cell down.

Rina Zviel-Girshin @ASC       19
No change
• No change:
• (q,,X) = (q', X)
• write the same letter to the stack, i.e. not
changing the X at the top of the stack and
not moving the top pointer

Rina Zviel-Girshin @ASC        20
• (q,,X) = (q', W1..WnX)
• write the same letter to the stack and above
it write a string, i.e. not changing the X at
the top of the stack, but adding any number
of letters above in the same one transition
and moving the top pointer as needed

Rina Zviel-Girshin @ASC          21
Change the stack
• Change the stack:
• (q,,X) = (q', W1..Wn)
• delete the letter X in the stack and instead
write a string, i.e. changing the X at the top
of the stack into any number of letters
above in the same one transition and
moving the top pointer as needed

Rina Zviel-Girshin @ASC          22
Bottom of the stack symbol
• The acceptance model we will use will be
by emptying the stack.
• In this model of acceptance the PDA is
stuck immediately if the stack is empty.

stack.

Rina Zviel-Girshin @ASC      23
Bottom of the stack symbol
• Therefore we will assume that at the
commencement of the computation, the
stack already includes one symbol - a
special "bottom of the stack symbol".
• There are many possible notations for the
symbol, such as \$, ┤.
• We will use the letter Z for the "bottom of
the stack symbol".

Rina Zviel-Girshin @ASC        24
Example
Construct a PDA to recognize: L = {aibi | i>0}
We will use the empty stack model.

a,Z;A a,A;AA                           b,A;

q0           b,A;                  q1

Rina Zviel-Girshin @ASC               25
Example
• Construct a PDA to recognize:
L = {wcwR |w{a,b}*}
• We will use the empty stack model.

a,Z; A b,Z; B
a,A; AA b,A; BA                             b,B;
a,B; AB b,B; BB                             a,A;

q0       c,Z; c,A; A c,B; B             q1

Rina Zviel-Girshin @ASC          26
Example
L = {aibj | i >0 and j=i+5}
• Construct a PDA to recognize:
• We will use the empty stack model.

a,Z; AAAAAA
a,A; AA                           b,A;

q0            b,A;                 q1

Rina Zviel-Girshin @ASC          27
Deterministic PDA
• A PDA is called deterministic if”f it holds
the following two conditions:
• for each qQ, a{} and X
– |(q,a,X)|  1
• for each qQ and X
– if (q,,X)
– then for each  (q, ,X)=

Rina Zviel-Girshin @ASC    28
Deterministic PDA
Informally
• A PDA is called non-deterministic if there
exist at least two transitions from the
current state q and stack top X:
– one with  (-transition) and
– another with .

Rina Zviel-Girshin @ASC     29
Example of ND PDA
• Construct a PDA to recognize:
L = {wwR |w{a,b}*}
We will use the empty stack model
a,Z; A b,Z; B
a,A; AA b,A; BA                             b,B; e
a,B; AB b,B; BB                             a,A; e

q0       e,A; A e,Z; e e,B; B            q1

Rina Zviel-Girshin @ASC            30
Example of ND PDA
• Construct a PDA to recognize:
L = {aibjci+j | i,j0}

We will use the empty stack model.
The basic idea:
• push a’s and b’s to the stack and than pop
the stack top symbol for each c letter.
Rina Zviel-Girshin @ASC      31
L = {aibjci+j | i,j0}
b,A; AA
a,Z; A
a,A; AA
q2
b,A; AA
b,Z; A
q0
c,A; e      c,A; e
c,A; e
e,Z; e

q1
q3

Rina Zviel-Girshin @ASC                        32
Example
• Construct a PDA to recognize:
L = {aibj | i,j>0}
• We will use a finite state model.

a,Z; A
a,A; A                             b,A; A

q0             b,A; A               q1
qf
q4

Rina Zviel-Girshin @ASC            33
Equivalent form of acceptance
• The empty stack PDA equivalent to the
final state PDA
The basic idea:
• We will use the empty stack PDA model
during the computation and on the last stage
we will produce -transition to the final
state.

Rina Zviel-Girshin @ASC     34
Algorithm
• Given PDA=(Q, , , , q0, ∅)
• Convert it to
FS PDA=(QU{s,f}, , U{Y}, , s, F={f})

1.Create a new start state s and a new final
state f.
2.Create a new bottom of the stack symbol: Y.

Rina Zviel-Girshin @ASC     35
Algorithm(cont.)
3.Connect a new start state s to the old start
state q0 by an edge labeled ,Y; ZY that
means (s,,Y)=(q0,ZY)
4.Connect each state of the PDA to the new
final state f and label the edges with the
expression ,Y; Y.

Rina Zviel-Girshin @ASC        36
L={a}
• Given an empty stack automaton:

Construct an equivalent final-state automaton.

Rina Zviel-Girshin @ASC     37
L={a}
•The resulting finite-state automaton:

Rina Zviel-Girshin @ASC   38
Equivalent form of acceptance
• The final-state PDA is equivalent to the
empty stack PDA
The basic idea:
• We will use a finite state PDA model during
the computation and on the last stage we
will produce -transition to empty the stack
state - by popping everything from the
stack.

Rina Zviel-Girshin @ASC     39
Algorithm
• Given PDA=(Q, , , , q0, F)
• Convert it to ESPDA=(QU{s,f}, , U{Y},
, s, ∅)

1. Create a new start state s and a new “empty
state” f.
2. Create a new bottom of the stack symbol:
Y.

Rina Zviel-Girshin @ASC     40
Algorithm(cont.)
3. Connect a new start state s to the old start state q0
by an edge labeled ,Y; ZY that means
(s,,Y)=(q0,ZY)
4. Connect each final state of the PDA to the new
empty state f and label the edges with the
expression ,A;  where A means any symbol of
the stack, including Z and Y.
5. Add new edges from f to f labeled as in step 4:
(f,,A)=(f, ) for every A in .

Rina Zviel-Girshin @ASC           41
L={a}
• Given a finite-state automaton:

Construct an equivalent empty stack
automaton.
Rina Zviel-Girshin @ASC   42
L={a}
•The resulting automaton:

Rina Zviel-Girshin @ASC   43
Any Questions?

Rina Zviel-Girshin @ASC   44

```
Related docs
Other docs by yaofenji
HPCx_March_2005