Define the following terms and give an example of each : Automata, String,

Language, Alphabet, Grammar

Write a short note on Regular Expressions.
Limitations of FA
What are Moore and Mealy machines?

Differentiate between Moore machine and Mealy

. Distinguish between NFA and DFA

Write short note on reduced DFA.

What do you mean by ambiguous grammar?

Define CFG,
Write a short note on Chomsky hierarchy
Define DFA

Define Chomsky Normal Form

Compare and Contrast between FA, PDA and TM.
Model of PDA
Simplification of Grammer
Power and limitations of PDA

Turing Machine
Applications of all Machines

Write a short note on Variants of TM.

Write a short note on Halting Problem

The Halting Problem is a key concept in computer science introduced by Alan Turing in
1936. It asks whether there exists an algorithm that can determine if any given program will
halt (stop running) or run indefinitely when given a specific input. Turing proved that such a
universal algorithm cannot exist, making the Halting Problem undecidable. This means there
are limits to what can be computed algorithmically, highlighting that some problems cannot
be solved by any algorithm. The Halting Problem is fundamental in understanding the
theoretical boundaries of computation.

Power and limitations of FA, PDA, and TM

Finite Automata (FA), Pushdown Automata (PDA), and Turing Machines (TM) are
fundamental models of computation in theoretical computer science. Each has distinct
capabilities and limitations.

Finite Automata (FA)

Power:

• Regular Languages: FA can recognize exactly the class of regular languages. These
are languages that can be described by regular expressions or finite sets of rules.
• Simple Pattern Matching: They are efficient for tasks involving simple pattern
matching, lexical analysis, and text processing.
• Deterministic and Nondeterministic FA (DFA and NFA): Both DFA and NFA are
equivalent in terms of the languages they can recognize, although NFA can be more
succinct.

Limitations:

• Memory Limitation: FA have a finite amount of memory in the form of states. They
cannot count or store an arbitrary amount of information.
• Inability to Handle Context-Free Languages: FA cannot recognize languages that
require matching nested structures, such as balanced parentheses.
Pushdown Automata (PDA)

Power:

• Context-Free Languages: PDA can recognize the class of context-free languages

(CFLs), which includes many programming languages' syntax.
• Stack Memory: PDAs have a stack that provides additional memory beyond the
finite states, allowing them to handle nested structures.
• Deterministic and Nondeterministic PDA (DPDA and NPDA): NPDAs are more
powerful than DPDAs in terms of the languages they can recognize, as deterministic
PDAs cannot recognize all CFLs.

Limitations:

• Single Stack Limitation: PDAs use a single stack, which limits their ability to handle
more complex languages.
• Inability to Recognize Context-Sensitive Languages: PDAs cannot recognize
languages that require more than a single stack's worth of memory.

Turing Machines (TM)

Power:

• Turing-Recognizable Languages: TMs can recognize a broader class of languages,

known as recursively enumerable languages. This includes all languages that a PDA
can recognize and more.
• Simulating Algorithms: TMs can simulate any algorithm and are equivalent to what
we consider as computable by a modern computer (given infinite time and space).
• Variants: There are many variants of TMs (e.g., multi-tape TMs, nondeterministic
TMs), but they are all equivalent in terms of the class of languages they can
recognize.

Limitations:

• Decidability: Not all languages are decidable by a TM. Some problems (e.g., the
Halting Problem) cannot be solved by any TM.
• Physical Constraints: While TMs have infinite tape theoretically, real computers
have finite memory and cannot implement a TM with truly infinite resources.
• Complexity: TMs may be impractical for some tasks due to time or space constraints,
even if they are theoretically capable of solving them.

Summary

• FA are limited to recognizing regular languages and are constrained by their finite
state memory.
• PDA extend the capabilities of FA with a stack, allowing them to recognize context-
free languages but are still limited to single-stack memory.
 • TM are the most powerful, capable of recognizing a broad class of languages
(recursively enumerable languages) and simulating any algorithm, but they face
limitations in decidability and practical implementation constraints.

Closure properties of regular language and CFL

Closure Properties of Regular Languages

Regular languages are closed under the following operations, meaning that performing these
operations on regular languages results in a language that is also regular:

1. Union: If 𝐿1 L1 and 𝐿2 L2 are regular languages, then 𝐿1∪𝐿2 L1∪L2 is also regular.
2. Intersection: If 𝐿1 L1 and 𝐿2 L2 are regular languages, then 𝐿1∩𝐿2 L1∩L2 is also
regular.
3. Complementation: If 𝐿L is a regular language, then its complement 𝐿bar is also
regular.
4. Difference: If 𝐿1L1 and 𝐿2L2 are regular languages, then 𝐿1−𝐿2 L1−L2 (or 𝐿1∖𝐿2L1
∖L2) is also regular.
5. Concatenation: If 𝐿1L1 and 𝐿2L2 are regular languages, then 𝐿1𝐿2L1L2 (the
concatenation of 𝐿1L1 and 𝐿2L2) is also regular.
6. Kleene Star: If 𝐿L is a regular language, then 𝐿∗L∗ (the Kleene star of 𝐿L) is also
regular.
7. Reversal: If 𝐿L is a regular language, then the reverse of 𝐿L is also regular.
8. Homomorphism: If 𝐿L is a regular language and ℎh is a homomorphism, then
ℎ(𝐿)h(L) is also regular.
9. Inverse Homomorphism: If 𝐿L is a regular language and ℎh is a homomorphism,
then ℎ−1(𝐿)h−1(L) is also regular.

Closure Properties of Context-Free Languages (CFLs)

Context-free languages have the following closure properties:

1. Union: If 𝐿1L1 and 𝐿2L2 are context-free languages, then 𝐿1∪𝐿2L1∪L2 is also
context-free.
2. Concatenation: If 𝐿1L1 and 𝐿2L2 are context-free languages, then 𝐿1𝐿2L1L2 (the
concatenation of 𝐿1L1 and 𝐿2L2) is also context-free.
3. Kleene Star: If 𝐿L is a context-free language, then 𝐿∗L∗ (the Kleene star of 𝐿L) is
also context-free.
4. Reversal: If 𝐿L is a context-free language, then the reverse of 𝐿L is also context-free.
5. Homomorphism: If 𝐿L is a context-free language and ℎh is a homomorphism, then
ℎ(𝐿)h(L) is also context-free.
6. Inverse Homomorphism: If 𝐿L is a context-free language and ℎh is a
homomorphism, then ℎ−1(𝐿)h−1(L) is also context-free.

Note: CFLs are not closed under intersection and complementation, which are key
differences from regular languages.
For Phases of compiler see remaining 1 in AT, variants of TM vedio