Pushdown automaton

Formal definition

We use standard formal language notation: ${\displaystyle {\mathrm{\Gamma }}^{\ast }}$ denotes the set of finite-length strings over alphabet ${\displaystyle \mathrm{\Gamma }}$ and ${\displaystyle \epsilon }$ denotes the empty string.

A PDA is formally defined as a 7-tuple:

${\displaystyle M=(Q,\mathrm{\Sigma },\mathrm{\Gamma },\delta ,q_0,Z,F)}$ where

• ${\displaystyle Q}$ is a finite set of states
• ${\displaystyle \mathrm{\Sigma }}$ is a finite set which is called the input alphabet
• ${\displaystyle \mathrm{\Gamma }}$ is a finite set which is called the stack alphabet
• ${\displaystyle \delta }$ is a finite subset of ${\displaystyle Q\times (\mathrm{\Sigma }\cup \{\epsilon \})\times \mathrm{\Gamma }\times Q\times {\mathrm{\Gamma }}^{\ast }}$, the transition relation
• ${\displaystyle q_0\in Q}$ is the start state
• ${\displaystyle Z\in \mathrm{\Gamma }}$ is the initial stack symbol
• ${\displaystyle F\subseteq Q}$ is the set of accepting states

An element ${\displaystyle (p,a,A,q,\alpha )\in \delta }$ is a transition of ${\displaystyle M}$. It has the intended meaning that ${\displaystyle M}$, in state ${\displaystyle p\in Q}$, on the input ${\displaystyle a\in \mathrm{\Sigma }\cup \{\epsilon \}}$ and with ${\displaystyle A\in \mathrm{\Gamma }}$ as topmost stack symbol, may read ${\displaystyle a}$, change the state to ${\displaystyle q}$, pop ${\displaystyle A}$, replacing it by pushing ${\displaystyle \alpha \in {\mathrm{\Gamma }}^{\ast }}$. The ${\displaystyle (\mathrm{\Sigma }\cup \{\epsilon \})}$ component of the transition relation is used to formalize that the PDA can either read a letter from the input, or proceed leaving the input untouched.

In many texts the transition relation is replaced by an (equivalent) formalization, where

• ${\displaystyle \delta }$ is the transition function, mapping ${\displaystyle Q\times (\mathrm{\Sigma }\cup \{\epsilon \})\times \mathrm{\Gamma }}$ into finite subsets of ${\displaystyle Q\times {\mathrm{\Gamma }}^{\ast }}$

Here ${\displaystyle \delta (p,a,A)}$ contains all possible actions in state ${\displaystyle p}$ with ${\displaystyle A}$ on the stack, while reading ${\displaystyle a}$ on the input. One writes for example ${\displaystyle \delta (p,a,A)=\{(q,BA)\}}$ precisely when ${\displaystyle (q,BA)\in \{(q,BA)\},(q,BA)\in \delta (p,a,A),}$ because ${\displaystyle ((p,a,A),\{(q,BA)\})\in \delta }$. Note that finite in this definition is essential.

Computations

In order to formalize the semantics of the pushdown automaton, a description of the current situation is introduced. Any 3-tuple ${\displaystyle (p,w,\beta )\in Q\times {\mathrm{\Sigma }}^{\ast }\times {\mathrm{\Gamma }}^{\ast }}$ is called an instantaneous description (ID) of ${\displaystyle M}$, which includes the current state, the part of the input tape that has not been read, and the contents of the stack (top-most symbol written first). The transition relation ${\displaystyle \delta }$ defines the step-relation ${\displaystyle {⊢}_M}$ of ${\displaystyle M}$ on instantaneous descriptions. For instruction ${\displaystyle (p,a,A,q,\alpha )\in \delta }$ there exists a step ${\displaystyle (p,ax,A\gamma ){⊢}_M(q,x,\alpha \gamma )}$, for every ${\displaystyle x\in {\mathrm{\Sigma }}^{\ast }}$ and every ${\displaystyle \gamma \in {\mathrm{\Gamma }}^{\ast }}$.

In general, pushdown automata are nondeterministic, meaning that in a given instantaneous description ${\displaystyle (p,w,\beta )}$ there may be several possible steps. Any of these steps can be chosen in a computation. With the above definition, in each step a single symbol (top of the stack) is always popped, and replaced with as many symbols as necessary. As a consequence, no step is defined when the stack is empty.

Computations of the pushdown automaton are sequences of steps. The computation starts in the initial state ${\displaystyle q_0}$ with the initial stack symbol ${\displaystyle Z}$ on the stack, and a string ${\displaystyle w}$ on the input tape—thus, with initial description ${\displaystyle (q_0,w,Z)}$.

