Turing machine that erase its input - turing-machines

I have got this question :
Consider a Turing machine Cw which erases its input, writes w on the tape, and halts while scanning the leftmost character of w. Design the Turing machine C011
I need explanation what is actual the question is and what Cw does. I kind of understand it writes empty symbol on every input it gets but the rest is unclear to me. Hope someone can help me understand the question and what is required me to do.

In your case w = 011.
Indeed, the TM should first overwrite the entire input. I think we can assume that the input does not have gaps. So as soon as the TM reads an empty space on the input tape, it should begin writing 011.
When writing the second 1, enter into a state for which there do not exist any transitions. This way you ensure that the machine halts on that position. Nothing is said explicitely about whether this state should be accepting, but it would make sense to have it as the unique accepting state.


Why is this an invalid Turing machine?

Whilst doing exam revision I am having trouble answering the following question from the book, "An Introduction to the Theory of Computation" by Sipser. Unfortunately there's no solution to this question in the book.
Explain why the following is not a legitimate Turing machine.
M = {
The input is a polynomial p over variables x1, ..., xn
Try all possible settings of x1, ..., xn to integer values
Evaluate p on all of these settings
If any of these settings evaluates to 0, accept; otherwise reject.
This is driving me crazy! I suspect it is because the set of integers is infinite? Does this somehow exceed the alphabet's allowable size?
Although this is quite an informal way of describing a Turing machine, I'd say the problem is one of the following:
otherwise reject - i agree with Welbog on that. Since you have a countably infinite set of possible settings, the machine can never know whether a setting on which it evaluates to 0 is still to come, and will loop forever if it doesn't find any - only when such a setting is encountered, the machine may stop. That last statement is useless and will never be true, unless of course you limit the machine to a finite set of integers.
The code order: I would read this pseudocode as "first write all possible settings down, then evaluate p on each one" and there's your problem:
Again, by having an infinite set of possible settings, not even the first part will ever terminate, because there never is a last setting to write down and continue with the next step. In this case, not even can the machine never say "there is no 0 setting", but it can never even start evaluating to find one. This, too, would be solved by limiting the integer set.
Anyway, i don't think the problem is the alphabet's size. You wouldn't use an infinite alphabet since your integers can be written in decimal / binary / etc, and those only use a (very) finite alphabet.
I'm a bit rusty on turing machines, but I believe your reasoning is correct, ie the set of integers is infinite therefore you cannot compute them all. I am not sure how to prove this theoretically though.
However, the easiest way to get your head around Turing machines is to remember "Anything a real computer can compute, a Turing machine can also compute.". So, if you can write a program that given a polynomial can solve your 3 questions, you will be able to find a Turing machine which can also do it.
I think the problem is with the very last part: otherwise reject.
According to countable set basics, any vector space over a countable set is countable itself. In your case, you have a vector space over the integers of size n, which is countable. So your set of integers is countable and therefore it is possible to try every combination of them. (That is to say without missing any combination.)
Also, computing the result of p on a given set of inputs is also possible.
And entering an accepting state when p evaluates to 0 is also possible.
However, since there is an infinite number of input vectors, you can never reject the input. Therefore no Turing machine can follow all of the rules defined in the question. Without that last rule, it is possible.

Theory of Computation turing machine

What are the implications of a non-blank character being over-written by a Turing machine M for the given input variable 'x'?
Intention of the question: I am trying to answer how the halting problem can be made decidable provided we have a TM which can say whether 'M' overwrites a non-blank character by Blank or not?
Remember that at the beginning of the computation, the tape (except for the input) is full of blanks. If the head never overwrites a blank, what do you think would happen?

How to prove a Turing Machine property is trivial [closed]

Imagine I have a Turing Machine Property that looks like this:
P = {M | L(M) is accepted by a Turing machine that does not halt in an even number of steps for any input}
How can I prove that this property is trivial? Or, more generally, are there good ways to prove this sort of thing?
As a hint: you can make any TM always halt within an odd number of steps by making two copies of the states - an "odd" copy and an "even" copy - and toggling back and forth between them when transitions occur. Once you've done this, how would you modify this machine so that it never halts in an even number of steps? Given that this construction works for any arbitrary TM, do you see why the above property is trivial?
Hope this helps!

How to convert a DFA to a Turing machine?

Having the diagram of a DFA, how can I convert it to a Turing Machine? Do I have to find the language that the DFA accepts and then create the Turing Machine? Or is there a direct way?
Thank you.
Each transition in a DFA reads a character of input, follows a transition, then moves to the next character of input. Once all input has been read, the DFA accepts if it's in an accepting state and rejects otherwise.
You can directly simulate this with a Turing machine. Build the finite state control of the Turing machine by creating one state for each state in the DFA. For each transition in the DFA on the character c, replace that transition in the TM with one that, on reading character c, writes back some arbitrary character to the tape (it doesn't matter what) and then moving the tape head right (to the next spot on the tape). Then, for each state, introduce a transition on the blank symbol from that state either to the accept state of the TM or the reject state of the TM (based on whether that state is accepting or rejecting). This TM effectively runs the DFA by stepping manually across the input string and finally deciding whether to accept or reject at the end of the run.
Hope this helps!

Turing machine diagram for enumerator

I am supposed to draw an enumerator for the language 0^k1^k (k>=0). I am not sure how that is different from building a Turing machine state diagram for this language: the way I understand it is that I need to build an enumerator that recognizes the aforementioned language given all strings above {0,1} by simulating the Turing machine that recognizes this language on string i for i steps, which I couldn't think how to do using a state diagram, but my teacher has pointed out that this is how we prove the equivalence between an enumerator and a Turing machine, so I thought that what we have to do is use the transition function defined for enumerators which makes the diagram look similar to the Turing machine that recognizes 0^k1^k, only instead of moving to qaccept we move to qprint for inputs in the language, and then for inputs that must be rejected we print epsilon? But how do we go about producing an infinite number of strings above the alphabet {0,1}? At the initial state the work tape and the print tape are empty. Can someone clarify these points for me? Maybe I misunderstand.
I think I finally have the enumerator notion clear, an enumerator is not supposed to read an input, it creates words in the language for which it is built:
here's the algorithm:
print epsilon on the output tape
write 01 on the work tape
go back to the front of the tape and copy its contents to the output tape
go back to the leftmost 0, replace it with 1, go to the rightmost 1 and add two 1's at the end.
go back to stage 3
i thought of another slightly different algorithm that produces a smaller number of states, and uses only {0,blank} on its work tape:
i think you might have an error there.
in stage 4, you wrote "go back to the leftmost 0, replace it with 1, go to the rightmost 1 and add two 1's at the end"
i think it should be: "go back to the leftmost 1, replace it with 0, go to the rightmost 1 and add two 1's at the end"