Automatic Structures — Recent Results and Open Questions

It would be of interest to separate nondeterminism from determinism i.e., to show that for all nice functions t(n), NTIME (t(n)), (the class of languages accepted by multitape nondeterministic Turing machines in time O(t(n))) strictly contains DTIME (t(n)) (the class of languages accepted by multitape deterministic Turing machines in time O(t(n)). We establish a weaker form of the statement. We show that there is a universal constant k such that for all nice functions t(n), the class of languages that can be accepted simultaneously in deterministic time O(t(n)) and space o((t(n))1/k) is strictly contained in NTIME (t(n)). (We will use the notation SPACE, TIME (s(n),t(n)) to denote the class of languages accepted by a deterministic TM in time O(t(n)) and simultaneously space O(s(n)).) This result is proved using a time-alternation trade-off and several other applications of this trade-off are presented. For example, we show that for each language L in SPACE, TIME (nl-e, ni) (where o≪e≪l, e, i constants) there exists a j such that L is accepted by a O(n) time bounded alternating Turing machine with j alternations. The trade-off also leads to the separation ∪SeSt SPACE, TIME (s,t)⊂+Σ2 TIME(t) where t(n) is any nice function and St is a class of nice functions in o(t). Here St includes most natural functions for natural t. For example, nj/log*n is in Snj.

An injection structure \({\mathcal A}= (A,f)\) is a set A together with a one-place one-to-one function f. \({\mathcal A}\) is a Finite State Transducer (abbreviated FST) injection structure if A is a regular set, that is, the set of words accepted by some finite automaton, and f is realized by a deterministic finite-state transducer. Automatic relational structures have been well-studied along with the isomorphism problem for automatic structures. For an FST injection structure (A, f), the graph of f is not necessarily automatic. We continue the study of the complexity of FST injection structures by showing that the isomorphism problem for unary FST injection structures is decidable in quadratic time in the size (number of states) of the FST.KeywordsComputability theoryInjection structuresAutomatic structuresFinite state automataFinite state transducers

Wang’s B machines are efficiently universal, as is Hasenjaeger’s small universal electromechanical toy

Domino games which describe computations of alternating Turing machines in the same way as dominoes (tiling systems) encode computations of deterministic and nondeterministic Turing machines are considered. The domino games are two-person games in the course of which the players build up domino tilings of a square of prescribed size. Acceptance of an alternating Turing machine corresponds to a winning strategy for one player—the number of moves in the game is the number of alternations of the Turing machine. Let $\operatorname{ATIME}(T(n), m)$ denote the class of all sets that are accepted by some alternating Turing machine in time $T(n)$ with at most m alternations. It is shown that any problem in such a complexity class can be reduced to the strategy problem for some domino game. In particular domino games which are complete in the classes $\Sigma_{m}^{p}$, and $\Pi_{m}^{p}$, of the polynomial time hierarchy are found. This corresponds to the approach of Savelsbergh and van Emde Boas and of Lewis and Papadimitriou, who have shown that the theory of NP-completeness may also be founded on a finite domino problem instead of the satisfiability problem for propositional formulae. Similar generalizations are possible for domino connectability problems: Domino thread games where the players build up a thread of dominoes are introduced; the first player wins if he can ultimately connect two given points. It is shown that a certain class of such games captures deterministic time complexity. In particular, games are found whose strategy problems are P-complete. In the last section applications to the complexity of simple prefix classes in logical theories are briefly discussed.

Let Σ be an arbitrary alphabet. denotes ɛ∪Σ∪...∪Σn. We say that a function t, t : is f-sparse iff card for every natural n. The main theorem of this paper establishes that if CLIQUE has some f-sparse translation into another set, which is calculable by a deterministic Turing machine in time bounded by f, then all the sets belonging to NP are calculable in time bounded by a function polynomially related to f. The proof is constructive and shows the way of constructing a proper algorithm. The simplest and most significant corollary says that if there is an NP-complete language over a single letter alphabet, then P=NP.

There are essentially two results described in this paper. First, it is shown that for any random access machine (RAM) time-constructable function $T(n) \geqq n$, there are languages L such that L can be recognized in time $O(T(n))$ by a RAM (using the unit cost measure), but L cannot be recognized by any deterministic multitape Turing machine in time $O(T(n))$. Secondly, a family of random access stored program machines (RASP’S) are considered. For these RASP’S it is shown that there is an arbitrarily complex (infinitely often) partial recursive function $f(n)$. which has only 0–1 values (whenever defined) such that $f(n)$ can be computed in time $F(n)$ by some RASP, but cannot be computed in time $(1 - \varepsilon )F(n)$, for any $\varepsilon > 0$, by any RASP in this family.

Isomorphism of regular trees and words

The paper gives a logical characterisation of the class NTIME(n) of problems that can be solved on a nondeterministic Turing machine in linear time. It is shown that a set L of strings is in this class if and only if there is a formula of the form ∃f 1··∃f k ∃R 1··∃R m ∀xϕ that is true exactly for all strings in L. In this formula the f i are unary function symbols, the R i are unary relation symbols and ϕ is a quantifier-free formula. Furthermore, the quantification of functions is restricted to non-crossing, decreasing functions and in ϕ no equations in which different functions occur are allowed. There are a number of variations of this statement, e.g., it holds also for k = 3. From these results we derive an Ehrenfeucht game characterisation of NTIME(n).KeywordsLinear TimeTuring MachineDerivation TreeRelational AtomLogical CharacterisationThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Totalistic cellular automata, introduced by S. Wolfram, are cellular automata in which the state transition function depends only on the sum of the states in a cell's neighborhood. Each state is considered as a nonnegative integer and the sum includes the cell's own state. It is shown that one-dimensional totalistic cellular automata can simulate an arbitrary Turing machine in linear time, even when the neighborhood is restricted to one cell on each side. This result settles Wolfram's conjecture that totalistic cellular automata are computation-universal.

We consider depth 2 unbounded fan-in circuits with symmetric and linear threshold gates. We present a deterministic algorithm that, given such a circuit with n variables and m gates, counts the number of satisfying assignments in time $$2^{n-\Omega \left( \left( \frac{n}{\sqrt{m} \cdot \textrm{poly}(\log n)}\right) ^a\right) }$$ 2 n - Ω n m · poly ( log n ) a for some constant $$a>0$$ a > 0 . Our algorithm runs in time super-polynomially faster than $$2^n$$ 2 n if $$m=O(n^2/\log ^b n)$$ m = O ( n 2 / log b n ) for some constant $$b>0$$ b > 0 . Previously, such algorithms were only known for bounded depth circuits with linear threshold gates and a slightly super-linear number of wires [Impagliazzo-Paturi-Schneider, FOCS 2013 and Chen-Santhanam-Srinivasan, CCC 2016]. We also show that depth 2 circuits with $$O(n^2/\log ^b n)$$ O ( n 2 / log b n ) symmetric and linear threshold gates in total cannot compute an explicit function computable by a deterministic $$2^{O(n)}$$ 2 O ( n ) -time Turing machine with an NP oracle. Previously, even slightly super-linear lower bounds on the number of gates were not known until recently Kane and Williams [STOC 2016] showed that depth 2 linear threshold circuits with $$o(n^{3/2}/\log ^3 n)$$ o ( n 3 / 2 / log 3 n ) gates cannot compute an explicit function computable in linear time.

Realtime subshifts

We study local symmetry breaking problems in the Congest model, focusing on ruling set problems, which generalize the fundamental Maximal Independent Set (MIS) problem. The time (round) complexity of MIS (and ruling sets) have attracted much attention in the Local model. Indeed, recent results (Barenboim et al., FOCS 2012, Ghaffari SODA 2016) for the MIS problem have tried to break the long-standing O(log n)-round "barrier" achieved by Luby's algorithm, but these yield o(log n)-round complexity only when the maximum degree Delta is somewhat small relative to n. More importantly, these results apply only in the Local model. In fact, the best known time bound in the Congest model is still O(log n) (via Luby's algorithm) even for moderately small Delta (i.e., for Delta = Omega(log n) and Delta = o(n)). Furthermore, message complexity has been largely ignored in the context of local symmetry breaking. Luby's algorithm takes O(m) messages on m-edge graphs and this is the best known bound with respect to messages. Our work is motivated by the following central question: can we break the Theta(log n) time complexity barrier and the Theta(m) message complexity barrier in the Congest model for MIS or closely-related symmetry breaking problems?
\n
\nThis paper presents progress towards this question for the distributed ruling set problem in the Congest model. A beta-ruling set is an independent set such that every node in the graph is at most beta hops from a node in the independent set. We present the following results:
\n
\n- Time Complexity: We show that we can break the O(log n) "barrier" for 2- and 3-ruling sets. We compute 3-ruling sets in O(log n/log log n) rounds with high probability (whp). More generally we show that 2-ruling sets can be computed in O(log Delta (log n)^(1/2 + epsilon) + log n/log log n) rounds for any epsilon > 0, which is o(log n) for a wide range of Delta values (e.g., Delta = 2^(log n)^(1/2-epsilon)). These are the first 2- and 3-ruling set algorithms to improve over the O(log n)-round complexity of Luby's algorithm in the Congest model.
\n
\n- Message Complexity: We show an Omega(n^2) lower bound on the message complexity of computing an MIS (i.e., 1-ruling set) which holds also for randomized algorithms and present a contrast to this by showing a randomized algorithm for 2-ruling sets that, whp, uses only O(n log^2 n) messages and runs in O(Delta log n) rounds. This is the first message-efficient algorithm known for ruling sets, which has message complexity nearly linear in n (which is optimal up to a polylogarithmic factor).