There are two modes of accepting. The pushdown automaton either accepts by final state, which means that after reading its input the automaton reaches an accepting state (in ${\displaystyle F}$), or else it accepts by empty stack (${\displaystyle \epsilon }$), which means that after reading its input the automaton empties its stack. The first acceptance mode uses the internal memory (state), the second the external memory (stack).

Formally one defines

1. ${\displaystyle L(M)=\{w\in {\mathrm{\Sigma }}^{\ast }|(q_0,w,Z){⊢}_M^{\ast }(f,\epsilon ,\gamma )}$ with ${\displaystyle f\in F}$ and ${\displaystyle \gamma \in {\mathrm{\Gamma }}^{\ast }\}}$ (final state)
2. ${\displaystyle N(M)=\{w\in {\mathrm{\Sigma }}^{\ast }|(q_0,w,Z){⊢}_M^{\ast }(q,\epsilon ,\epsilon )}$ with ${\displaystyle q\in Q\}}$ (empty stack)

Here ${\displaystyle {⊢}_M^{\ast }}$ represents the reflexive and transitive closure of the step relation ${\displaystyle {⊢}_M}$, meaning any number of consecutive steps (zero, one or more).

For each single pushdown automaton, these two languages need have no relation; they may be equal, but usually this is not the case. A specification of the automaton should also include the intended mode of acceptance. Taken over all pushdown automata, both acceptance conditions define the same family of languages.

Theorem. For each pushdown automaton ${\displaystyle M}$ one may construct a pushdown automaton ${\displaystyle M^{\prime }}$ such that ${\displaystyle L(M)=N(M^{\prime })}$, and vice versa, for each pushdown automaton ${\displaystyle M}$ one may construct a pushdown automaton ${\displaystyle M^{\prime }}$ such that ${\displaystyle N(M)=L(M^{\prime })}$

Example

The following is the formal description of the PDA which recognizes the language ${\displaystyle \{0^n{1}^n\mid n\ge 0\}}$ by final state:

${\displaystyle M=(Q,\mathrm{\Sigma },\mathrm{\Gamma },\delta ,q_0,Z,F)}$, where

• states: ${\displaystyle Q=\{p,q,r\}}$
• input alphabet: ${\displaystyle \mathrm{\Sigma }=\{0,1\}}$
• stack alphabet: ${\displaystyle \mathrm{\Gamma }=\{A,Z\}}$
• start state: ${\displaystyle q_0=p}$
• start stack symbol: Z
• accepting states: ${\displaystyle F=\{r\}}$

The transition relation ${\displaystyle \delta }$ consists of the following six instructions:

${\displaystyle (p,0,Z,p,AZ)}$,

${\displaystyle (p,0,A,p,AA)}$,

${\displaystyle (p,ϵ,Z,q,Z)}$,

${\displaystyle (p,ϵ,A,q,A)}$,

${\displaystyle (q,1,A,q,ϵ)}$, and

${\displaystyle (q,ϵ,Z,r,Z)}$.

In words, the first two instructions say that in state p any time the symbol 0 is read, one A is pushed onto the stack. Pushing symbol A on top of another A is formalized as replacing top A by AA (and similarly for pushing symbol A on top of a Z).

The third and fourth instructions say that, at any moment the automaton may move from state p to state q.

The fifth instruction says that in state q, for each symbol 1 read, one A is popped.

Finally, the sixth instruction says that the machine may move from state q to accepting state r only when Z is the top stack symbol. In this PDA, that is equivalent to the stack consisting of a single Z, since Z is only used as the bottom-of-stack marker and no transition pushes another Z above it.

There seems to be no generally used representation for PDA. Here we have depicted the instruction ${\displaystyle (p,a,A,q,\alpha )}$ by an edge from state p to state q labelled by ${\displaystyle a;A/\alpha }$ (read a from input string; replace A at top of stack by ${\displaystyle \alpha }$).

Explanation

The following illustrates how the above PDA computes on different input strings. The subscript M from the step symbol ${\displaystyle ⊢}$ is here omitted.

