## Is this language decidable - turing-machines

### Given the encoding of a specific Turing machine, can it be decided if it will halt on a specific input?

```Say I have the Universal Turing Machine encoding of a specific Turing machine T. Also say I have the encoding of a specific input s. Is the question of whether T halts on s decidable? Can simulating running T on s be used to reach an answer?
```
```This problem is decidable in all instances. Any specific, fixed TM either halts or doesn't on any specific, fixed input, assuming for the moment that the excluded middle is not something you want to challenge here. For a specific instance of your problem where you are fixing the TM and input, the TM should either halt-accept for all inputs (not the specific, fixed input with which you are parameterizing the problem, but the typical input to the TM which will solve our parameterized problem) if that specific instance if the problem has a TM halting on the supplied input, or it should halt-reject if that specific instance has a TM that fails to halt.
The difficulty is that for any specific instance of the problem, we know that the specific TM either halts or doesn't given the specific input, but we don't have any computationally effective way to know which is the case. Certainly one or the other is (again, whether you accept the excluded middle is a larger discussion) and therefore the specific instance of the problem is decidable - regular, even - but that doesn't help us too much, except to understand computability a little better.
Note that there are lots of instances of this problem where we could know which of the two cases holds; for instance, it is not hard to produce TMs which halt, or fail to halt, on any or all inputs. Those instances of the problem are not only decidable and regular, but we know which decidable/regular languages they are.```

### L = {T | T is a turing machine that recognizes {00, 01}} Prove L is undecidable

```L = {<T> | T is a turing machine that recognizes {00, 01}}
Prove L is undecidable.
I am really having difficulties even understanding the reduction to use here.
```
```A direct application of Rice's theorem will let you prove this without doing any work at all.
Some Turing machines recognize {00, 01}. Some don't. The difference is semantic in that it has to do with the strings accepted, not the structure of the automaton. Hence, by Rice's theorem, this set is undecidable.```

### Is this language decidable, recognizable, or unrecognizable?

```The language L that consists of all Turing Machine descriptions M, for which the language accepted by M is finite.
I said L is a decidable language because I can just run M on a function D(M) that returns false if there exists a loop somewhere between start and accept state of M, and returns true otherwise.
I have a feeling that I am wrong because I am underestimating the difficulty of detecting an infinite loop.
Assistance is appreciated, thank you in advance.
```
```If you could decide this language, you could decide the halting problem.
Suppose M is a machine and x is its input. The halting problem is to say whether or not M halts on x. Consider a machine N that clears the tape and writes x in place of whatever input was there before. Now consider the machine obtained by running N and then running M. This machine accepts all inputs if M accepts x, and no inputs otherwise. If you could say for any machine whether the language accepted is finite, you'd be able to say whether M halts on x or not. But that was the halting problem.```

### Universal turing machine U should determine if M(x) stops

```so we have a universal turing machine U, that should determine if a turing machine M with input x will stop. The solution should be presented in pseudo code.
can someone help me a bit out, who should i solve it ?
```
```This sounds like the halting problem:
The halting problem can be stated as follows: "Given a description of an arbitrary computer program, decide whether the program finishes running or continues to run forever". This is equivalent to the problem of deciding, given a program and an input, whether the program will eventually halt when run with that input, or will run forever.
Alan Turing proved in 1936 that a general algorithm to solve the halting problem for all possible program-input pairs cannot exist. A key part of the proof was a mathematical definition of a computer and program, what became known as a Turing machine; the halting problem is undecidable over Turing machines.
So no, it's not possible.
If you want, you can probably run M on x for a while. If it stops, we know it stops. If it doesn't stop, we don't really know whether or not it stops.```

### Turing Machines and Machine Schemas

```Arthur Dent, using space age technology not yet available on earth developed an algorithm which determines if a TM M1 halts or not when started on a blank tape. But then later, he discovered that the meaning to life, the universe, and everything is 42.
(a) [5] Given a TM M2, prove that Arthur can determine if M2 halts or not on the input 42 using the program he already developed which determines if a TM M1 halts or not when started on a blank tape. If you create a new TM in your proof, give its machine schema.
(b) [5] Suppose there is a program which is faster than Arthur's but it answers the question of whether a TM M2 halts on input 42. Explain how Arthur can use this algorithm to determine if some TM M1 halts when started on a blank tape. If you create a new TM in your proof, give its machine schema.
(c) [5] We proved in class that that the problem of determining if a TM M halts when started on a blank tape is not decidable. Is it part (a) or part (b) which can be used to prove that it is also undecidable to determine if a TM M halts on input 42?
Can anyone help me decipher what my prof is talking about here?
```
```Welcome to some really complicated computer science theory. Try starting here: http://en.wikipedia.org/wiki/Halting_problem
Google Turing Machine as well if you're not familiar with that.```