What it is?
The Pumping Lemma is a property of all regular The pumping lemma of context-free languages tell us that If there was a string long enough to
languages.How is it used? A technique that is used to show that a
given language is not regular Let L be a regular language
This property should hold for all regular languages.
Then there exists some constant N such that for every string w ∈ L s.t.
|w|≥N, there exists a way to break w into three parts, w=xyz, such
that:
1. y≠ ε
2. |xy|≤N
3. For all k≥0, all strings of the form xykz ∈ L
L is regular => it should have a DFA.
4. Set N := number of states in the D FA
5. Any string w∈L, s.t. |w|≥N, should have the form: w=a1a2…am,
where m≥N
6. Let the states traversed after reading the first N symbols be:
{p0,p1,… pN}
7. ==> There are N+1 p-states, while there are only N DFA states
8. ==> at least one state has to repeat
i.e, pi= pJwhere 0≤i<j≤N (by PHP)
2. We should be able to break w=xyz as follows:
1. x=a1a2..ai; y=ai+1ai+2..aJ; z=aJ+1aJ+2..am
2. x’s path will be p0..pi
3. y’s path will be pi pi+1..pJ (but pi=pJ implying a loop)
4. z’s path will be pJpJ+1..pm
3. Now consider another
string wk=xykz , where k≥0
4. Case k=0
1. DFA will reach the accept state pm
5. Case k>0
1. DFA will loop for yk, and finally reach the accept state pm for z
6. In either case, wk∈ L
7. For part (1):
8. Since i<j, y ≠ ε
9. For part (2):
10. By PHP, the repetition of states has to occur within the first N symbols in
w the transition function, meaning that there can be multiple possible next states
11. ==> |xy|≤N
4-DFA
A DeterminisAc Finite Automaton (DFA) is a mathemaAcal model used in
computer science and formal language theory to describe languages
recognized by finite automata. A DFA consists of a finite set of states, an input
alphabet, transiAon rules, an iniAal state, and one or more final states.
5-REGULAR GRAMMAR
In Formal Languages and Automata Theory (FLAT), a regular language is a
language that can be expressed by a regular expression or recognized by a
finite automaton, such as a determinisAc finite automaton (DFA) or a
nondeterminisAc finite automaton (NFA).
Formally, a regular language L over an alphabet Σ is a subset of Σ*, the set of all
possible strings over Σ, which satisfies one of the following equivalent
conditions:
1. L can be generated by a regular grammar.
2. L can be recognized by a finite automaton (DFA, NFA, or ε-NFA).
3. L can be described by a regular expression.
Regular languages are fundamental in computer science, particularly in areas
such as compiler construction, pattern matching, text processing, and formal
language theory. They form the foundation of many important algorithms and
data structures used in software development. Properties of regular languages,
such as closure properties under various operations (union, concatenation,
Kleene closure), are extensively studied in FLAT, contributing to the
understanding of computational complexity and formal language theory.
5-CONTEXT FREE GRAMMAR
A context-free grammar (CFG) is a formal grammar used to generate strings in
a context-free language. It consists of a set of production rules, each defining
how symbols in the grammar can be replaced or expanded into other symbols.
Context-free grammars are widely used in formal language theory,.
Formally, a context-free grammar G is defined as a 4-tuple (V, Σ, R, S), where:
1. V is a finite set of non-terminal symbols (variables).
2. Σ is a finite set of terminal symbols (alphabet), disjoint from V.
3. R is a finite set of production rules, each rule of the form A → α, where A
is a non-terminal symbol and α is a string of symbols from (V ∪ Σ)*,
representing the possible replacements or expansions for A.
4. S is the start symbol, which is a designated non-terminal symbol from V
that serves as the initial symbol for generating strings in the language.
A context-free grammar is called "context-free" because the production rules
apply regardless of the context (surrounding symbols) of the non-terminal being
replaced. This property makes context-free grammars simpler to analyze and
work with compared to grammars with context-sensitive or unrestricted rules.
10 - INSTANTANEOUS DESCRIPTION IN PDA
In a Pushdown Automaton (PDA), an instantaneous description (ID) represents
the current configuration of the automaton at a specific point during its
computation. It provides a snapshot of the state of the PDA, including the contents
of its stack and its current state.
Formally, an instantaneous description for a PDA typically includes the following
components:
1. Current State: The state that the PDA is currently in.
2. Input: The remaining input string that the PDA has yet to process.
3. Stack Contents: The contents of the stack, which may include symbols
pushed onto the stack during the computation.
The combination of these components fully describes the state of the PDA at a
particular step in its operation. The instantaneous description allows for tracking
and understanding how the PDA processes input strings and manipulates its stack
during computation.
During the execution of a PDA, the instantaneous description changes as the
automaton reads input symbols, transitions between states, and manipulates the
stack according to its transition rules. Analyzing the sequence of instantaneous
descriptions provides insight into the behavior and operation of the PDA on
different input strings.
11-MULTITAPE TM BY SINGLE TAPE TM
• Theorem 3.13: Every multitape Turing machine has an equivalent single-
tape Turing machine.
• Simulate an n-tape machine using a one tape machine:
o Store information on all tapes on the single tape.
o Separate information from different tapes using a new symbol (eg
#)
o Use a dotted symbol to represent the location of each tape head
§ When the tape head moves to a location, replace the symbol
there (eg symbol x) with the equivalent dotted symbol (ie with
dotted x)
§ When the tape head moves from a location, write a regular (ie
non-dotted) symbol at that location
§ Requires adding dotted symbols to tape alphabet
o Develop new transition function:
§ A step of the n-tape machine will represent steps on all n of
the parts of the single tape
§ A right movement onto the # results in shifting to the right one
symbol all of the symbols that are to the right of the #
1. REGULAR
cause a cycle (same variable appears more than once in the derivation), then we can always
find two pieces of this sufficiently long string to "pump" in tandem and discover an infinite
sequence of strings that had to be in the language.
That is: if we repeat each of the two pieces the same number of times, we get another string in
the language.
Let L be a CFL.
Then there exists a constant N, s.t.,
• if z ∈L s.t. |z|≥N, then we can write z=uvwxy, such that:
1. |vwx| ≤ N
2. vx≠ε
• For all k≥0: uvkwxky ∈ L
PROOF
If L=Φ or contains only ε, then the lemma is trivially sa>sfied (as
it cannot be violated)
• For any other L which is a CFL:
• Let G be a CNF grammar for L
• Let m = number of variables in G
m • δ is the transition function, which maps Q × (Σ ∪ {ε}) to 2^Q (the power
• Choose N=2 .
• Pick any z ∈ L s.t. |z|≥ N
the parse tree for z should have a height ≥ m+1
(by the parse tree theorem)
6-CONTEXT FREE LANGUAGE
A context-free language is a formal language that can be generated by a
context-free grammar (CFG) or recognized by a non-determinisAc pushdown
automaton (PDA). These languages are a fundamental concept in formal
language theory and computer science.
Formally, a language L is considered context-free if there exists a context-free
grammar G such that L = L(G), where L(G) is the set of all strings generated by
G. Equivalently, a language is context-free if there exists a non-deterministic
pushdown automaton (PDA) that recognizes it.
Context-free languages are widely used in various areas of computer science,
including compiler construction, natural language processing, parsing, and
theoretical computer science. Many programming languages, such as C, Java,
and Python, have syntaxes that can be described using context-free grammars.
7-PUSHDOWN AUTOMATA
A pushdown automaton (PDA) is a type of automaton used in computer science
to recognize context-free languages. It extends the capabilities of finite automata
by adding a stack, allowing it to recognize languages that cannot be described by
finite automata alone.
Formally, a pushdown automaton is a 6-tuple (Q, Σ, Γ, δ, q0, F), where:
1. Q is a finite set of states.
2. Σ is a finite set of input symbols (the alphabet).
3. Γ is a finite set of stack symbols.
4. δ is the transition function, which maps Q × (Σ ∪ {ε}) × Γ to 2^(Q × Γ*),
representing the possible transitions the machine can make based on the
current state, input symbol (or ε for ε-transitions), and top symbol of the
stack.
5. q0 is the initial state.
6. F is a set of final (or accepting) states.
A pushdown automaton operates similarly to a finite automaton, but it has access
to an additional stack data structure. At each step, the PDA reads an input symbol,
consults its current state and the top symbol of the stack, and based on this
information, it updates its state, possibly changes the stack contents, and moves
to the next input symbol. The PDA accepts a string if it reaches an accepting state
after processing the entire input string.
Pushdown automata are particularly useful for recognizing context-free
languages, as they can handle nested structures and maintain unbounded amounts
of memory (through the stack) during their computation. They are used in various
areas of computer science, including compiler construction, parsing, and natural
language processing. The formalism of pushdown automata provides a powerful
tool for studying the properties and capabilities of context-free languages.
11-MULTITAPE TM
A multitape Turing machine (MTM) is a variation of the classical Turing
machine model that features multiple tapes, each equipped with its own
independent read/write head. This model extends the computational power of a
single tape Turing machine by allowing it to simultaneously access and
manipulate multiple tapes during computation.
Formally, a multitape Turing machine is defined by a 7-tuple (Q, Σ, Γ, δ, q0,
qaccept, qreject), where:
• Q is a finite set of states.
• Σ is the input alphabet, which does not include the special blank symbol.
• Γ is the tape alphabet, which includes the input alphabet Σ as well as a
special blank symbol.
• δ is the transition function, which maps Q × Γ^k to Q × Γ^k × {L, R}^k,
where k is the number of tapes. This function specifies the machine's
behavior when reading the current symbol(s) on each tape and being in a
certain state.
• q0 is the initial state.
• qaccept is the accepting state.
• qreject is the rejecting state.
In a multitape Turing machine, each tape operates independently, allowing the
machine to read from or write to multiple positions on multiple tapes
simultaneously. The transition function dictates how the machine updates its
internal state and the contents of each tape based on the current configuration.
MTMs offer advantages over single tape Turing machines in terms of
computational efficiency and expressiveness for certain tasks, such as
simulating parallel algorithms, handling multiple inputs simultaneously, and
simplifying certain algorithms by utilizing multiple tapes for intermediate
storage.
base case:
o The empty set ∅ and the empty string ε are regular expressions.
o For each symbol a in Σ, the singleton set {a} is a regular
expression.
Inductive steps:
o If r and s are regular expressions, then the following are also
regular expressions:
§ Concatenation: rs (the concatenation of r and s).
§ Union: r | s (the union of r and s).
§ Closure: r* (the Kleene closure of r)
2.e-nfa
An ε-NFA (epsilon-NondeterminisAc Finite Automaton) is a type of
nondeterminisAc finite automaton (NFA) extended with ε-transiAons, or
epsilon-transiAons. These transiAons allow the automaton to move from one
state to another without consuming any input symbol.
Formally, an ε-NFA is a 5-tuple (Q, Σ, δ, q0, F), where:
• Q is a finite set of states.
• Σ is a finite set of input symbols (the alphabet).
set of Q), representing the set of states the machine can move to from a
given state with a given input symbol or ε.
• q0 is the initial state.
• F is a set of final (or accepting) states.
In an ε-NFA, the ε-transition allows the machine to move from one state to
another without consuming any input symbol. This feature enhances the
expressive power of the automaton by allowing more flexibility in recognizing
languages.
3-NFA
A Nondeterministic Finite Automaton (NFA) is a mathematical model used in
computer science and formal language theory to describe languages recognized
by finite automata. An NFA consists of a finite set of states, an input alphabet,
transition rules, an initial state, and one or more final states.
Unlike deterministic finite automata (DFAs), NFAs allow for nondeterminism in
for a given input symbol and current state. In other words, at any given point
during the input processing, an NFA can transition to one or more possible
states depending on the current state and the input symbol.
Languages recognized by NFAs are known as regular languages.
8-CHOMSKY HIERARCHY
The Chomsky hierarchy, proposed by linguist and cogniAve scienAst Noam
Chomsky in the 1950s, is a classificaAon of formal grammars and the languages
they generate. It provides a way to categorize formal languages based on their
generaAve power. The hierarchy consists of four levels, each represenAng a
class of grammars and the corresponding languages they generate. These
levels are:
1. Type 0: Unrestricted Grammars (Recursively Enumerable Languages)
o Unrestricted grammars have no restrictions on the production rules.
They can generate languages that cannot be recognized by any
mechanical means, also known as recursively enumerable languages.
2. Type 1: Context-Sensitive Grammars
o Context-sensitive grammars have production rules of the form αAβ →
αγβ, where A is a non-terminal symbol, α and β are strings of terminal
and non-terminal symbols, and γ is a non-empty string. These
grammars generate languages that are a proper subset of recursively
enumerable languages. They are recognized by linear-bounded
automata.
3. Type 2: Context-Free Grammars
o Context-free grammars have production rules of the form A → β,
where A is a non-terminal symbol and β is a string of terminal and
non-terminal symbols. These grammars generate context-free
languages, which are recognized by pushdown automata. Context-free
languages are widely used in computer science and linguistics.
4. Type 3: Regular Grammars (Regular Languages)
o Regular grammars have production rules of the form A → aB or A →
a, where A and B are non-terminal symbols, and a is a terminal
symbol. These grammars generate regular languages, which are
recognized by finite automata. Regular languages are used in many
practical applications, including lexical analysis, pattern matching,
and string processing.
o
9-CONVERT CFG TO PDA
Conversion of CFG to PDA consists of five steps. The steps are as follows:
• Convert the CFG productions into GNF.
• There will only be one state, "q," on the PDA.
• The CFG's first symbol will also be the PDA's initial symbol.
• Include the following rule for non-terminal symbols:
o δ(q, ε, A) = (q, α), Where the production rule is A → α
• Add the following rule for each terminal symbol:
o δ(q, a, a) = (q, ε) for every terminal symbol
12- L1 L2 ARE EMURABLE
To prove that the union and intersection of recursively enumerable languages are
also recursively enumerable, we can use the properties of recursively enumerable
languages and the definition of a recursively enumerable language.
Recall that a language is recursively enumerable (RE) if there exists a Turing
machine that halts and accepts any string in the language, and either halts and
rejects or loops indefinitely for strings not in the language.
Let's prove each part separately:
1. **Union of RE Languages (L1 ∪ L2)**:
- Let's denote the Turing machines that recognize L1 and L2 as M1 and M2,
respectively.
- To recognize strings in the union of L1 and L2, we can construct a new Turing
machine M that simulates both M1 and M2:
- On input w, M simulates M1 on w. If M1 accepts w, M accepts.
- If M1 rejects or loops indefinitely, M simulates M2 on w. If M2 accepts, M
accepts; otherwise, it rejects.
- Since both M1 and M2 are Turing machines that recognize recursively
enumerable languages, M halts and accepts strings in L1 ∪ L2, and thus L1 ∪ L2
is recursively enumerable.
2. **Intersection of RE Languages (L1 ∩ L2)**:
- Similarly, let's denote the Turing machines that recognize L1 and L2 as M1
and M2, respectively.
- To recognize strings in the intersection of L1 and L2, we can construct a new
Turing machine M that simulates both M1 and M2:
- On input w, M simulates M1 on w. If M1 rejects or loops indefinitely, M
rejects.
- If M1 accepts w, M simulates M2 on w. If M2 accepts, M accepts; otherwise,
it rejects.
- Since both M1 and M2 are Turing machines that recognize recursively
enumerable languages, M halts and accepts strings in L1 ∩ L2, and thus L1 ∩ L2
is recursively enumerable.
Therefore, we have proved that the union and intersection of recursively
enumerable languages are also recursively enumerable.
13-LINEAR BOUNDED AUTOMATA
Linear Bounded Automata (LBA) are a class of computational devices that serve
as a restricted form of Turing machines. LBAs operate on finite input strings
while restricting their tape usage to a space proportional to the length of the input
string. This constraint ensures that LBAs cannot move beyond a bounded region
of the tape, making them less powerful than Turing machines, which have
unbounded tape length.
Formally, a Linear Bounded Automaton is defined by a 6-tuple (Q, Σ, Γ, δ, q0, F),
where:
- Q is a finite set of states.
- Σ is the input alphabet.
- Γ is the tape alphabet, which includes Σ as well as a special blank symbol.
- δ is the transition function, which maps Q × Γ to Q × Γ × {L, R}, specifying the
machine's behavior when reading the current symbol and being in a certain state.
- q0 is the initial state.
- F is a set of final states.
The key restriction of LBAs is that their tape usage is bounded by a linear function
of the input size. More precisely, the tape head of an LBA can only move within
a constant factor of the length of the input string. This limitation ensures that
LBAs cannot use an arbitrarily large amount of tape, as Turing machines can.
Linear Bounded Automata are particularly useful for studying problems that
require bounded space, such as parsing context-sensitive languages or performing
certain types of string manipulation. They also serve as an important theoretical
tool for understanding the limitations of computational devices with restricted
resources, contributing to the study of complexity theory and formal language
theory.
13 POST CORRESPONDENCE PROBLEM
12- HALTING PROBLEM
The Halting Problem is determining whether a computer program will eventually stop The Post Correspondence Problem (PCP), introduced by Emil Post in 1946,
or run forever. Creating a general algorithm that can accurately predict this for all is an undecidable decision problem. The PCP problem over an alphabet ∑
programs is impossible. Alan Turing's proof showed no way to solve the Halting is stated as follows −
Problem for all cases.
Given the following two lists, M and N of non-empty strings over ∑ −
Before moving on to the proof, let's first understand some terms.
3. Undecidable Problems
An undecidable problem is a sort of computational problem requiring a yes/no M = (x1, x2, x3,………, xn)
answer but where no computer program can give the proper answer all of the time;
that is, any possible algorithm or program would sometimes give the wrong answer N = (y1, y2, y3,………, yn)
or run forever without providing any answer.
Step 1: Assume we can create a machine called HM(P, I), where HM is the Halting We can say that there is a Post Correspondence Solution, if for some
machine, P is the program, and I is the input. After receiving both inputs, the machine i1,i2,………… ik, where 1 ≤ ij ≤ n, the condition xi1 …….xik =
HM will output whether or not the program P terminates. yi1 …….yik satisfies.
Step 2: Now, create an inverted halting machine IM that takes a program P as input
and,
• Loops forever If HM returns YES.
• Halts if HM returns NO.
Step 3: Now, take a situation where the program IM is passed to the IM function as
an input. Here, we got a contradiction. Let's understand how.