Unlike the wreath product, the block product is not associative at the level of varieties. All decomposition theorems involving block products, such as the bilateral version of Krohn–Rhodes' theorem, have always assumed a right-to-left bracketing of the operands. We consider here the left-to-right bracketing, which is generally weaker. More precisely, we are interested in characterizing for any pseudovarieties of monoids U, V the smallest pseudovariety W that contains U and such that W □ V = W. This allows us to obtain new decomposition results for a number of important varieties such as DA, DO and DA * G. We apply these results to characterize the regular languages definable with generalized first-order sentences using only two variables and to shed new light on recent results on regular languages recognized by bounded-depth circuits with a linear number of wires and regular languages with small communication complexity.

We will show how padding techniques can be applied on onedimensional cellular automata by proving a transfer theorem on complexity classes (how one inclusion of classes implies others). Then we will discuss the consequences of this result, in particular when considering that all languages recognized in linear space can be recognized in linear time (whether or not this is true is still an open question), and see the implications on one-tape Turing machines.

A neural network composed of a finite number of continuous value output neurons is known to be able to simulate any deterministic Turing machine. Several simulation models have been proposed, but there remains the problem that a massive number of neurons is needed to simulate the tape part in real time. In this paper the authors demonstrate that a recurrent higher‐order neural network can simulate any Turing machine, then specify the lower limit for the number of neurons required and the time needed for the simulation. First, the authors show that a recurrent higher‐order neural network consisting of a limited number of neurons using a threshold input/output function and a linear input/output function can simulate any deterministic Turing machine in real time, and that the number of neurons required to simulate the tape can be reduced to six. Then the authors show that if a saw‐type function is used, the number of neurons required for the simulation can be reduced to four. A simplified simulation model is then offered as a viable framework for learning formal language using a neural network. © 2001 Scripta Technica, Syst Comp Jpn, 32(10): 42–50, 2001