Unit 5

A Turing machine is a fundamental concept in computer science and mathematics,

introduced by the British mathematician and computer scientist Alan Turing in 1936.
It serves as an abstract mathematical model for a computing device, helping to
understand the limits and capabilities of computation. Turing machines are a
cornerstone of theoretical computer science and play a crucial role in the
development of algorithms and the study of computational complexity.

Introduction to Turing Machines:

A Turing machine is composed of several key components:

1. Tape: The tape is an infinite one-dimensional tape divided into cells, where
each cell can hold a symbol from a finite alphabet. The tape is initially
populated with symbols.
2. Head: The head is a read/write mechanism that moves left or right along the
tape and can read the symbol currently under it, write a new symbol, or erase
the existing symbol.
3. State Register: The Turing machine has a finite set of states, and it can be in
one of these states at any given time.
4. Transition Function: The transition function specifies how the machine
should behave based on its current state and the symbol it is reading. It
defines what symbol to write on the tape, whether to move the head left or
right, and which state to transition to next.
5. Start State and Halt State: The Turing machine has a designated start state
where it begins its computation and a halt state where it stops. The machine
operates in discrete steps, transitioning between states according to the
transition function, until it enters the halt state.

The operation of a Turing machine involves reading the symbol under the head,
determining the next state and symbol to write based on the current state and
symbol, and then moving the head left or right. This process continues until the
machine reaches the halt state.

Types of Turing Machines:

Turing machines can be classified into several types based on their capabilities and
variations in their operation:

1. Deterministic Turing Machine (DTM): In a DTM, the transition function is

deterministic, meaning that for any given combination of current state and
symbol, there is exactly one next state and symbol to write. DTMs are the
simplest and most commonly studied type of Turing machine.
 Unit 5

2. Non-deterministic Turing Machine (NDTM): An NDTM allows for multiple

possible transitions from a given state and symbol. It can explore multiple
computation paths simultaneously. NDTMs are often used in theoretical
discussions to illustrate concepts but do not have a direct physical
counterpart.
3. Multitape Turing Machine: In a multitape Turing machine, there are multiple
tapes and corresponding heads that can read and write simultaneously. This
type of Turing machine can potentially speed up certain computations.
4. Nondeterministic Multitape Turing Machine (NDMTM): This combines the
features of non-determinism and multiple tapes. It is a theoretical model that
explores different computation paths using multiple tapes and heads.
5. Universal Turing Machine: A universal Turing machine is a Turing machine
that can simulate the operation of any other Turing machine. It is a
fundamental concept in the theory of computation and serves as a basis for
understanding the limits of computation.

These are some of the key types of Turing machines, each with its own characteristics
and applications in theoretical computer science. Turing machines provide a
theoretical foundation for understanding what can and cannot be computed, and
they are a fundamental tool in the study of algorithms and computational
complexity.

Turing Machine for Recognizing Balanced Strings:

Input: The Turing machine is given an input string composed of 0s and 1s.

States: {q0, q1, q_accept, q_reject}

Alphabet: {0, 1, _}

 "0" and "1" are the input symbols.

 "_" represents a blank symbol.

Transition Function:

1. If the machine is in state q0 and reads a "0," it replaces the "0" with "_", moves
right, and stays in state q0.
2. If the machine is in state q0 and reads a "1," it replaces the "1" with "_", moves
right, and transitions to state q1.
3. If the machine is in state q1 and reads a "1," it replaces the "1" with "_", moves
right, and stays in state q1.
 Unit 5

4. If the machine is in state q1 and reads a "0," it replaces the "0" with "_", moves
right, and transitions back to state q0.
5. If the machine reads a blank symbol "_" while in state q0, it moves left and
remains in state q0.
6. If the machine reads a blank symbol "_" while in state q1, it moves left and
remains in state q1.
7. If the machine reads a blank symbol "_" while in state q0 or q1, it transitions to
the accept state (q_accept).

Execution:

Suppose the input string is "010101." Let's see how the Turing machine processes it:

1. The machine starts in state q0 and reads "0." It replaces the "0" with "_",
moves right, and stays in state q0. The tape becomes "_10101."
2. It continues this process for the next "1" and "0" in the input, transitioning
between states q0 and q1. The tape becomes "_1_01_1."
3. After processing the entire string, it reaches the accept state (q_accept).

