A characterization of the power of vector machines

A new formal model of register machines is described. Registers contain bit vectorswhich are manipulated using bitwise Boolean operations and shifts. Our main results relate the language recognition power of such vector machines to that of Turing machines. A class of vector machines is exhibited for which time on a vector machine supplies, to within a polynomial, just as much power as space on a Turing machine. Moreover, this is true regardless of whether the machines are deterministic or non-deterministic

Tree-size bounded alternation

AbstractThe size of an accepting computation tree of an alternating Turing machine (ATM) is introduced as a complexity measure. We present a number of applications of tree-size to the study of more traditional complexity classes. Tree-size on ATMs is shown to closely correspond to time on nondeterministic TMs and on nondeterministic auxiliary pushdown automata. One application of the later is a useful new characterization of the class of languages log-space-reducible to context-free languages. Surprising relationships with parallel-time complexity are also demonstrated. ATM computations using at most space S(n) and tree-size Z(n) (simultaneously) can be simulated in alternating space S(n) and time S(n) · log Z(n) (simultaneously). Several well-known simulations, e.g., Savitch's theorem, are special cases of this result. It also leads to improved parallel complexity bounds for many problems in terms of both time and number of “processors.” As one example we show that context-free language recognition in time O(log2 n) is possible on several parallel models. Further, this bound is achievable with only a polynomial number of processors, in contrast to all previously known sub-linear time CFL recognizers

Discontinuities in recurrent neural networks

This paper studies the computational power of various discontinuous real computational models that are based on the classical analog recurrent neural network (ARNN). This ARNN consists of finite number of neurons; each neuron computes a polynomial net-function and a sigmoid-like continuous activation-function. The authors introducePostprint (published version

The RAM equivalent of P vs. RP

One of the fundamental open questions in computational complexity is whether the class of problems solvable by use of stochasticity under the Random Polynomial time (RP) model is larger than the class of those solvable in deterministic polynomial time (P). However, this question is only open for Turing Machines, not for Random Access Machines (RAMs). Simon (1981) was able to show that for a sufficiently equipped Random Access Machine, the ability to switch states nondeterministically does not entail any computational advantage. However, in the same paper, Simon describes a different (and arguably more natural) scenario for stochasticity under the RAM model. According to Simon's proposal, instead of receiving a new random bit at each execution step, the RAM program is able to execute the pseudofunction $\textit{RAND}(y)$, which returns a uniformly distributed random integer in the range $[0,y)$. Whether the ability to allot a random integer in this fashion is more powerful than the ability to allot a random bit remained an open question for the last 30 years. In this paper, we close Simon's open problem, by fully characterising the class of languages recognisable in polynomial time by each of the RAMs regarding which the question was posed. We show that for some of these, stochasticity entails no advantage, but, more interestingly, we show that for others it does.Comment: 23 page

Computing with and without arbitrary large numbers

In the study of random access machines (RAMs) it has been shown that the availability of an extra input integer, having no special properties other than being sufficiently large, is enough to reduce the computational complexity of some problems. However, this has only been shown so far for specific problems. We provide a characterization of the power of such extra inputs for general problems. To do so, we first correct a classical result by Simon and Szegedy (1992) as well as one by Simon (1981). In the former we show mistakes in the proof and correct these by an entirely new construction, with no great change to the results. In the latter, the original proof direction stands with only minor modifications, but the new results are far stronger than those of Simon (1981). In both cases, the new constructions provide the theoretical tools required to characterize the power of arbitrary large numbers.Comment: 12 pages (main text) + 30 pages (appendices), 1 figure. Extended abstract. The full paper was presented at TAMC 2013. (Reference given is for the paper version, as it appears in the proceedings.

Reflective Relational Machines

AbstractWe propose a model of database programming withreflection(dynamic generation of queries within the host programming language), called thereflective relational machine, and characterize the power of this machine in terms of known complexity classes. In particular, the polynomial time restriction of the reflective relational machine is shown to express PSPACE, and to correspond precisely to uniform circuits of polynomial depth and exponential size. This provides an alternative, logic based formulation of the uniform circuit model, which may be more convenient for problems naturally formulated in logic terms, and establishes that reflection allows for more “intense” parallelism, which is not attainable otherwise (unless P=PSPACE). We also explore the power of the reflective relational machine subject to restrictions on the number of variables used, emphasizing the case of sublinear bounds