1. Input string = 0011. There are various computations, depending on the moment the move from state p to state q is made. Only one of these is accepting.
   1. ${\displaystyle (p,0011,Z)⊢(q,0011,Z)⊢(r,0011,Z)}$
      The final state is accepting, but the input is not accepted this way as it has not been read.
   2. ${\displaystyle (p,0011,Z)⊢(p,011,AZ)⊢(q,011,AZ)}$
      No further steps possible.
   3. ${\displaystyle (p,0011,Z)⊢(p,011,AZ)⊢(p,11,AAZ)⊢(q,11,AAZ)⊢(q,1,AZ)⊢(q,ϵ,Z)⊢(r,ϵ,Z)}$
      Accepting computation: ends in accepting state, while complete input has been read.
2. Input string = 00111. Again there are various computations. None of these is accepting.
   1. ${\displaystyle (p,00111,Z)⊢(q,00111,Z)⊢(r,00111,Z)}$
      The final state is accepting, but the input is not accepted this way as it has not been read.
   2. ${\displaystyle (p,00111,Z)⊢(p,0111,AZ)⊢(q,0111,AZ)}$
      No further steps possible.
   3. ${\displaystyle (p,00111,Z)⊢(p,0111,AZ)⊢(p,111,AAZ)⊢(q,111,AAZ)⊢(q,11,AZ)⊢(q,1,Z)⊢(r,1,Z)}$
      The final state is accepting, but the input is not accepted this way as it has not been (completely) read.

Context-free languages

Every context-free grammar can be transformed into an equivalent nondeterministic pushdown automaton. The derivation process of the grammar is simulated in a leftmost way. Where the grammar rewrites a nonterminal, the PDA takes the topmost nonterminal from its stack and replaces it by the right-hand part of a grammatical rule (expand). Where the grammar generates a terminal symbol, the PDA reads a symbol from input when it is the topmost symbol on the stack (match). In a sense the stack of the PDA contains the unprocessed data of the grammar, corresponding to a pre-order traversal of a derivation tree.

Technically, given a context-free grammar, the PDA has a single state, 1, and its transition relation is constructed as follows.

1. ${\displaystyle (1,\epsilon ,A,1,\alpha )}$ for each rule ${\displaystyle A\to \alpha }$ (expand)
2. ${\displaystyle (1,a,a,1,\epsilon )}$ for each terminal symbol ${\displaystyle a}$ (match)

The PDA accepts by empty stack. Its initial stack symbol is the grammar's start symbol.

For a context-free grammar in Greibach normal form, defining (1,γ) ∈ δ(1,a,A) for each grammar rule A → aγ also yields an equivalent nondeterministic pushdown automaton.

The converse, finding a grammar for a given PDA, is not that easy. The trick is to code two states of the PDA into the nonterminals of the grammar.

Theorem. For each pushdown automaton ${\displaystyle M}$ one may construct a context-free grammar ${\displaystyle G}$ such that ${\displaystyle N(M)=L(G)}$.

The language of strings accepted by a deterministic pushdown automaton (DPDA) is called a deterministic context-free language. Not all context-free languages are deterministic. As a consequence, the DPDA is a strictly weaker variant of the PDA. Even for regular languages, there is a size explosion problem: for any recursive function ${\displaystyle f}$ and for arbitrarily large integers ${\displaystyle n}$, there is a PDA of size ${\displaystyle n}$ describing a regular language whose smallest DPDA has at least ${\displaystyle f(n)}$ states. For many non-regular PDAs, any equivalent DPDA would require an unbounded number of states.

A finite automaton with access to two stacks is a more powerful device, equivalent in power to a Turing machine. A linear bounded automaton is a device which is more powerful than a pushdown automaton but less so than a Turing machine.

Turing machines

A pushdown automaton is computationally equivalent to a "restricted" Turing Machine (TM) with two tapes, which is restricted in the following manner. On the first tape, the TM can only read the input and move from left to right (i.e., it cannot make changes). On the second tape, it can only "push" and "pop" data; i.e., the TM can read, write, and move left and right on the second tape, with the restriction that the only action it can perform at each step is to either delete the left-most character in the string (pop) or add an extra character left to the left-most character in the string (push).

That a PDA is weaker than a TM can be boiled down to the fact that the "pop" procedure deletes some data. In order to make a PDA as strong as a TM, we need to save this lost data somewhere; this can be achieved by introducing a second stack. In the aforementioned TM model of pushdown automata, this is equivalent to a TM with three tapes, wherein the first tape is the read-only input tape, and both the second and third tapes are "push" and "pop" (stack) tapes. In order for such a PDA to simulate any given TM, we give the input of the PDA to the first tape, while keeping both the stacks empty; it then goes on to push all the input from the input tape onto the first stack. When the entire input is transferred to the first stack, operation proceeds as in a normal TM: moving right on the tape is the same as popping a symbol from the first stack and pushing a (possibly updated) symbol onto the second stack, and moving left corresponds to popping a symbol from the second stack and pushing a (possibly updated) symbol onto the first stack—hence, we now have a two-stack PDA that can simulate any TM.

