Two-stack Pushdown Automata and Turing Machine

---

---

A traditional Pushdown Automaton has one stack, but there could be some variations. We can also have a two-stack pushdown automaton. Both are powerful computational models, but they differ in their structure and capabilities.

In this chapter, we will explain the basics of these models, and their key features with examples to present a clear understanding of how they work.

Basics of Two-stack Pushdown Automata

A Pushdown Automaton is a computational model similar to a finite automaton but with an added stack. The stack provides the machine with additional memory. These are used for recognizing context-free languages.

However, a standard PDA has limitations, particularly when it comes to languages that require more complex memory management. We can put another stack to make two-stack PDA. Take a look at the following block diagram −

Key Features of Two-stack Pushdown Automata

Following are some of the key features of two-stack pushdown automata −

• Two Stacks − Unlike a standard PDA, which has only one stack, a two-stack PDA has two stacks. This dual-stack setup allows it to simulate a Turing machine, making it more powerful than a single-stack PDA.
• Memory Management − With two stacks, the PDA can store and manage more complex information, enabling it to recognize languages that a standard PDA cannot.
• Deterministic and Non-deterministic − A two-stack PDA can be either deterministic or non-deterministic, but it is the non-deterministic version that fully captures the power of a Turing machine.

How Does a Two-Stack Pushdown Automata Work?

In a two-stack PDA, the machine uses one stack to push and pop symbols while the other stack performs similar operations. The interaction between these two stacks enables the PDA to keep track of more complex structures, such as nested sequences or multiple dependencies, which are common in context-sensitive languages.

Comparison with Turing Machine

The Turing Machine is most powerful computational model that can simulate any algorithm. It consists of an infinite tape, a tape head that reads and writes symbols on the tape, and a finite state control that dictates the machine's operations based on the current state and the symbol under the tape head.

Relationship between Two-stack PDA and Turing Machine

A Two-Stack PDA and Turing Machines are computationally equivalent that we can prove. A PDA is similar to FSM, but it has an additional memory, a stack, to help it recognize strings. If a PDA has more than one stack, we can call it a Turing machine.

Simulation − A two-stack PDA can simulate a Turing machine by using one stack to represent the portion of the tape to the left of the head and the other stack to represent the portion to the right.

Components of Two-stack PDA

A two-stack PDA is defined by a 9-tuple: $\mathrm{M \:=\: (Q,\: \Sigma,\: \Gamma,\: \Gamma',\: \delta,\: q0,\: z1,\: z2,\: F)}$

• Q − All the states the PDA can be in
• Σ − The input alphabet (symbols it can read)
• Γ − The alphabet for the first stack
• Γ' − The alphabet for the second stack
• δ − Rules for moving between states and using the stacks
• q0 − The starting state
• z1 − The bottom symbol for the first stack
• z2 − The bottom symbol for the second stack
• F − The final or accepting states

Example: Recognizing $\mathrm{\{a^{n} b^{n} c^{n} \: |\:n\: \geq\: 0\}}$

Let's see how a two-stack PDA can handle the language $\mathrm{\{a^{n} b^{n} c^{n} \: |\:n\: \geq\: 0\}}$. This language has equal numbers of a's, b's, and c's in that order. Which is not solvable by one stack PDA, but can be solvable by Turing Machines.

Strategy − Here's how we'll use our two stacks −

• While reading 'a', we'll push 'X' into stack 1.
• While reading 'b', we'll push 'Y' into stack 2.
• While reading 'c', we'll pop 'X' from stack 1 and 'Y' from stack 2.
• If both stacks are empty at the end, we accept the string.

Transition Functions − Here are the transition functions −

$$\mathrm{\delta(q0,\: \lambda,\: z1,\: z2)\: \rightarrow \:(qf,\: z1,\: z2)}$$

$$\mathrm{\delta(q0,\: a,\: z1,\: z2)\: \rightarrow \:(q0,\: Xz1,\: z2)}$$

$$\mathrm{\delta(q0,\: a,\: X,\: z2)\: \rightarrow \:(q0,\: XX,\: z2)}$$

$$\mathrm{\delta(q0,\: b,\: X,\: z2)\: \rightarrow \:(q0,\: X,\: Yz2)}$$

$$\mathrm{\delta(q0,\: b,\: X,\: Y)\: \rightarrow \:(q0,\: X,\: YY)}$$

$$\mathrm{\delta(q0,\: c,\: X,\: Y)\: \rightarrow \:(q1,\: \lambda,\: \lambda)}$$

$$\mathrm{\delta(q1,\: c,\: X,\: Y)\: \rightarrow \:(q1,\: \lambda,\: \lambda)}$$

$$\mathrm{\delta(q1,\: \lambda,\: z1,\: z2)\: \rightarrow \:(qf,\: z1,\: z2)}$$

Explanation of Transitions

• The first line handles the case of an empty input string.
• The next two lines handle reading 'a' and pushing 'X' to stack 1.
• The fourth and fifth lines handle reading 'b' and pushing 'Y' to stack 2.
• The sixth and seventh lines handle reading 'c' and popping from both stacks.
• The last line checks if we have finished the string with empty stacks.

Conclusion

In this chapter, we explained the concept of two-stack pushdown automata and Turing Machines. A two-stack PDA has more power because it can recognize all context-free languages, just like a regular PDA. In addition, a two-stack PDA can also recognize some context-sensitive languages, which regular PDAs cannot. Two-stack PDAs are equivalent to Turing machines! This means they can compute anything that is computable.