Since the machine has successfully processed the entire input string and reached the
accept state, it recognizes that "010101" has an equal number of 0s and 1s, which
makes it a balanced string.

This simple example demonstrates the basic operation of a Turing machine for
recognizing a specific language, in this case, strings with a balanced number of 0s
and 1s.

Tm for simple problem

Sure, let's construct a Turing machine for a simple problem: recognizing whether a binary input string
contains an even number of "1" symbols.

**Turing Machine for Recognizing Even "1"s:**

**Input:** The Turing machine takes as input a binary string consisting of "0" and "1" symbols.

**States:** {q0, q1, q_accept, q_reject}

 Unit 5

**Alphabet:** {0, 1, _}

- "0" and "1" are the input symbols.

- "_" represents a blank symbol.

**Transition Function:**

1. If the machine is in state q0 and reads a "1," it replaces the "1" with "_", moves right, and
transitions to state q1.

2. If the machine is in state q0 and reads a "0," it moves right and stays in state q0.

3. If the machine is in state q1 and reads a "1," it replaces the "1" with "_", moves right, and
transitions back to state q0.

4. If the machine is in state q1 and reads a "0," it moves right and stays in state q1.

5. If the machine reads a blank symbol "_" while in state q0, it moves right and remains in state q0.

6. If the machine reads a blank symbol "_" while in state q1, it moves right and remains in state q1.

7. If the machine reaches the end of the input string and is in state q0, it transitions to the accept
state (q_accept).

8. If the machine reaches the end of the input string and is in state q1, it transitions to the reject
state (q_reject).

**Execution:**

Let's see how the Turing machine processes an example input string, "110101":

1. The machine starts in state q0 and reads "1." It replaces the "1" with "_", moves right, and
transitions to state q1. The tape becomes "_10101."

2. It continues this process, alternating between states q0 and q1 as it processes the "1"s in the
input. The tape becomes "_1_01_1_."

3. After processing the entire string, it reaches the end of the input and is in state q0.

4. Since it's in state q0 at the end of the input, it transitions to the accept state (q_accept) because
the input contains an even number of "1" symbols.

So, the Turing machine recognizes that "110101" contains an even number of "1" symbols, and it
reaches the accept state.
 Unit 5

This Turing machine serves as a simple example of how a Turing machine can be constructed to solve
a specific problem by defining its states, transition rules, and behavior based on the problem's
requirements.

Tm as enumerator

In the context of theoretical computer science, a Turing machine can be used as an enumerator to
generate and list various mathematical objects, such as strings or sets. An enumerator is a type of
Turing machine that systematically generates all possible strings, sequences, or objects within a
specified set, typically in lexicographic order. Enumerators are commonly used in mathematical
proofs and computer science to demonstrate the existence or properties of certain objects.

Here's how a Turing machine can function as an enumerator:

1. **Input Specification:** The enumerator Turing machine takes an initial string or input as a
starting point, which may represent the first element in the set to be enumerated.

2. **Generation Process:** The Turing machine employs a systematic process to generate strings or
objects within the desired set. This process typically involves iterating through all possible
combinations in a well-defined order.

3. **Output:** As the enumerator generates each string or object, it can either write them on the
tape or produce them as output in some other way, such as through a printer or another output
device.

4. **Control:** The enumerator can use a control mechanism to keep track of its progress and to
ensure that it generates all elements of the set, potentially stopping when it has enumerated the
entire set or when it reaches a specified limit.

5. **Termination:** The enumerator can terminate when it has exhausted all possibilities within the
set, or it can be designed to run indefinitely if the set being enumerated is infinite.

**Example:** Let's consider an enumerator that generates all binary strings of length n, where n is a
positive integer. The enumerator would start with "0" of length n and incrementally generate all
possible binary strings of that length in lexicographic order.
 Unit 5

Here's a simplified representation of how the enumerator works for n = 3:

- Start with "000" (the first binary string of length 3).

- Output "000."

- Move to the next binary string: "001."

- Output "001."

- Continue this process, generating and outputting "010," "011," "100," "101," "110," and "111" in
sequence.

