Scribd
Upload
173 views

Converting Many-State PDA To One-State PDA

The document describes how to convert a many-state pushdown automaton (PDA) to an equivalent single-state PDA. It does this by encoding the state as part of the stack symbol. Transition rules are modified such that they operate on the encoded stack instead of changing states directly. The encoding guesses the future state when pushing multiple symbols to ensure consistency when popping symbols later.

Uploaded by

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

Converting Many-State PDA To One-State PDA

The document describes how to convert a many-state pushdown automaton (PDA) to an equivalent single-state PDA. It does this by encoding the state as part of the stack symbol. Transition rules are modified such that they operate on the encoded stack instead of changing states directly. The encoding guesses the future state when pushing multiple symbols to ensure consistency when popping symbols later.

Uploaded by

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

Converting many-state PDA to one-state PDA

Summary
Let’s say P is a many state PDA with transition relation δ. We’ll create a single
state PDA P1 with transition relation δ1 . The stack symbols of P1 look like
[pXq] where p and q are states of P and X is a stack symbol from P (of course,
X might also be an input symbol). P1 has only one state which we’ll call 1 for
distinction. For each transition in δ, create one or more transitions in δ1 . There
is really only one rule, but we can break it down into three cases for clarity:

1. δ pops a symbol (and moves from p to q)

δ(p, a, X) = {(q, )}

⇓
δ1 (1, a, [pXq]) = {(1, )}

2. δ replaces a symbol
δ(p, a, X) = {(q, Y )}
⇓
∀b δ1 (1, a, [pXb]) = {(1, [qY b])}

3. δ pushes 2 or more symbols

δ(p, a, X) = {(q, Y Z)}

⇓
∀g, b δ1 (1, a, [pXb]) = {(1, [qY g][gZb])}

Note: If δ pushes more symbols, e.g. WXYZ, then we must make a guess
for each symbol, and the RHS will look like: [qW g1 ][g1 Xg2 ][g2 Y g3 ][g3 Zb].

Discussion
The trick is encoding the state into the stack in P1 . To start, we always keep
the current state with the topmost stack symbol. It’s on the left – so if [pAq]
is on the top of the stack, then we’re in state p. But this is not quite enough.
If we pop [pAq] we must still know what state we’re in. That’s where q comes
in. Before we push a new symbol onto the stack we guess what state we’ll be
in when the stack returns to the same height. That guess is on the right (the q
in [pAq]) – we’ll verify the guess later since we can only delete [pAq] if there is
a transition in δ that deletes A and moves from p to q.
When building the stack we always need to maintain consistency of adjacent
symbols (e.g. [pAq][qBr]) so deleting [pAq] actually moves us to state q. Here
are some example stack operations and their meanings:

1
1. [pAq][qBr] −→ [qBr]
This means that we pop A from the stack and move from state p to q.
2. [pAq][qBr] −→ [sXq][qBr]
This means that we replace A with X and move to state s. The symbol
[pAq] indicates a previous guess that the eventual deletion of the symbol
in this position would take us to state q, so we must maintain that guess
in [sXq].
3. [pAq][qBr] −→ [sXg][gY q][qBr]
Replace A by XY and move to state s. Here we increase the height of
the stack, so we must guess the state g that P will move to when this
symbol is eventually deleted. It may seem that by allowing any state g we
are somehow being too permissive, but that is not the case. We can only
delete [sXg] if there is a transition in δ that deletes X and moves from
s to g — if we guess incorrectly we place a symbol on the stack that can
never be deleted.

Example
Let P be a PDA that accepts {0n 10n |n ≥ 1} and has three states:

1. State p reads 0’s from the input and pushes them onto the stack. It may
stay in state p or move to state q.
2. State q reads a single 1 from the input and moves to state r.
3. State r reads 0’s from the input and pops 0’s from the stack.

δ looks like:

δ(p, 0, Z0 ) = {(p, 0Z0 ), (q, 0Z0 )}


δ(p, 0, 0) = {(p, 00), (q, 00)}

δ(q, 1, 0) = {(r, 0)}

δ(r, 0, 0) = {(r, )}


δ(r, 0, Z0 ) = {(r, )}

2
Here are the stack symbols of P1 :

[p0p], [p0q], [p0r] [p1p], [p1q], [p1r] [pZ0 p], [pZ0 q], [pZ0 r]

[q0p], [q0q], [q0r] [q1p], [q1q], [q1r] [qZ0 p], [qZ0 q], [qZ0 r]
[r0p], [r0q], [r0r] [r1p], [r1q], [r1r] [rZ0 p], [rZ0 q], [rZ0 r]
Here are three examples of transitions in δ and the transitions in δ1 that they
generate.

1. δ(p, 0, 0) → (q, 00)

δ1 (1, 0, [p0p]) = {(1, [q0p][p0p]), (1, [q0q][q0p]), (1, [q0r][r0p])}


δ1 (1, 0, [p0q]) = {(1, [q0p][p0q]), (1, [q0q][q0q]), (1, [q0r][r0q])}
δ1 (1, 0, [p0r]) = {(1, [q0p][p0r]), (1, [q0q][q0r]), (1, [q0r][r0r])}

2. δ(q, 1, 0) → (r, 0)

δ1 (1, 1, [q0p]) = {(1, [r0p])}


δ1 (1, 1, [q0q]) = {(1, [r0q])}
δ1 (1, 1, [q0r]) = {(1, [r0r])}

3. δ(r, 0, 0) → (r, )

δ1 (1, 0, [r0r]) = {(1, )}

It may be useful to work through some example stack configurations to see how
this machine accepts the string 00100. Hint. In the middle of the computation,
the string 100 will remain from the input and the stack will look like:

[q0r][r0r][rZ0 r]

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy