Input: Deterministic TM - M.
Question: Is there any input x, such that when M run on x, there are 3 different states of M, that M going throught the first state once, the seconed state twice, and 3 times throught the third state ?
To which complexity class the following problem belonges ?
A. R
B. RE\R
C. co-RE\R
D. Non of the above
I will be glad if someone can give im a formal proof to this problem, and a tip how to deal with this sort of questions.
thanks.
When dealing with complexity class R, you should always think of the Halting problem. If you can find any algorithm (even if superexponential) to solve the problem, it is in R. If you can deduce the halting problem to your problem, (as in this case), the problem is incomputable (and therefore I think the answer is D).
I'm not sure how a formal proof in this case goes, but the idea is that you want to prove that you can solve the halting problem if you can solve your problem. Now suppose you have a TM and you want to find out if it terminates. We assume that we can solve your problem instance. First, we prepend a Turing machine A before the start state of the halting problem and use the start state of A as the new start state. A is such that no state will be visited exactly once, some state will be visited exactly twice and some state will be visited exactly three times. That part should be trivial. Now, except for the end state of the halting machine, We need to make sure that each state of the halting machine will be visited at least twice. I don't know the details, but this should be possible by having a new arrow from each state to itself and manipulating the symbols to each state so that it needs to go to itself once before it can continue to another state. Now, the only possible state that could be visited exactly once, is the end state. Therefore, if you can solve your problem, you can solve the halting problem. But the halting problem is incomputable, so so is your problem.
Related
How can we reduce Boolean SAT problem to HALTING problem? I tried it, but have no idea how to begin. Eventually, I wanted to prove HALT is NP-HARD, so is there a better method than this to prove HALT is NP-HARD?
Basically, we can assume a Turing machine that considers all possible assignments:
If a satisfying assignment is found, the machine halts
Otherwise, it loops forever
if a satisfying assignment is not found then it runs forever. This machine halts if and only if the 3SAT instance is satisfiable. Given an input F (3Sat formula) to 3SAT, we pass the input into HALT(M, F) and see what the answer is.
I guess there is no polynomial algorithm for opening a code lock with n dials on a suitcase.
However, to verify an existing solution is easy, it consists simply of opening the suitcase.
So the problem is in NP, but not in P.
Obviously I am mistaken. Where am I wrong?
I agree with zmbd's answer.
I would like to expand it a little bit. Deterministic problems shouldn't have hidden numbers to be guessed; the entire problem to be solved should be clear. Deterministic problems are more like chess than like poker: the entire problem statement should be accessible to the algorithm.
However, Computer Science often studies complexity classes with "oracles". An oracle is more or less a black box that has some hidden from the algorithm criteria for answering "yes/no" questions. Your suitcase problem essentially includes an oracle that allows you to open the suitcase if and only if the lock coincide with the hidden number. With the help of that oracle your implied question can be made rigorous:
Given an oracle A that has a hidden combination of locks the problem of opening the suitcase is clearly in NP^A, but not in P^A. Does that prove that P != NP?
The answer to the above question is no: it turns out that there exists an oracle A for which P^A != NP^A, and also exists an oracle B for which P^B == NP^B. Therefore your perfectly correct observation that opening the suitcase is in NP relative to the hidden number oracle, but not in P relative to the same hidden number oracle does not prove that P != NP.
Here's the original paper about that:
T. P. Baker, J. Gill, and R. Solovay, "Relativizations of the P =? NP Question"
Let's start from the end - you haven't just proven P!=NP in a 2-line Stack Overflow question.
The problem is your suitcase problem isn't well defined. Turing machines can't open suitcases, you need to model a suitcase somehow.
Since complexity depends on the input's length, without knowing how you model a suitcase, there's really no way of discussing complexities.
For example, if you follow #indiv's comment's logic, your suitcase model can be the combination that opens the lock. In that case, you can solve it in constant time:
def figure_suitcase_code(code):
return code
You haven't defined your problem properly - you can't say anything about the complexity.
Is it possible to determine all the possible execution paths by reading the bytecode of a given method, or will that be equivalent to trying to solve the halting problem? If it can't be reduced to the halting problem, then how far can I go with static analysis without crossing the boundary of trying to solve the halting problem?
Related question: "Finding all the code in a given binary is equivalent to the Halting problem." Really?
Yes, this is easily equivalent to solving the halting problem. Consider the following if statement:
if (TuringMachine(x)) then goto fred;
OK, is it really possible to goto fred? You can only answer this question if you can analyze a Turing machine.
There's an equivalent set of bytecodes for this.
Now, if the only problem is to determine all plausible paths, and you don't care if you get some false positives, the answer is No. Consider the following program:
if (false) then x else y ;
The possbile paths: eval(false);do x and eval(false);do y is a complete enumeration.
You have to treat loops specially, as zero, one, two, or some maximum bounded number of iterations, it you want a computable answer. If a loop can repeat forever, some of your paths will be infinitely long and you can't report them with a algorithm and finite time :-{
I'm writing a program which solves a 24-puzzle (5x5 grid) using two heuristic. The first uses how many blocks the incorrect place and the second uses the Manhattan distance between the blocks current place and desired place.
I have different functions in the program which use each heuristic with an A* and a greedy search and compares the results (so 4 different parts in total).
I'm curious whether my program is wrong or whether it's a limitation of the puzzle. The puzzle is generated randomly with pieces being moved around a few times and most of the time (~70%) a solution is found with most searches, but sometimes they fail.
I can understand why greedy would fail, as it's not complete, but seeing as A* is complete this leads me to believe that there's an error in my code.
So could someone please tell me whether this is an error in my thinking or a limitation of the puzzle? Sorry if this is badly worded, I'll rephrase if necessary.
Thanks
EDIT:
So I"m fairly sure it's something I'm doing wrong. Here's a step-by-step list of how I'm doing the searches, is anything wrong here?
Create a new list for the fringe, sorted by whichever heuristic is being used
Create a set to store visited nodes
Add the initial state of the puzzle to the fringe
while the fringe isn't empty..
pop the first element from the fringe
if the node has been visited before, skip it
if node is the goal, return it
add the node to our visited set
expand the node and add all descendants back to the fringe
If you mean that sliding puzzle: This is solvable if you exchange two pieces from a working solution - so if you don't find a solution this doesn't tell anything about the correctness of your algorithm.
It's just your seed is flawed.
Edit: If you start with the solution and make (random) legal moves, then a correct algorithm would find a solution (as reversing the order is a solution).
It is not completely clear who invented it, but Sam Loyd popularized the 14-15 puzzle, during the late 19th Century, which is the 4x4 version of your 5x5.
From the Wikipedia article, a parity argument proved that half of the possible configurations are unsolvable. You are probably running into something similar when your search fails.
I'm going to assume your code is correct, and you implemented all the algorithms and heuristics correctly.
This leaves us with the "generated randomly" part of your puzzle initialization. Are you sure you are generating correct states of the puzzle? If you generate an illegal state, obviously there will be no solution.
While the steps you have listed seem a little incomplete, you have listed enough to ensure that your A* will reach a solution if there is one (albeit not optimal as long as you are just simply skipping nodes).
It sounds like either your puzzle generation is flawed or your algorithm isn't implemented correctly. To easily verify your puzzle generation, store the steps used to generate the puzzle, and run it in reverse and check if the result is a solution state before allowing the puzzle to be sent to the search routines. If you ever generate an invalid puzzle, dump the puzzle, and expected steps and see where the problem is. If the puzzle passes and the algorithm fails, you have at least narrowed down where the problem is.
If it turns out to be your algorithm, post a more detailed explanation of the steps you have actually implemented (not just how A* works, we all know that), like for instance when you run the evaluation function, and where you resort the list that acts as your queue. That will make it easier to determine a problem within your implementation.
So I've had at least two professors mention that backtracking makes an algorithm non-deterministic without giving too much explanation into why that is. I think I understand how this happens, but I have trouble putting it into words. Could somebody give me a concise explanation of the reason for this?
It's not so much the case that backtracking makes an algorithm non-deterministic.
Rather, you usually need backtracking to process a non-deterministic algorithm, since (by the definition of non-deterministic) you don't know which path to take at a particular time in your processing, but instead you must try several.
I'll just quote wikipedia:
A nondeterministic programming language is a language which can specify, at certain points in the program (called "choice points"), various alternatives for program flow. Unlike an if-then statement, the method of choice between these alternatives is not directly specified by the programmer; the program must decide at runtime between the alternatives, via some general method applied to all choice points. A programmer specifies a limited number of alternatives, but the program must later choose between them. ("Choose" is, in fact, a typical name for the nondeterministic operator.) A hierarchy of choice points may be formed, with higher-level choices leading to branches that contain lower-level choices within them.
One method of choice is embodied in backtracking systems, in which some alternatives may "fail", causing the program to backtrack and try other alternatives. If all alternatives fail at a particular choice point, then an entire branch fails, and the program will backtrack further, to an older choice point. One complication is that, because any choice is tentative and may be remade, the system must be able to restore old program states by undoing side-effects caused by partially executing a branch that eventually failed.
Out of the Nondeterministic Programming article.
Consider an algorithm for coloring a map of the world. No color can be used on adjacent countries. The algorithm arbitrarily starts at a country and colors it an arbitrary color. So it moves along, coloring countries, changing the color on each step until, "uh oh", two adjacent countries have the same color. Well, now we have to backtrack, and make a new color choice. Now we aren't making a choice as a nondeterministic algorithm would, that's not possible for our deterministic computers. Instead, we are simulating the nondeterministic algorithm with backtracking. A nondeterministic algorithm would have made the right choice for every country.
The running time of backtracking on a deterministic computer is factorial, i.e. it is in O(n!).
Where a non-deterministic computer could instantly guess correctly in each step, a deterministic computer has to try all possible combinations of choices.
Since it is impossible to build a non-deterministic computer, what your professor probably meant is the following:
A provenly hard problem in the complexity class NP (all problems that a non-deterministic computer can solve efficiently by always guessing correctly) cannot be solved more efficiently on real computers than by backtracking.
The above statement is true, if the complexity classes P (all problems that a deterministic computer can solve efficiently) and NP are not the same. This is the famous P vs. NP problem. The Clay Mathematics Institute has offered a $1 Million prize for its solution, but the problem has resisted proof for many years. However, most researchers believe that P is not equal to NP.
A simple way to sum it up would be: Most interesting problems a non-deterministic computer could solve efficiently by always guessing correctly, are so hard that a deterministic computer would probably have to try all possible combinations of choices, i.e. use backtracking.
Thought experiment:
1) Hidden from view there is some distribution of electric charges which you feel a force from and you measure the potential field they create. Tell me exactly the positions of all the charges.
2) Take some charges and arrange them. Tell me exactly the potential field they create.
Only the second question has a unique answer. This is the non-uniqueness of vector fields. This situation may be in analogy with some non-deterministic algorithms you are considering. Further consider in math limits which do not exist because they have different answers depending on which direction you approach a discontinuity from.
I wrote a maze runner that uses backtracking (of course), which I'll use as an example.
You walk through the maze. When you reach a junction, you flip a coin to decide which route to follow. If you chose a dead end, trace back to the junction and take another route. If you tried them all, return to the previous junction.
This algorithm is non-deterministic, non because of the backtracking, but because of the coin flipping.
Now change the algorithm: when you reach a junction, always try the leftmost route you haven't tried yet first. If that leads to a dead end, return to the junction and again try the leftmost route you haven't tried yet.
This algorithm is deterministic. There's no chance involved, it's predictable: you'll always follow the same route in the same maze.
If you allow backtracking you allow infinite looping in your program which makes it non-deterministic since the actual path taken may always include one more loop.
Non-Deterministic Turing Machines (NDTMs) could take multiple branches in a single step. DTMs on the other hand follow a trial-and-error process.
You can think of DTMs as regular computers. In contrast, quantum computers are alike to NDTMs and can solve non-deterministic problems much easier (e.g. see their application in breaking cryptography). So backtracking would actually be a linear process for them.
I like the maze analogy. Lets think of the maze, for simplicity, as a binary tree, in which there is only one path out.
Now you want to try a depth first search to find the correct way out of the maze.
A non deterministic computer would, at every branching point, duplicate/clone itself and run each further calculations in parallel. It is like as if the person in the maze would duplicate/clone himself (like in the movie Prestige) at each branching point and send one copy of himself into the left subbranch of the tree and the other copy of himself into the right subbranch of the tree.
The computers/persons who end up at a dead end they die (terminate without answer).
Only one computer will survive (terminate with an answer), the one who gets out of the maze.
The difference between backtracking and non-determinism is the following.
In the case of backtracking there is only one computer alive at any given moment, he does the traditional maze solving trick, simply marking his path with a chalk and when he gets to a dead end he just simply backtracks to a branching point whose sub branches he did not yet explore completely, just like in a depth first search.
IN CONTRAST :
A non deteministic computer can clone himself at every branching point and check for the way out by running paralell searches in the sub branches.
So the backtracking algorithm simulates/emulates the cloning ability of the non-deterministic computer on a sequential/non-parallel/deterministic computer.