The enumerator systematically lists all binary strings of length 3 in lexicographic order and can be
extended to enumerate binary strings of any desired length.

Enumerators are valuable tools in theoretical computer science, especially for proving properties
about sets and their members. They demonstrate the computability and systematic nature of certain
problems and sets, helping to establish mathematical results and theoretical foundations in the field.

Relation between language of classes

In theoretical computer science, there are various classes of formal languages, and they are
organized in a hierarchy based on their generative power and computational complexity.
Understanding the relationships between these language classes is essential for classifying problems
and analyzing their solvability. Here's an overview of some of the most common language classes
and their relationships:

1. **Regular Languages (RL):** Regular languages are the simplest class of languages and can be
recognized by finite automata, like finite state machines (FSMs) or regular expressions. They are
closed under union, concatenation, and Kleene star operations. Regular languages are a subset of
context-free languages.

2. **Context-Free Languages (CFL):** Context-free languages are more expressive than regular
languages and can be recognized by pushdown automata. They are closed under union,
concatenation, Kleene star, and some context-free languages have a corresponding context-free
grammar. Context-free languages are a proper superset of regular languages.

3. **Context-Sensitive Languages (CSL):** Context-sensitive languages are recognized by linear

bounded automata, which are Turing machines with a restricted tape space. They are more
 Unit 5

expressive than context-free languages and include many natural languages and programming
languages.

4. **Recursively Enumerable Languages (RE):** Recursively enumerable languages are recognized by

unrestricted Turing machines, which can be thought of as a generalization of context-sensitive
languages. Every context-sensitive language is also recursively enumerable, but not all recursively
enumerable languages are context-sensitive.

5. **Decidable Languages (D):** Decidable languages are a subset of recursively enumerable

languages. They are recognized by Turing machines that always halt on every input, either accepting
or rejecting it. Context-free languages and regular languages are examples of decidable languages.

Here are some of the key relationships between these language classes:

- **Regular Languages ⊆ Context-Free Languages ⊆ Context-Sensitive Languages ⊆ Recursively

Enumerable Languages:** This represents the hierarchy of language classes based on increasing
generative power. Each class is more expressive than the previous one.

- **Context-Free Languages ⊆ Recursively Enumerable Languages:** While context-free languages

are not as expressive as context-sensitive languages, they are still a proper subset of recursively
enumerable languages.

- **Decidable Languages ⊆ Recursively Enumerable Languages:** Every decidable language is also

recursively enumerable. Decidable languages are a subset of the more general class of recursively
enumerable languages.

- **Some Context-Free Languages are Not Context-Sensitive:** There exist context-free languages
that are not context-sensitive, showing that context-sensitive languages are strictly more powerful
than context-free languages.

- **Some Recursively Enumerable Languages are Not Context-Free:** There are recursively
enumerable languages that cannot be generated by context-free grammars, demonstrating that the
hierarchy is strict.

Understanding these relationships is crucial for characterizing the computational complexity of

problems, designing algorithms, and determining the limits of computation for various language
classes in theoretical computer science.
 Unit 5

Computational complexity

Computational Complexity Theory is a subfield of theoretical computer science (TOC) that focuses on
the classification and analysis of computational problems based on the resources required to solve
them. It aims to understand the inherent difficulty of problems and how the time and space
requirements for solving them scale with input size. Key concepts and topics in computational
complexity theory include the following:

1. **Complexity Classes:** Complexity theory defines a hierarchy of complexity classes that

categorize problems based on their difficulty. Common complexity classes include P, NP, PSPACE, EXP,
and many others. Understanding which problems belong to which class is central to complexity
theory.

2. **P vs. NP:** The P vs. NP problem is one of the most famous and unsolved problems in computer
science. It asks whether every problem whose solution can be verified in polynomial time (NP) can
also be solved in polynomial time (P). Resolving this problem has profound implications for the
practical efficiency of algorithms.

3. **Reductions:** Reductions are used to establish the relative difficulty of problems. Polynomial-
time reductions, in particular, help show that if one problem is solvable in polynomial time, then
another problem can be reduced to it in polynomial time. This is essential for understanding the
complexity landscape.

