Indirect addressing and the time relationships of some models of sequential computation

In the realm of sequential computing, the random access machine has successfully provided an underlying model of computation that has promoted consistency and coordination among algorithm developers, computer architects and language experts. In the realm of parallel computing, however, there has been no similar success. The need for such a unifying parallel model or set of models is heightened by the greater demand for performance and the greater diversity among machines. Yet the modeling of parallel computing still seems to be mired in controversy and chaos. This paper presents a broad range of models of parallel computation and the different roles they serve in algorithm, language and machine design. The objective is to better understand which model characteristics are important to each design community, in order to elucidate the requirements of a unifying paradigm. As an impetus for discussion, we conclude by suggesting a model of parallel computation which is consistent with a model design philosophy that balances simplicity and descriptivity with prescriptivity. We present only the survey of abstract computational models. This introduction should provide insights into the rich array of relevant issues in other disciplines. >

On the presence of periodic configurations in Turing machines and in counter machines

The oritatami system (OS) is a model of computation by cotranscriptional folding, being inspired by the recent experimental succeess of RNA origami to self-assemble an RNA tile cotranscriptionally. The OSs implemented so far, including binary counter and Turing machine simulator, are deterministic, that is, uniquely fold into one conformation, while nondeterminism is intrinsic in biomolecular folding. We introduce nondeterminism to OS (NOS) and propose an NOS that chooses an assignment of Boolean values nondeterministically and evaluates a logical formula on the assignment. This NOS is seedless in the sense that it does not require any initial conformation to begin with like the RNA origami. The NOS allows to prove the co-NP hardness of deciding, given two NOSs, if there exists no conformation that one of them folds into but the other does not.

Theoretical models of computation (automata, Turing machines, random access machines, etc.) define not only what is computable but determine how much time and/or space is required for a computation. The parallel extensions of the sequential models usually offer significant speedup in algorithm execution (not all algorithms can be parallelized, however). Real parallel computer architectures based on these parallel computation models should exhibit the same algorithmic speedup. A complexity hierarchy can be defined for parallel computation models based on the space and/or time speedup of certain classes of algorithms. In particular the parallel shared memory models1 are some of the more powerful of the parallel computation models. Their close resemblance to actual computer architectures provide guidance for real architectural design and their massive interconnection requirements are well suited for implementation in optical computing architectures. In addition, the shared memory models have recently been shown to simulate deterministic Boltzmann machines and threshold-logic Turing machines. Thus optical machines based on these parallel models can potentially exhibit the computational power of the shared memory models. These parallel computation models and their implications for optical computing are discussed.

The article is written in support of the educational discipline “Non-classical logics”. Within the framework of this discipline, the objects of study are the basic principles and constructive elements, with the help of which the formal construction of various non-classical propositional logics takes place. Despite the abstractness of the theory of non-classical logics, in which the main attention is paid to the strict mathematical formalization of logical reasoning, there are real practical areas of application of theoretical results. In particular, languages of temporal modal logics are widely used for modeling, specification, and verification (correctness analysis) of logic control program systems. This article demonstrates, using the linear temporal logic LTL as an example, how abstract concepts of non-classical logics can be reƒected in practice in the field of information technology and programming. We show the possibility of representing the behavior of a software system in the form of a set of LTL-formulas and using this representation to verify the satisfiability of program system properties through the procedure of proving the validity of logical inferences, expressed in terms of the linear temporal logic LTL. As program systems, for the specification of the behavior of which the LTL logic will be applied, Minsky counter machines are considered. Minsky counter machines are one of the ways to formalize the intuitive concept of an algorithm. They have the same computing power as Turing machines. A counter machine has the form of a computer program written in a high-level language, since it contains variables called counters, and conditional and unconditional jump operators that allow to build loop constructions. It is known that any algorithm (hypothetically) can be implemented in the form of a Minsky three-counter machine.

