Turing machine without return equivalent to Finite Automaton, PushDown Automaton or Turing Machine?

Informally, a pushdown automaton has a way to store and use an infinite amount of memory (the stack). In a Turing machine, the only way to store an infinite amount of memory is to write it on the tape. But in a Turing machine without return, you cannot go back to the cells that you have already written, so that memory can never be used.

That means that a Turing machine without return cannot be “as powerful” as a pushdown automaton. The solution is a finite automaton.

If you want a more formal proof, you can start with the formal definition of a Turing machine without return, note that you can dismiss what you write on the tape (because you can’t go back), and construct a finite automaton that recognize the same language as the Turing machine.

finite automata – Thinking about how an automaton can be created that accepts a language that switches the first and second alphabet

I have been thinking about this problem for quite a while, but to no avail.

Say I have a deterministic automaton M (you can assume it to be the 5-tuple (Q, sigma, q0, delta, F), which is given to accept a language L.

How do we create an automaton that would accept the language that has the first and second letter of the language L switched (given that the first and second letter in fact exist in a string accepted by M).

Is there an easy way to do this?

automata – What’s the difference between a Generalized Nondeterministic Finite Automaton (GNFA) and a Generalized Transition Graph (GTG)?

I’ve recently come across a few articles that talk about a “Generalized Transition Graph” (GTG), but I’ve never heard of such a thing before. This other answer to a similar question leads me to believe that GNFAs are simply GTGs with a different name where GNFA is the more standard nomenclature/name.

There is a Wikipedia article on GNFAs that describes them as:

…a variation of a nondeterministic finite automaton (NFA) where each transition is labeled with any regular expression.

which from what I understand is described by others as a GTG. Unfortunately, there’s no article on Generalized Transition Graphs on Wikipedia. The definitions for GTGs that I have come across are:

So again, are GNFAs the same as GTGs?

Finite automaton for all words whose length $n$ satisfies $operatorname{gcd}(n,504) geq 6$

I have been working on the following homework question, and I just can’t seem to make any progress:

Construct a finite automaton having fewer than 36 states that recognizes the language ${s in a^* : operatorname{gcd}(|s|, 504) geq 6}$, where $|s|$ is the length of $s$.

So far I have been trying to figure out a regular pattern in $504$ and have broken it down to the prime factorization $504 = 2^3 cdot 3^2 cdot 7$, which means that all divisors must be multiples of 2, 3, or 7. However I don’t know how to create the finite automaton (NFA or DFA). Any help is appreciated!

automata – Whether there exists a probabilistic automaton satisfying $Pr { x in L}=frac{Pr { x in L_1}}{Pr { x in L_1}+Pr { x in L_2}}$

Suppose that there are two probabilistic automata $A_1$ and $A_2$ with a same finite alphabet $Sigma$. The languages of them are $mathcal{L}_{1} subseteq Sigma^*$ and $mathcal{L}_{2} subseteq Sigma^*$ respectively.

For every input $x in Sigma^*$, $Pr { x in mathcal{L}_{1}}=p_1(x)$ and $Pr { x in mathcal{L}_{2}}=p_2(x)$. Whether there exists a probabilistic automaton $A$ satisfying $$Pr { x in mathcal{L}}=frac{p_1(x)}{p_1(x)+p_2(x)}$$ where $mathcal{L} subseteq Sigma^*$ is the language of $A$?

Finite automaton for ${0^{2n} : n ge 0 } cup {(100)^m : m ge 0}$

I have to construct an FA for the following language:
{ w_1,w_2 in {a,b}^* mid w_1 = 0^{2n}, w_2 = (100)^m, text{ for some } n,m in mathbb{N} }.

Does anyone here have any experience with something like that? I’m totally lost how I should draw an FA for something like that. Would appreciate any kind of input or approach to this problem.

automata – On the queue automaton and acceptance of this language

We have this language:
$$ L = {𝑥𝑥^r|𝑥∈Σ^∗} $$

We want to show that it can be accepted by QA.

  1. consider a letter like #, before anything we push it to the queue.
  2. using this additional letter, we push every letter we get such that it would be the first letter of the string inside the queue (i.e. letter after #)
  3. then (using Lambda Transition), we remove # from the queue, and we pop the letters come from input one by one out of queue. E.g. we get abccba from the input, we want to get string:
    in the queue, then remove # to reach abcE. then from this point when we get c from the input, we remove c from the queue’s head.

Is this approach correct? Could you show me the queue automaton of it?

Thanks in advance.

turing machines – Where to put the state in a two-stack push down automaton?

theoretically, the state is between the two kleene-stars of the work-alphabet

gamma* q gamma*

where q is the current state and each gamma* is the content of one of both stacks. But where is “the middle” with the state? Regarding the one tape of the classical Turing Machine it is obvious.

von Spotz