4. **NP-Completeness:** Problems that are both in NP and "hard" within NP are referred to as NP-
complete. NP-complete problems are crucial in complexity theory because they are believed to be
difficult to solve and have many practical applications. The theory of NP-completeness was
introduced by Stephen Cook and Richard Karp.

5. **Polynomial-Time Algorithms:** Complexity theory is concerned with problems that can be

solved in polynomial time. Such problems are categorized within P, and the associated class contains
decision problems that are "easy" to solve.

6. **Space Complexity:** While time complexity is a key focus, space complexity is also essential.
Problems are classified based on the amount of memory (space) they require. PSPACE, for instance,
contains problems that can be solved using polynomial space.

7. **Time Hierarchy Theorem:** This theorem states that there exist problems that can be solved in
more time than others. In other words, there are problems that are inherently harder to solve within
the same computational model.
 Unit 5

8. **Exponential Time:** Problems that require an exponential amount of time to solve are classified
in EXP. Understanding the relationship between P, NP, and EXP is a critical aspect of complexity
theory.

9. **Non-deterministic Turing Machines:** Non-deterministic Turing machines play a pivotal role in

the definition of complexity classes. Problems that can be solved by non-deterministic machines in
polynomial time are in NP.

10. **Circuit Complexity:** Circuit complexity theory explores the complexity of Boolean functions
and their representation using logic gates. This is an alternative perspective on the complexity of
problems.

11. **Parallel Complexity:** In addition to the traditional sequential computation model, complexity
theory also considers parallel computation, which is essential for understanding the complexity of
parallel algorithms and systems.

Computational complexity theory has practical applications in computer science, such as guiding the
design of efficient algorithms, cryptography, and understanding the limits of computation. It is also
fundamental for understanding problems that are inherently difficult to solve, which has implications
in various fields, including cryptography, optimization, and AI.

computable function

In the context of theoretical computer science (TOC), a computable function is a function that can be
calculated or computed by an algorithm. It's a fundamental concept in the theory of computation,
which seeks to understand the limits and capabilities of computers and algorithms.

There are various types of computable functions in TOC, but two fundamental classes are:

1. Turing Computable Functions: These are functions that can be computed by a Turing machine. A
Turing machine is an abstract mathematical model of a general-purpose computer that operates on
an infinite tape of cells and follows a set of rules to manipulate symbols. Any function that can be
computed by a Turing machine is considered Turing computable.

2. Recursive Functions: Recursive functions are another class of computable functions. They are
defined using a formal mathematical notation and can be computed using a process of recursion,
 Unit 5

where a function calls itself with smaller inputs until it reaches a base case. The set of recursive
functions is equivalent to the set of Turing computable functions.

These two classes of computable functions are important because they capture the notion of what
can be effectively computed by a computer or algorithm. They provide a foundation for
understanding the limits of computation and form the basis for many theoretical investigations in
computer science and the theory of computation.

Here are some key characteristics of computable functions:

1. Algorithmic Computability: A function is considered computable if there exists an
algorithm, such as a Turing machine or a similar computational model, that can
compute the function for any given input within its domain. This means that there is a
systematic procedure to determine the output of the function for any input.
2. Well-Defined Inputs and Outputs: For a function to be computable, its inputs and
outputs must be well-defined and unambiguous. The function should produce a unique
output for each valid input, and the computation process should be deterministic.
3. Halting Property: The algorithm computing the function must always halt (terminate)
after a finite number of steps for any input. This ensures that the computation does not
run indefinitely.
4. Domain and Codomain: Computable functions have a well-defined domain (set of
possible input values) and codomain (set of possible output values). The function
produces an output from the codomain for each input from the domain.
5. Turing Machine Computability: In many discussions of computable functions, the
focus is on Turing machines as the model of computation. A function is said to be
Turing-computable if there exists a Turing machine that, when given an input, can
produce the correct output for that input.
Computable functions are a fundamental concept in the theory of computation, and they are
used to define the limits of what can be computed by computers or algorithms. Functions that
are not computable are said to be undecidable or non-computable, and they play a significant
role in exploring the boundaries of computability theory. Alan Turing's work on computable
functions and Turing machines was instrumental in laying the theoretical foundation for
modern computer science.

In theoretical computer science (TOC), functions are often categorized as either partial or total
functions, based on how they behave with respect to their input values:
 Unit 5