Well-known hierarchies discriminate between the computational power of discrete time and space dynamical systems. A contrario the situation is more confused for dynamical systems when time and space are continuous. A possible way to discriminate between these models is to state whether they can simulate Turing machine. For instance, it is known that continuous systems described by an ordinary differential equation (ODE) have this power. However, since the involved ODE is defined by overlapping local ODEs inside an infinite number of regions, this result has no significant application for differentiable models whose ODE is defined by an explicit representation. In this work, we considerably strengthen this result by showing that Time Differentiable Petri Nets (TDPN) can simulate Turing machines. Indeed the ODE ruling this model is expressed by an explicit linear expression enlarged with the “minimum” operator. More precisely, we present two simulations of a two counter machine by a TDPN in order to fulfill opposite requirements: robustness and boundedness. These simulations are performed by nets whose dimension of associated ODEs is constant. At last, we prove that marking coverability, submarking reachability and the existence of a steady-state are undecidable for TDPNs.KeywordsTuring MachineHybrid AutomatonTransition PairCurrent InstructionCounter MachineThese 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.

We describe an asymptotically optimal data-structure for dynamic point location for horizontal segments. For n line-segments, queries take O(log n) time, updates take O(log n) amortized time and the data structure uses O(n) space. This is the first structure for the problem that is optimal in space and time (modulo the possibility of removing amortization). We also describe dynamic data structures for orthogonal range reporting and orthogonal intersection reporting. In both data structures for n points (segments) updates take O(log n) amortized time, queries take O(log n+k log n/log log n) time, and the structures use O(n) space, where k is the size of the output. The model of computation is the unit cost RAM.

The purpose of a model of computation is to provide the algorithm designer a device for running algorithms. It should be conceptually clear to let him or her concentrate at the algorithmic ideas for solving the problem. At the same time it should be concrete enough to give a realistic estimate on the use resources, when the algorithm is executed on a real computer. In this paper we analyze some weaknesses of existing models of computation, namely sequential access machine and random access machine, and propose a new cost model, called relative cost random access machine, which solves some contradictions between these models. The new model actually only generalizes the way of counting the complexity, and includes sequential access machines and random access machines as special cases. At the same time, it is flexible enough to characterize the cost of memory access in current computers.

This chapter describes a Turing machine built from patterns in the Conway’s Game of Life cellular automaton. It outlines the architecture of the construction, the structure of its parts and explains how the machine works. It also illustrates the principle choices made during the design0 [17]. Background information about Turing machines, minimal universal Turing machines (those that simulate any other Turing machine) and non-erasing Turing machines can be found in [20,7,15,14,18]. The importance of Turing machines is the existence of universal Turing machines. Thus a machine that can simulate any Turing machine can simulate a universal Turing machine. It has been proved that Turing machines can be simulated by many types of machine: cellular automata (as one can see in this and other chapters of this book), random access machines [4], register machines [1] and others. In particular Minsky [16] describes a register machine which can simulate a Turing machine. The registers have the unusual property of being able to store positive numbers of any size. Remarkably, a long time ago Conway described [1] a method of constructing a register of this form in the Game of Life. This is discussed later in this chapter.

A realistic model of computation called the block-move (BM) model is developed. The BM regards computation as a sequence of finite transductions in memory, and operations are timed according to a memory cost parameter $\mu $. Unlike previous memory-cost models, the BM provides a rich theory of linear time, and in contrast to what is known for Turing machines (TMs), the BM is proved to be highly robust for linear time. Under a wide range of $\mu $ parameters, many forms of the BM model, ranging from a fixed-wordsize random-access machine (RAM) down to a single finite automaton iterating itself on a single tape, are shown to simulate each other up to constant factors in running time. The BM is proved to enjoy efficient universal simulation, and to have a tight deterministic time hierarchy. Relationships among BM and TM time complexity classes are studied.

