VISVESVARAYA TECHNOLOGICAL UNIVERSITY

JNANA SANGAMA, BELAGAVI-590018

THEORY OF COMPUTATIONS (BCS503)

Report on

“Non-Deterministic Pushdown Automata”

Submitted by

CHIRAYU SHARMA G K 1BI22IS021

DEEKSHA S KASHYAP 1BI22IS022
DHANUSH MADESH 1BI22IS023
DHARSHAN D 1BI22IS024

Under the Guidance of

Prof. Chikka Krishnappa T K
Assistant Professor

Department of ISE

BIT, Bangalore

DEPARTMENT OF INFORMATION SCIENCE & ENGINEERING

BANGALORE INSTITUTE OF TECHNOLOGY
K R Road, V.V Puram, Bengaluru-560004
2024-2025
 TABLE OF CONTENTS

CHAPTER NO. CONTENT PAGE NO.

1 INTRODUCTION 1

2 JFLAP 8

3 NON-DETERMINISTIC PUSHDOWN AUTOMATA 11

4 RESULTS 13

5 APPLICATIONS 15

6 CONCLUSION 16
 THEORY OF COMPUTATION (BCS503)
(
CHAPTER 1
INTRODUCTION

1.1 Introduction
A Pushdown Automaton (PDA) is a theoretical computational model used to recognize context-
free languages, which are a class of languages generated by context-free grammars. It extends the
capabilities of a finite automaton by incorporating a stack, a memory structure that operates on the
Last-In-First-Out (LIFO) principle. A PDA consists of states, an input alphabet, a stack alphabet,
and transition rules. These rules dictate how the automaton reads symbols from the input,
transitions between states, and performs stack operations like pushing, popping, or leaving the
stack unchanged. This stack gives the PDA the ability to handle nested structures, making it
powerful enough to process languages like those used in programming languages or mathematical
expressions that finite automata cannot handle.

Key Features of a PDA

1. States: A PDA has a finite set of states that represent various configurations during
computation.
2. Input Alphabet (Σ\Sigma): The set of symbols that the PDA can read from its input tape.
3. Stack Alphabet (Γ\Gamma): The set of symbols that can be stored in the stack, used for
tracking nested relationships.
4. Stack Operations: The PDA uses three types of stack operations:
• Push: Add a symbol to the top of the stack.
• Pop: Remove the top symbol from the stack.
• No Operation (No-Op): Leave the stack unchanged.
5. Transition Function (δ\delta): Determines the PDA’s behaviour based on:
• The current state.
• The current input symbol (or ε, meaning no input is read).
• The symbol at the top of the stack.
• It specifies the next state, the symbol to push onto or pop from the stack, and
whether to consume an input symbol.

Dept of ISE, BIT 2023-2024 1

 THEORY OF COMPUTATION (BCS503)
(
6. Start State: The initial state where the PDA begins computation.
7. Accept States: The set of states where, if reached with an empty stack or a specific
configuration, the PDA accepts the input.

Working of a PDA
• A PDA reads its input string symbol by symbol and uses its stack to keep track of additional
information.
• For each input symbol, the PDA consults its transition function to decide:
• The next state to move to.
• What to do with the stack (push, pop, or no operation).
• Whether to consume an input symbol or not.

Acceptance Criteria
A PDA can accept an input string in two ways:
1. Final State Acceptance: The PDA accepts the string if it ends in an accepting state after
reading the input.
2. Empty Stack Acceptance: The PDA accepts the string if the stack is empty at the end of
input processing.

Example Language
A classic example of a context-free language is L= {anbn | n≥0}, where the number of a's must
equal the number of b's. A PDA can recognize this language by pushing a's onto the stack and
popping them for each b read, ensuring the numbers match.
PDAs provide a foundation for understanding formal language theory, context-free grammars, and
the design of parsers in computer science.

1.2 Types of PDA

Pushdown Automata (PDA) are categorized based on their acceptance criteria and their transition
capabilities. The types of PDA are as follows:

1. Deterministic Pushdown Automata (DPDA)

Dept of ISE, BIT 2023-2024 2

 THEORY OF COMPUTATION (BCS503)
(
A Deterministic Pushdown Automaton has at most one possible action for each combination of
input symbol, current state, and stack top. This means it cannot have:
• Multiple transitions for the same input, state, and stack symbol.
• ε-transitions (transitions that occur without consuming an input symbol) that introduce
ambiguity.
Key Characteristics:
• DPDAs are used to recognize deterministic context-free languages (DCFLs), which are a
strict subset of context-free languages.
• They are less powerful than non-deterministic PDAs.
Example: Languages like L={anbn∣n≥0} are recognized by a DPDA.

2. Non-Deterministic Pushdown Automata (NPDA)

A Non-Deterministic Pushdown Automaton can have multiple possible transitions for the same
input, state, and stack top. It can also use ε -transitions, where it changes states or performs stack
operations without consuming any input symbol.
Key Characteristics:
• NPDAs can recognize all context-free languages (CFLs).
• They are more powerful than DPDAs because they allow ambiguity and multiple choices
during computation.
• Practical implementations often simulate non-determinism by exploring all possible
computation paths.
Example: Languages like L= {ambncm | m, n≥0}, which are inherently non-deterministic, require
an NPDA.

3. Single-Stack vs. Multi-Stack PDAs

• Single-Stack PDA: Most PDAs use a single stack for computation and are sufficient for
recognizing context-free languages.

• Multi-Stack PDA: If a PDA is allowed to have multiple stacks, its computational power
increases, making it equivalent to a Turing machine, capable of recognizing recursively
enumerable languages.

Dept of ISE, BIT 2023-2024 3

 THEORY OF COMPUTATION (BCS503)
(
4. Acceptance-Based Types
PDAs can also be categorized based on how they accept input strings:
1. Acceptance by Final State: The PDA accepts the input if it reaches an accepting state after
processing the input.
2. Acceptance by Empty Stack: The PDA accepts the input if the stack becomes empty after
processing the input.
Both acceptance criteria are equivalent in terms of recognizing context-free languages, but the
specific design of the PDA may vary.

1.3 Comparison of DPDA and NDPA

Feature DPDA NDPA

At most one per
TRANSITIONS Multiple possible transitions
state/input/stack
ε- TRANSITIONS Generally, not allowed Allowed
LANGUAGE
Deterministic CFLs All CFLs
RECOGNITION
POWER Less powerful More powerful

1.4 Applications

Pushdown Automata (PDA) are a foundational concept in theoretical computer science and have
several practical and theoretical applications. Their primary significance lies in their ability to
model systems and processes involving hierarchical or nested structures, which are common in
various domains.

1.4.1 Practical Applications of PDA

1. Parsing in Compilers:
• PDAs are used in the syntax analysis phase of compilers to check whether a given
program conforms to the syntax of a programming language.
• Deterministic PDAs (DPDAs) are commonly used in parser generators like LL and
LR parsers, which are essential for context-free grammar parsing.

Dept of ISE, BIT 2023-2024 4

 THEORY OF COMPUTATION (BCS503)
(
2. Modelling Context-Free Languages:
• PDAs can recognize and process languages generated by context-free grammars
(CFLs), such as arithmetic expressions, programming language constructs, and
balanced parentheses.
3. XML and HTML Parsing:
• Hierarchical structures in markup languages like XML and HTML can be validated
using PDAs, ensuring proper nesting of tags.
4. Expression Evaluation:
• PDAs are useful in evaluating arithmetic expressions, especially those involving
nested operations (e.g., infix to postfix conversion or expression evaluation).
5. Pushdown Systems in Verification:
• PDAs are used in formal verification to model software systems with recursive
procedures or nested calls.
6. Language Recognition:
• PDAs recognize various context-free languages like palindromes, balanced
parentheses, and more, which are common in formal language analysis.

1.4.2 Theoretical Applications of PDA

1. Automata Theory:
• PDAs serve as a bridge between finite automata and Turing machines, helping
understand the hierarchy of computational power in automata.
• They provide insights into the relationship between context-free grammars and
context-free languages.
2. Understanding Computational Limits:
• PDAs help illustrate the limitations of finite automata and highlight the additional
power gained by using a stack for memory.
3. Foundation of Context-Free Grammar (CFG):
• PDAs are intrinsically linked to CFGs, offering a machine-based perspective on the
derivation of strings in these grammars.
4. Recursive Processes:
• They model recursive systems and processes, providing a theoretical framework
for understanding recursion in computation.
Dept of ISE, BIT 2023-2024 5
 THEORY OF COMPUTATION (BCS503)
(
1.4.3 Real-Life Example Scenarios
1. Balanced Parentheses Checker:
• Language L= {anbn | n≥0} (e.g., matching numbers of open and close brackets).
2. Arithmetic Expression Parsing:
• Validating expressions like (a+b) × c (a + b), ensuring proper operation precedence
and parenthesis placement.
3. Syntax Checking in Code:
• Ensuring that constructs like loops and conditional statements have matching start
and end blocks.

1.4.4 Limitations of PDA

1. Limited Memory: Single Stack
• PDAs use a single stack for memory, which restricts their ability to manage multiple
independent pieces of information simultaneously.
• As a result, they cannot recognize languages requiring multiple levels of memory or
relationships beyond simple nested structures.
Example of a Language They Cannot Recognize: L= {anbncn | n≥0}, where the numbers of a, b,
and c must all match. This language requires two stacks or equivalent memory, which PDAs cannot
handle.
2. Inability to Recognize Context-Sensitive or Non-Context-Free Languages
• PDAs are strictly limited to recognizing context-free languages (CFLs). They cannot
process context-sensitive languages, which require additional constraints beyond simple
nesting.
• For instance, languages where the rules depend on the surrounding context, such as L=
{ww ∣ w ∈ Σ *}, are beyond the scope of PDAs.
3. No Random Access Memory
• PDAs operate on a stack that uses Last-In-First-Out (LIFO) access. They cannot access
arbitrary elements within the stack or input, limiting their ability to model systems
requiring random or sequential memory access.

4. Deterministic PDA (DPDA) Limitations

Dept of ISE, BIT 2023-2024 6

 THEORY OF COMPUTATION (BCS503)
(
• Deterministic PDAs are even more restricted, as they cannot use non-determinism to
explore multiple computation paths. This means DPDAs can recognize only deterministic
context-free languages (DCFLs), a strict subset of CFLs.
Example: A DPDA cannot recognize L= {w ∈ {a, b} * | w=wR}, the language of palindromes over
a and b.

5. Inability to Model Unbounded Dependencies

• PDAs cannot handle languages or problems that require tracking unbounded dependencies
that are not naturally nested.
Example: In natural language processing, some languages exhibit cross-serial dependencies that
PDAs cannot model.

6. Non-Determinism is Hard to Simulate

• While non-deterministic PDAs (NPDAs) are more powerful, their non-determinism makes
them impractical for direct implementation. Simulating an NPDA with a DPDA or any
deterministic model is computationally expensive and often infeasible.

7. Stack Cannot Be Used for Complex Arithmetic

• The stack in PDAs is limited to pushing, popping, and reading the top element. It cannot
perform arithmetic or store complex structures without external computation.

Dept of ISE, BIT 2023-2024 7

 THEORY OF COMPUTATION (BCS503)
(
CHAPTER 2
JFLAP

2.1 Introduction

JFLAP is a software tool primarily used for experimenting with formal languages and automata,
including finite automata, pushdown automata, and Turing machines. It is developed at Duke
University and is freely available for educational and research purposes. JFLAP provides a user-
friendly interface for designing, simulating, and testing various automata and grammars, making it
a valuable resource for students, educators, and researchers in the field of theoretical computer
science.

Figure 2.1 JFLAP Dialogue Box

2.2 Key Features of JFLAP

Graphical User Interface (GUI): JFLAP offers an intuitive graphical interface that allows users
to construct and manipulate automata and grammars easily. Users can create finite automata,
regular expressions, context-free grammars, and other formal language constructs using drag-and-
drop functionality.

Dept of ISE, BIT 2023-2024 8

 THEORY OF COMPUTATION (BCS503)
(
Automata Construction: JFLAP supports the creation of various types of automata, including
deterministic finite automata (DFAs), nondeterministic finite automata (NFAs), Mealy machines,
Moore machines, pushdown automata (PDAs), and Turing machines. Users can define states,
transitions, input output symbols, and other properties of automata using the graphical interface.

Simulation and Testing: JFLAP enables users to simulate the behavior of automata and grammars
by providing interactive tools for inputting strings and observing the execution of automata. Users
can test strings against automata and observe the sequence of states visited during the execution.
This feature helps users understand the operation of automata and verify their correctness.

Conversion and Equivalence Checking: JFLAP supports conversion between different types of
automata and grammars. Users can convert DFAs to equivalent NFAs, regular expressions to
NFAs, context-free grammars to PDAS, and vice versa. Additionally, JFLAP provides tools for
checking the equivalence of automata and grammars, helping users validate their designs and
implementations.

Algorithm Visualization: JFLAP includes visualizations of algorithms for automata and

grammars, such as algorithms for minimizing DFAS, converting NFAs to DFAs, and constructing
parse trees from input strings. These visualizations help users understand the underlying algorithms
and concepts by providing step-by-step demonstrations.

Export and Import: JFLAP allows users to export their automata and grammars in various
formats. including plain text, XML, and image files. This feature enables users to share their
designs with others or integrate them into documentation and presentations. JFLAP also supports
importing automata and grammars from external files, facilitating collaboration and reuse of
existing designs.

2.3 Usage of JFLAP

Education: JFLAP is widely used in academic settings for teaching formal languages and automata
theory courses. It provides students with hands-on experience in designing and analyzing automata
and grammars, reinforcing theoretical concepts with practical exercises.

Dept of ISE, BIT 2023-2024 9

 THEORY OF COMPUTATION (BCS503)
(
Research: JFLAP serves as a valuable tool for researchers in theoretical computer science and
related fields. Researchers can use JFLAP to prototype and experiment with new algorithms,
conduct simulations, and validate their findings through interactive experimentation.

Self-Study: JFLAP is also used by individuals for self-study and self-paced learning of formal
languages and automata theory. The interactive nature of JFLAP allows users to explore concepts
at their own pace, experiment with different designs, and gain insights into the behavior of automata
and grammars.

Figure 2.2 Running of Finite Automata in JFLAP

Dept of ISE, BIT 2023-2024 10

 THEORY OF COMPUTATION (BCS503)
(
CHAPTER 3

NON-DETERMINISTIC PUSHDOWN AUTOMATA

A Non-deterministic Pushdown Automaton (NPDA) is a computational model used to recognize
context-free languages, a subset of formal languages. It extends the concept of a finite automaton
by incorporating a stack as an auxiliary memory structure, allowing it to handle a broader range of
languages.

3.1 Components of Non-Deterministic Pushdown Automata

An NPDA is defined as a 7-tuple:

M= (Q, Σ, Γ, δ, q0, Z0, F)
where:
1. Q: A finite set of states.
2. Σ: The input alphabet (finite set of symbols the automaton reads).
3. Γ: The stack alphabet (finite set of symbols the stack can hold).
4. δ: The transition function, defined as:
δ: Q × (Σ ∪ {ϵ}) × Γ → P (Q × Γ*)
This means the automaton, given a current state, an input symbol (or no input, represented
by ϵ), and the top stack symbol, can transition to a set of possible states while replacing the
top of the stack with a string of symbols.
5. q0: The initial state (q0 ∈ Q).
6. Z0: The initial stack symbol (Z0 ∈ Γ), initially placed in the stack.
7. F: A set of accept states (F ⊆ Q).

3.2 State Diagram

A PDA is said to be non-deterministic if one transition has more than one move.
It can be done in two ways:
1. If two or more edges labeled with same input and stack symbols.
2. When a state has two edges with same stack symbol and one of the input symbols is 𝜀.

Dept of ISE, BIT 2023-2024 11

 THEORY OF COMPUTATION (BCS503)
(

Figure 3.1 Same Input and Stack Symbols Figure 3.2 One Input Symbol is 𝜺

EXAMPLE:

Figure 3.3 State Diagram in JFLAP

The above Figure 3.3 is the state diagram for the language L = {anbn | n ≥ 0}

Dept of ISE, BIT 2023-2024 12

 THEORY OF COMPUTATION (BCS503)
(
CHAPTER 4
RESULTS

Figure 4.1 State Diagram for Palindrome Sequence

Figure 4.2 Multiple Run Tests to check if String is Palindrome directly

Figure 4.3 Steps by Closure to check each transition

Dept of ISE, BIT 2023-2024 13
 THEORY OF COMPUTATION (BCS503)
(

Figure 4.4 Final answer after going through each state

Figure 4.5 Fast run of String showing transitions

Dept of ISE, BIT 2023-2024 14

 THEORY OF COMPUTATION (BCS503)
(
CHAPTER 5
APPLICATIONS
1. Context-Free Language Recognition
• NPDAs are used to recognize context-free languages (CFLs), which are generated by
context-free grammars (CFGs).
• Many programming languages have context-free components, such as balanced
parentheses, nested structures, and syntactically valid expressions.
2. Parsing in Compilers
• NPDAs can be used conceptually to parse expressions in programming languages.
• They form the theoretical basis for parsing algorithms, such as LL and LR parsers, which
are implemented in compilers to check syntactic correctness.
3. String Matching with Context-Free Constraints
• NPDAs are useful in scenarios where a string needs to be validated against complex patterns
involving nesting or recursion, such as matching balanced parentheses, XML tags, or nested
function calls.
4. Modelling Natural Languages
• Some aspects of natural language syntax can be modelled using NPDAs, as natural
languages often exhibit context-free structures (e.g., nested subordinate clauses).
5. Grammar Verification and Language Processing
• Verifying if a CFG can generate a particular language.
• Processing languages with ambiguous grammars, where multiple parsing paths need to be
considered simultaneously.
6. Simulation of Ambiguous Scenarios
• NPDAs can model systems where decisions are not deterministic, such as multi-threaded
processes or non-deterministic algorithms.
7. Theoretical Computer Science Education
• NPDAs are used to teach and understand the differences between deterministic and non-
deterministic computation.
• They help in understanding the Chomsky hierarchy and the relationships between different
classes of languages.

Dept of ISE, BIT 2023-2024 15

 THEORY OF COMPUTATION (BCS503)
(
CHAPTER 6
CONCLUSION
In conclusion, Non-Deterministic Pushdown Automata (NPDAs) serve as a powerful theoretical
model for recognizing context-free languages and understanding the complexities of nested and
recursive structures in computation. They find applications in parsing, grammar verification, and
modelling natural language syntax, providing foundational insights for compilers and automated
language processing. Despite their theoretical nature and the practical preference for deterministic
systems, NPDAs offer significant value in exploring non-deterministic computation, ambiguity
handling, and the study of computational hierarchies. Their role in theoretical computer science
continues to shape our understanding of formal languages and automata.

Dept of ISE, BIT 2023-2024 16