Largest subset of $RE$ whose automata are decidable

Question

Recall that the Chomsky hierarchy that says regular languages correspond to (non)deterministic finite-state machines, context-free languages correspond to non-deterministic pushdown automata, and recursively enumerable languages ($RE$) correspond to Turing machine. And we have

$$ \mbox{regular} \subset \mbox{context free} \subset R \subset RE.$$

As we get to a larger set of languages, the corresponding computation model gets stronger. For example, Turing machine is notoriously known for not guaranteeing to halt. Hence people restrict its ability a bit, by considering recursive languages ($R$), which correspond to total Turing machines (i.e. those that always halt; see Is there an always-halting, limited model of computation accepting $R$ but not $RE$?).

However, this is not good enough in the sense that it is undecidable to recognize total Turing machines among all Turing machines. Thus it is natural to reduce even further:

Question. What is the largest subset $D \subset RE$, such that the corresponding automata $A_{D}$ are decidable by Turing machines?

Here, $A_{D}$ is defined to be

$$\{x \in TM \,|\, x\mbox{ accepts some d }\in D\},$$

where $TM$ is the set of Turing machines. The problem of whether a given $x \in TM$ is an element of $A_{D}$ should be a decidable problem.

Answer 1

There is no largest subset. Given any subset $D$ that satisfies those conditions, we can construct $D'=D \cup \{L\}$ where $L$ is one language such that $L \notin D$ and $L$ is accepted by some Turing machine. Then $D'$ will satisfy the conditions, too.

If you are interested in such classes, you might be interested in automata theory and complexity theory, where you can find many examples that satisfy these conditions. In automata theory, you might be interested in linear bounded automata (i.e., context-sensitive languages), stack automata, alternating pushdown automata, tree automata, counter machines, and Petri nets. Consult automata theory textbooks or courses for more.

As far as complexity theory, my guess is that most or all complexity classes qualify for your requirements. Let's focus on $P$, the class of all languages that can be accepted by a polynomial-time Turing machine. I claim that it satisfies your requirements. Consider Turing machines that are of the following form:

• Let $n := $ the length of the input.
• For $i:=1,2,\dots,p(n)$:
  • Simulate one step of $B$.
  • If $B$ halts and accepts, halt and accept. If $B$ halts and rejects, halt and reject.
• Halt and reject.

Here $p(n)$ is some polynomial, and $B$ is some Turing machine. This is a template for a Turing machine; if you fix a simulation strategy (universal TM), then once you fill in $p(n),B$, you obtain a Turing machine. The set of "automata" are all Turing machines of this sort. I claim that every language $L \in P$ is accepted by some Turing machine of this form (some "automaton"), and every Turing machine of this form accepts some language in $P$. The latter is obvious, as the running time is obviously at most a polynomial of $n$. For the former, consider any language $L \in P$. $L$ must be accepted by some Turing machine $B$, and let $p(n)$ be a polynomial that is an upper-bound on the worst-case running time of $B$; by the definition of $P$, there is some $B,p(n)$ for which this holds. Then filling in $B,p(n)$ into the template above yields a Turing machine ("automaton") $A$ of the desired form that accepts $L$. This demonstrates that every language in $P$ is accepted by such an automaton, and therefore that $P$ meets your requirements. I expect something similar can be proven for most or all other standard complexity classes.