Department of Information Technology

Assignment

Name: Vedant Gokul Patil

Q.1) Implementation of a Turing machine for “Problem statement” using c/c++

Problem Statement :

Al g o rit hm:
1. Initial state: Start at the leftmost position of the input string.

2. First check: If the current symbol is a, replace it with X, move right and check the rightmost symbol. If
it's a, replace it with X and move left to check the next pair.

• If the current symbol is b, replace it with X, move right, and check the rightmost b.

• If the symbols don't match, reject the string (i.e., the string is not a palindrome).

3 . Repeat: Continue this process for all pairs until you either:

• Find a mismatch (reject), or

• All symbols are marked (accept the string as a palindrome).

4. End condition: If all symbols have been marked and we reach the middle, accept the string as a
palindrome

Pro g ram:
#include <iostream>

#include <string>

using namespace std;

bool checkPalindrome(string input) {

while (left < right) {

// Check if characters at the left and right are equal

if (input[left] != input[right]) {

return false; // Not a palindrome

left++;

right--;

return true; // Palindrome

int main() {

string input;

cout << "Enter a string (over alphabet {a,b}): ";

cin >> input;

// Check if the string is a palindrome

if (checkPalindrome(input)) {

cout << "The string is a palindrome." << endl;

} else {

cout << "The string is not a palindrome." << endl;

return 0;
}

Ou t pu t :

Enter a string (over alphabet {a,b}): abba

The string is a palindrome.

Enter a string (over alphabet {a,b}): abca

The string is not a palindrome.

Q.2) Justify the statement P=NP?

Ans : The statement P = NP is one of the most important and famous open problems in computer science. It
asks whether the class of problems that can be solved in polynomial time (P) is the same as the class of
problems whose solutions can be verified in polynomial time (NP).
Let’s break down the components of this question and explore the arguments for and against the possibility
of P = NP.
Understanding P and NP:
• P (Polynomial Time): The class of decision problems (problems with a yes/no answer) that can be
solved by a deterministic Turing machine in polynomial time (i.e., the time taken to solve the
problem is bounded by a polynomial function of the input size).
Example: Sorting a list, finding the shortest path in a graph using Dijkstra's algorithm.
• NP (Nondeterministic Polynomial Time): The class of decision problems for which a proposed
solution can be verified in polynomial time. In other words, if you are given a potential solution
(called a "certificate"), you can verify its correctness in polynomial time.
Example: Given a graph and a particular subset of edges, checking whether it forms a valid Hamiltonian
cycle (a cycle that visits every vertex exactly once).
P = NP?
The P = NP question asks: Are all problems for which solutions can be verified in polynomial time also
problems that can be solved in polynomial time?
1. If P = NP:
o This would mean that for every problem where we can verify a solution in polynomial
time, we could also find a solution in polynomial time.
o This would have profound implications for fields like cryptography, optimization, artificial
intelligence, and more.
o Problems that are currently in NP-complete (the hardest problems in NP) could potentially
be solved efficiently. For example, problems like the Traveling Salesman Problem or
Knapsack Problem could be solved in polynomial time.
o Cryptography: Many cryptographic protocols rely on the fact that certain problems (e.g.,
factoring large integers) are believed to be hard to solve but easy to verify. If P = NP, this
would undermine the security of many cryptographic systems.
2. If P ≠ NP:
 o This would mean that there exist problems for which we can verify solutions in polynomial
time but cannot find solutions in polynomial time.
o This would suggest that some problems are inherently harder to solve than to verify, which
aligns with our current understanding of the difficulty of many real-world problems.
o If P ≠ NP, many problems in NP-complete would not have efficient (polynomial-time)
algorithms to solve them, even though we can verify their solutions efficiently.
Arguments for P = NP:
• Theoretical Possibility: There is nothing inherently stopping P from being equal to NP. Some
believe that a polynomial-time algorithm for NP-complete problems may exist, but it has not been
discovered yet.
• Optimistic View: Some theorists believe that as computer science and algorithms progress, new
techniques might be found that could provide a polynomial-time solution to NP-complete
problems.
Arguments for P ≠ NP:
• Complexity of NP-Complete Problems: There is a strong belief in the computer science community
that P ≠ NP, primarily because the NP-complete problems (such as the Traveling Salesman Problem,
Knapsack, and Boolean Satisfiability) are intuitively very difficult to solve in polynomial time.
Despite decades of effort, no polynomial-time solutions have been discovered, and the problems
appear to require exponential time to solve in the worst case.
• Evidence from Cryptography: Many modern cryptographic systems, such as RSA, rely on the
assumption that certain problems (e.g., factoring large numbers) are hard to solve but easy to
verify. If P = NP, these cryptographic systems would be insecure.
• Lack of Progress: No one has been able to find a polynomial-time solution for any NP-complete
problem, even after decades of research. This suggests that a polynomial-time solution may not
exist.
Current Status:
• As of today, P = NP remains an open problem, and no proof has been found to definitively answer
it.
• The Clay Mathematics Institute has even listed it as one of the seven "Millennium Prize Problems"
with a reward of $1 million for a correct proof.
• Most computer scientists believe P ≠ NP, but it has not been proven either way.
Conclusion:
The statement P = NP is still undecided. If P = NP, it would revolutionize many areas of computer science,
but if P ≠ NP, it would confirm that certain problems are inherently more difficult to solve than to verify.
The majority opinion among computer scientists is that P ≠ NP, but no definitive proof has been found. The
problem remains one of the central unsolved questions in theoretical computer science.