Generalization

A generalized pushdown automaton (GPDA) is a PDA that writes an entire string of some known length to the stack or removes an entire string from the stack in one step.

A GPDA is formally defined as a 6-tuple:

${\displaystyle M=(Q,\mathrm{\Sigma },\mathrm{\Gamma },\delta ,q_0,F)}$

where ${\displaystyle Q,\mathrm{\Sigma },\mathrm{\Gamma },q_0}$, and ⁠${\displaystyle F}$⁠ are defined the same way as a PDA.

${\displaystyle \delta }$: ${\displaystyle Q\times {\mathrm{\Sigma }}_{ϵ}\times {\mathrm{\Gamma }}^{\ast }⟶P(Q\times {\mathrm{\Gamma }}^{\ast })}$

is the transition function.

Computation rules for a GPDA are the same as a PDA except that the ${\displaystyle a_{i+1}}$'s and ${\displaystyle b_{i+1}}$'s are now strings instead of symbols.

Pushdown automata and generalized pushdown automata are equivalent in that if a language is recognized by a PDA, it is also recognized by a GPDA, and vice versa.

One can formulate an analytic proof for the equivalence of pushdown automata and generalized pushdown automata using the following simulation:

Let ${\displaystyle \delta (q_1,w,x_1{x}_2\cdot x_m)⟶(q_2,y_1{y}_2...y_n)}$ be a transition of the GPDA, where:

${\displaystyle q_1,q_2\in Q,w\in {\mathrm{\Sigma }}_{ϵ},x_1,x_2,\dots ,x_m\in {\mathrm{\Gamma }}^{\ast },m\ge 0,y_1,y_2,\dots ,y_n\in {\mathrm{\Gamma }}^{\ast },n\ge 0}$

Construct the following transitions for the PDA:

${\displaystyle \begin{array}{lcl}{\delta }^{\prime }(q_1,w,x_1)& ⟶& (p_1,ϵ)\\ {\delta }^{\prime }(p_1,ϵ,x_2)& ⟶& (p_2,ϵ)\\ & ⋮& \\ {\delta }^{\prime }(p_{m-1},ϵ,x_m)& ⟶& (p_m,ϵ)\\ {\delta }^{\prime }(p_m,ϵ,ϵ)& ⟶& (p_{m+1},y_n)\\ {\delta }^{\prime }(p_{m+1},ϵ,ϵ)& ⟶& (p_{m+2},y_{n-1})\\ & ⋮& \\ {\delta }^{\prime }(p_{m+n-1},ϵ,ϵ)& ⟶& (q_2,y_1).\end{array}}$

Stack automata

As a generalization of pushdown automata, Ginsburg, Greibach, and Harrison (1967) investigated stack automata, which may additionally step left or right in the input string (surrounded by special endmarker symbols to prevent slipping out), and step up or down in the stack in read-only mode. A stack automaton is called nonerasing if it never pops from the stack. The class of languages accepted by nondeterministic, nonerasing stack automata is NSPACE(n²), which is a superset of the context-sensitive languages. The class of languages accepted by deterministic, nonerasing stack automata is DSPACE(n⋅log(n)).

Alternating pushdown automata

An alternating pushdown automaton (APDA) is a pushdown automaton with a state set

• ${\displaystyle Q=Q_{\mathrm{\exists }}\cup Q_{\mathrm{\forall }}}$ where ${\displaystyle Q_{\mathrm{\exists }}\cap Q_{\mathrm{\forall }}=\mathrm{\varnothing }}$.

States in ${\displaystyle Q_{\mathrm{\exists }}}$ and ${\displaystyle Q_{\mathrm{\forall }}}$ are called existential resp. universal. In an existential state an APDA nondeterministically chooses the next state and accepts if at least one of the resulting computations accepts. In a universal state APDA moves to all next states and accepts if all the resulting computations accept.

The model was introduced by Chandra, Kozen and Stockmeyer. Ladner, Lipton and Stockmeyer proved that this model is equivalent to EXPTIME i.e. a language is accepted by some APDA if, and only if, it can be decided by an exponential-time algorithm.

Aizikowitz and Kaminski introduced synchronized alternating pushdown automata (SAPDA) that are equivalent to conjunctive grammars in the same way as nondeterministic PDA are equivalent to context-free grammars.