1. Partial Function:

- A partial function is defined for only some input values within its domain.

- It may produce a valid output for certain inputs but not for others.

- If you provide an input that is outside its domain, it might result in an error or an undefined
behavior.

- Partial functions are commonly encountered in programming, where functions may not be
defined for all possible input values. For example, the division operation is a partial function because
it's not defined when the denominator is zero.

2. Total Function:

- A total function is defined for all input values within its domain.

- It produces a valid output for every possible input.

- Total functions are guaranteed to always terminate and produce a result.

- In contrast to partial functions, total functions are often preferred in mathematical and theoretical
contexts because they provide well-defined behavior for all inputs.

Total functions are particularly important in the context of theoretical computer science and
mathematics because they are more amenable to formal reasoning and analysis. They avoid issues
related to undefined behavior or errors that can arise with partial functions. However, in practical
programming, partial functions are common, and handling their potential exceptions or errors is a
crucial aspect of software development.

Constant fn

In the context of theoretical computer science (TOC), a constant function is a specific type of function
that always returns the same value, regardless of its input. In other words, it is a function that is
entirely independent of its input and produces a constant output.

Mathematically, a constant function can be represented as follows:

[f(x) = c\]

Where:

(f(x)\) is the function.

(x\) is the input to the function (which is typically ignored in this case).

(c\) is the constant value that the function always returns.

 Unit 5

Key characteristics of a constant function in TOC include:

1. Predictable Output: Regardless of the input value \(x\), the function \(f(x)\) always returns the
same fixed value \(c\). This makes the behavior of the function highly predictable.

2. No Computation: Since the function's output is constant and does not depend on the input, there
is no computational or algorithmic work required to calculate the output. It is a simple mapping of
any input to a predefined constant value.

3. Limited Usefulness: Constant functions are not typically of great interest in TOC because they do
not capture any interesting computational behavior or decision-making process. They are essentially
trivial functions that are used for specific purposes, such as defining a constant value or placeholder
in mathematical expressions.

Examples of constant functions include:

(f(x) = 5) (a function that always returns the constant value 5).

(f(x) = pi) (a function that always returns the constant value of the mathematical constant π).

(f(x) = 0) (a function that always returns zero).

While constant functions themselves may not be the focus of significant study in TOC, they are a
fundamental concept in mathematics and are sometimes used in theoretical discussions or as
building blocks for more complex functions and expressions.

Primitive recursive fn

In theoretical computer science (TOC), primitive recursive functions are a class of functions that can
be defined using a simple and well-defined set of rules. These functions are computed using
recursion and are considered a subset of the more general recursive functions. Primitive recursive
functions have a limited computational power compared to general recursive functions, making
them a useful tool for studying computability and complexity.

The primitive recursive functions are defined recursively using the following base cases and closure
properties:

1. Zero Function (Z): This function, denoted as Z(x), returns 0 for all inputs x.
 Unit 5

Example: Z(5) = 0, Z(0) = 0, Z(100) = 0, and so on.

2. Successor Function (S): The successor function, denoted as S(x), returns the successor of x, which
is x + 1.

Example: S(5) = 6, S(0) = 1, S(100) = 101, and so on.

3. Projection Functions (P^n_i): These functions, denoted as P^n_i(x_1, x_2, ..., x_n), return the i-th
argument of the input tuple (x_1, x_2, ..., x_n).

Example: P^2_1(3, 4) = 3, P^3_2(1, 2, 3) = 2, and so on.

4. Composition (Composition Schema): If f(x_1, x_2, ..., x_n) and g(y_1, y_2, ..., y_m) are primitive
recursive functions, then their composition h(x_1, x_2, ..., x_n, y_1, y_2, ..., y_m) defined as follows is
also a primitive recursive function:

h(x_1, x_2, ..., x_n, y_1, y_2, ..., y_m) = f(g(x_1, x_2, ..., x_n), y_1, y_2, ..., y_m)

5. Primitive Recursion (Primitive Recursion Schema): If f(x_1, x_2, ..., x_n) and g(x, y_1, y_2, ..., y_m)
are primitive recursive functions, then their primitive recursion h(x_1, x_2, ..., x_n, 0) and h(x_1, x_2,
..., x_n, S(y)) defined as follows is also a primitive recursive function:

h(x_1, x_2, ..., x_n, 0) = f(x_1, x_2, ..., x_n)

h(x_1, x_2, ..., x_n, S(y)) = g(x, y, h(x_1, x_2, ..., x_n, y))

Primitive recursive functions are relatively simple and can express many common mathematical
operations, such as addition, multiplication, and exponentiation. Here's an example of a primitive
recursive function:

Example: Multiplication (mult)

Define a primitive recursive function mult(x, y) that computes the product of two non-negative
integers x and y.
 Unit 5

The base cases:

- mult(x, 0) = 0 (using the Z function)

- mult(x, S(y)) = mult(x, y) + x (using primitive recursion and the successor function S)

Using these rules, you can compute multiplication using only primitive recursive functions. For
instance:

- mult(3, 4) = 3 * 4 = 12

- mult(5, 0) = 5 * 0 = 0

- mult(2, 7) = 2 * 7 = 14

These are examples of primitive recursive functions because they are defined using the base cases
and primitive recursion schema.

Regular fn

In theoretical computer science (TOC), the term "regular function" does not have a widely recognized
or standard definition. The concept of regularity is more commonly associated with other branches
of mathematics, such as regular languages in formal language theory or regular expressions in string
processing.

However, if you are referring to a "regular function" in a broader mathematical context, it is typically
used in contrast to irregular or singular functions and is often associated with functions that are well-
behaved and continuous.

In calculus and real analysis, a real-valued function f(x) defined on a subset of the real numbers is
considered "regular" or "continuous" if it satisfies the following properties:

1. Continuity: The function does not have abrupt jumps or discontinuities. More formally, for every
point 'a' in its domain, the limit of the function as x approaches 'a' exists, and the value of the
function at 'a' is equal to this limit. Symbolically, lim (x → a) f(x) = f(a).

2. Differentiability: A continuous function may also be differentiable at a point 'a' if its derivative
exists at 'a'. This means that the function has a well-defined slope or rate of change at that point.
 Unit 5

3. Smoothness: A function can be considered "more regular" if it is not only continuous and
differentiable but also has higher-order derivatives that exist and are continuous. Such functions are
often referred to as "smooth" or "C^n" for some positive integer 'n'.

In summary, in the context of calculus and real analysis, "regular functions" generally refer to well-
behaved, continuous, and differentiable functions that do not exhibit abrupt changes or singularities.

If you have a specific context or definition of "regular function" in TOC or another specific area of
computer science, please provide more details, and I will do my best to provide a more specific
explanation.

Recursive fn

In theoretical computer science (TOC), a recursive function is a function that is defined in terms of
itself, either directly or indirectly. Recursive functions play a fundamental role in TOC and are used to
describe computations and algorithms in a recursive manner. Recursive functions are closely related
to the concept of recursion in computer science, where a function calls itself to solve a problem.

There are two primary types of recursive functions in TOC:

1. Recursive Functions (Direct Recursion):

- A recursive function directly calls itself within its own definition.

- These functions typically have one or more base cases, which are simple, non-recursive cases that
define the behavior for certain inputs.

- The function's recursive definition specifies how to solve larger or more complex instances of the
problem by breaking them down into smaller, similar instances and using the function on those
smaller instances.

- Recursive functions must have a well-defined stopping condition to prevent infinite recursion.

Example: The factorial function is a classic example of a recursive function.

fact(n):

if n == 0:

return 1 # Base case

else:

return n * fact(n-1) # Recursive case

 Unit 5

2. Indirect Recursion:

- In indirect recursion, multiple functions call each other in a circular manner, creating a chain of
function calls.

- Each function relies on another function to perform part of the computation.

- The recursion still requires base cases and stopping conditions to terminate.

Example: Consider two functions, A and B, that call each other:

A(x):

if x == 0:

return 1

else:

return B(x-1)

B(x):

if x == 0:

return 0

else:

return A(x-1)

Recursive functions are essential in various areas of computer science, including algorithm design,
data structures, and programming. They provide a powerful way to express complex problems and
solutions in a natural and elegant way. However, it's crucial to define recursive functions carefully,
ensuring that they have well-defined base cases and termination conditions to avoid infinite
recursion.