what is the function of a turing machine

The main question asked me to build a certain turing machine such that given a word w over {0,1}* the turing machine accepts all such words and ends in accept state with the tape string = the word apended with the number of zeros in it. I built the state diagram of this turing machine..

But now there is a question next to it which say something like –

  1. What is the function the machine you build computes ??

I dont understand what this means ?? What i can think of is that the function the question talks about is the transition function… and that just copies 0’s from w to the end of it… it doesnt computes as such anything..

Any lights on the above ??

Thanks

Universal Turing Machine algorithm

First, I learned this based on these facts:

  1. Turing machine (TM) will be define with 7-tuple Notation, M=<Q,G,b,S,d,q0,F>.
  2. Any computation rules that can use to simulate any possible TM is called Turing-Complete.
  3. Universal TM (UTM) is TM that is Turing-Complete.

Then, the question begins:

  • If we have 7-tuple Notation of any U that is UTM, Is there an algorithm to find initial tape content P that U to simulate any TM T with any I input(s)? If it exists, Does it based on each U or pattern of U? If it does, give me some example(s)? If it does, explain the algorithm?
  • Since all possible computations can be done with TM, Is there an algorithm to make TM simulate any algorithm P written in any language? If it exists, give me some example(s)?
  • If both questions above exist the algorithm, Why don’t we just make a single UTM U and use it to program itself then do every possible computation?

Can partial Turing completeness be quantified as a subset of Turing-computable functions?

Can partial Turing completeness be coherently defined this way:
An an abstract machine or programming language can be construed as Turing complete on its computable subset of Turing-computable functions.

In computability theory, several closely related terms are used to describe the computational power of a computational system (such as an abstract machine or programming language):

Turing completeness A computational system that can compute every Turing-computable function is called Turing-complete (or Turing-powerful). https://en.wikipedia.org/wiki/Turing_completeness

Transforming multi-tape Turing machines to equivalent single-tape Turing machines

We know that multi-tape Turing machines have the same computational power as single-tape ones. So every $ k$ -tape Turing machine has an equivalent single-tape Turing machine.

About the computability and complexity analysis of such a transformation:

Is there a computable function that receives as input an arbitrary multi-tape Turing machine and returns an equivalent single-tape Turing machine in polynomial time and polynomial space?

Is there a query language variant of Turing Completeness?

By this I mean a theory where you can say Language X is Query Complete so that you know that language is able to do any sort of query? I’m guessing not because some queries would run into things that a language would have to be Turing complete to work?

Why do I wonder – well you might have a relational database and a graph database and someone might say anything that can be done in the relational database can be done in the graph database (albeit at different speeds) so I would like if there were some terms DB A and DB B are both Query Complete – or if not that if there was a way to categorize levels of "query completeness" (I’m just going to assume my ill defined concept is totally understandable to everyone) so one can say stuff like "DB A is query level 4 but DB B is at query level 3, but of course much faster because of those limitations."

I sure hope (so as to not feel like a bigger idiot than normal) that the answer to this question isn’t just a flat No.

How to prove the language of all Turing Machines that accept an undecidable language is undecidable?

I want to prove that $ L=\{\langle M \rangle |L(M)\text{ is undecidable}\}$ is undecidable

I am not sure about this. This is my try :

Suppose L is decidable. Let $ E$ be the decider from $ L$ . Let $ A$ be a TM which is recognizing $ A_{TM}$ . Let $ S$ be a TM which works on input $ \langle M,w \rangle$ in the following way:

  1. Construct a TM $ N$ which works on Input $ x$ as follows: Run $ M$ on $ w$ . If $ M$ $ accepts$ run $ A$ on $ x$ and accept $ x$ if $ A$ accepts.(In this case is $ L(N)=A_{TM}$ ). If $ M$ $ rejects$ $ w$ , $ accept$ $ x$ .(In this case is $ L(N)=\Sigma^*$ )
  2. Run $ E$ on $ N$ and accept if N accepts. Otherwise reject

I am not sure if my reduction is the right way or not. Maybe someone can help to finish the reduction 🙂

Rice’s Theorem for Turing machine with fixed output

So I was supposed to prove with the help of Rice’s Theorem whether the language: $ L_{5} = \{w \in \{0,1\}^{*}|\forall x \in \{0,1\}^{*}, M_{w}(w) =x\}$ is decidable.

First of all: I don’t understand, why we can use Rice’s Theorem in the first place: If I would chose two Turingmachines $ M_{w}$ and $ M_{w’}$ with $ w \neq w’$ then I would get $ M_{w}(w) = M_{w’}(w) = x$ . But this would lead to $ w’$ not being in $ L_{5}$ and $ w \in L_{5}$ . Or am I misunderstanding something?

Second: The solution says, that the Language $ L_{5}$ is decidable as $ L_{5} = \emptyset$ because the output is clearly determined with a fixed input. But why is that so? I thought that $ L_{5}$ is not empty because there are TM which output x on their own input and there are some which do not.

Limiting where a Turing Machine can write

Suppose I have a Turing Machine A, generated by somebody else, trying to break my system. To break my system they would have to write to the tape at some point X (this can be a range of the tape).

If I can force the machine A to be in some state q1 at some point, can I make a Turing Machine B such that for any Machine A it will never write in X?