This article is written in support of the academic discipline “Nonclassical logics”. The objects of study within this discipline are the basic principles and constructive elements used in formal construction of various nonclassical propositional logics. Despite the abstract nature of the theory of nonclassical logics, which is mainly focused on strict mathematical formalization of logical reasoning, there are real practical applications for its theoretical results. In particular, languages of temporal modal logics are widely used for modeling, specification, and verification (correctness analysis) of logic control program systems. This article demonstrates, based on the example of linear temporal logic (LTL), how abstract concepts of nonclassical logics can be applied in practice in the area of information technology and programming. It is shown that the behavior of a software system can be represented as a set of LTL formulas, which can then be used to check the satisfiability of the properties of that software system via the procedure for proving the validity of logical inferences expressed in terms of linear temporal logic (LTL). The approach to using LTL to specify the behavior of software systems is demonstrated based on Minsky counter machines. Minsky machines are one of the ways of formalizing the intuitive concept of an algorithm. Their computational power is equivalent to that of Turing machines. A counter machine is a computer program written in a high-level language, since it contains variables called counters and conditional and unconditional jump operators used for loop construction. It is known that any algorithm can (hypothetically) be implemented as a three-counter Minsky machine.

It is well-known that non-comparison-based techniques can allow us to sort n elements in o(n log n) time on a Random-Access Machine (RAM). On the other hand, it is a long-standing open question whether (non-comparison-based) circuits can sort n elements from the domain [1..2k] with o(kn log n) boolean gates. We consider weakened forms of this question: first, we consider a restricted class of sorting where the number of distinct keys is much smaller than the input length; and second, we explore Oblivious RAMs and probabilistic circuit families, i.e., computational models that are somewhat more powerful than circuits but much weaker than RAM. We show that Oblivious RAMs and probabilistic circuit families can sort o(log n)-bit keys in o(n log n) time or o(kn log n) circuit complexity. Our algorithms work in the indivisible model, i.e., not only can they sort an array of numerical keys --- if each key additionally carries an opaque ball, our algorithms can also move the balls into the correct order. We further show that in such an indivisible model, it is impossible to sort Ω(log n)-bit keys in o(n log n) time, and thus the o(log n)-bit-key assumption is necessary for overcoming the n log n barrier.Finally, after optimizing the IO efficiency, we show that even the 1-bit special case can solve open questions: our oblivious algorithms solve tight compaction and selection with optimal IO efficiency for the first time.

In this paper we present new space efficient dynamic data structures for orthogonal range reporting. The described data structures support planar range reporting queries in time O(log n+klog log (4n/(k+1))) and space O(nlog log n), or in time O(log n+k) and space O(nlog en) for any e>0. Both data structures can be constructed in O(nlog n) time and support insert and delete operations in amortized time O(log 2n) and O(log nlog log n) respectively. These results match the corresponding upper space bounds of Chazelle (SIAM J. Comput. 17, 427–462, 1988) for the static case. We also present a dynamic data structure for d-dimensional range reporting with search time O(log d−1n+k), update time O(log dn), and space O(nlog d−2+en) for any e>0. The model of computation used in our paper is a unit cost RAM with word size log n.

We construct the first schemes that allow a client to privately outsource arbitrary program executions to a remote server while ensuring that: (I) the client's work is small and essentially independent of the complexity of the computation being outsourced, and (II) the server's work is only proportional to the run-time of the computation on a random access machine (RAM), rather than its potentially much larger circuit size. Furthermore, our solutions are non-interactive and have the structure of reusable garbled RAM programs, addressing an open question of Lu and Ostrovsky (Eurocrypt 2013). We also construct schemes for an augmented variant of the above scenario, where the client can initially outsource a large private and persistent database to the server, and later outsource arbitrary program executions with read/write access to this database. Our solutions are built from non-reusable garbled RAM in conjunction with new types of reusable garbled circuits that are more efficient than prior solutions but only satisfy weaker security. For the basic setting without a persistent database, we can instantiate the required type of reusable garbled circuits from indistinguishability obfuscation or from functional encryption for circuits as a black-box. For the more complex setting with a persistent database, we can instantiate the required type of reusable garbled circuits using stronger notions of obfuscation. Our basic solution also requires the client to perform a one-time pre-processing step to garble a program at the cost of its RAM run-time, and we can avoid this cost using stronger notions of obfuscation. It remains an open problem to instantiate these new types of reusable garbled circuits under weaker assumptions, possibly avoiding obfuscation altogether. We show several simple extensions of our results and techniques to achieve: efficiency proportional to the input-specific RAM run-time, verifiability of outsourced RAM computation, functional encryption for RAMs, and a candidate obfuscation for RAMs.

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.