Nondeterministic Computation Research Articles

λS: An implicitly parallel λ-calculus with recursive bindings, synchronization and side effects

λS extends the λ-calculus with recursive bindings, barriers, and updatable memory cells with synchronized operations. The calculus can express both deterministic and nondeterministic computations. It is designed to be useful for reasoning about compiler optimizations and thus allows reductions anywhere, even inside λ's. Despite the presence of side effects, the calculus retains fine-grained, implicit parallelism and non-strict functions: there is no global, sequentializing store. Barriers, for sequencing, capture a robust notion of termination. Although λS was developed as a foundation for the parallel functional languages pH and Id, we believe that barriers give it wider applicability — to sequential, explicitly parallel and concurrent languages. In this paper we describe the λS-calculus and its properties, based on a notion of observable information in a term. We also describe reduction strategies to compute maximal observable information even in the presence of unbounded nondeterminism.

Practically solving some problems expressed in the first order theory of real closed field

Many important mathematical and engineering problems can be expressed in the first order theory of real closed field Th(RLC), however any decision method for this theory needs exponential time even using nondeterministic computation models. Therefore it is desirable to find practical and efficient methods (non-decision methods) of solving problems expressed in this theory. By combining Ritt-Wu′ method with Budan-Fourier′s theorem, we propose a method to practically solve some problems expressed in this theory. In our method Budan-Fourier′s theorem is used to provide information on real roots of polynomial equations and to prove polynomial inequalities to hold, which is simpler and more efficient than Sturm theorem that is used in decision methods for Th(RLC). Our method has been found to efficiently work on many examples in practice though it is incomplete in general. Using our method, we have solved some problems, including deriving some new conditions on the existence of eight limit cycles for a cubic differential system which can not be dealt with using conventional methods because of the complexity of manipulating large polynomials. In this paper we describe our method by presenting some algorithms and examples.

Granularity via nondeterministic computations: What we gain and what we lose

Granularity via nondeterministic computations: What we gain and what we lose

Granularity via nondeterministic computations: What we gain and what we lose

We humans usually think in words; to represent our opinion about, e.g., the size of an object, it is sufficient to pick one of the few (say, five) words used to describe size (“tiny,” “small,” “medium,” etc.). Indicating which of 5 words we have chosen takes 3 bits. However, in the modern computer representations of uncertainty, real numbers are used to represent this “fuzziness.” A real number takes 10 times more memory to store, and therefore, processing a real number takes 10 times longer than it should. Therefore, for the computers to reach the ability of a human brain, Zadeh proposed to represent and process uncertainty in the computer by storing and processing the very words that humans use, without translating them into real numbers (he called this idea granularity). If we try to define operations with words, we run into the following problem: e.g., if we define “tiny” + “tiny” as “tiny,” then we will have to make a counter-intuitive conclusion that the sum of any number of tiny objects is also tiny. If we define “tiny” + “tiny” as “small,” we may be overestimating the size. To overcome this problem, we suggest to use nondeterministic (probabilistic) operations with words. For example, in the above case, “tiny” + “tiny” is, with some probability, equal to “tiny,” and with some other probability, equal to “small.” We also analyze the advantages and disadvantages of this approach: The main advantage is that we now have granularity and we can thus speed up processing uncertainty. The main disadvantage is that in some cases, when defining symmetric associative operations for the set of words, we must give up either symmetry, or associativity. Luckily, this necessity is not always happening: in some cases, we can define symmetric associative operations.

Quantum Nondeterministic Computation based on Statistics Superselection Rules

Quantum states which obey certain symmetry superselection rules under identical particles permutation can be interpreted as computational states satisfying corresponding Boolean predicates. Given the NP-complete problem of testing the satisfiability of a generic Boolean predicate P, we investigate the possibility of achieving quantum nondeterministic computation by deriving, from P, a physical situation in which the computational states satisfy Piff they satisfy a special fermion statistics.

On non-determinism in machines and languages

Non-deterministic computation is not really computation, but the difference with real computation is blurred. We study in detail various levels of non-determinism in computations on non-deterministic Turing machines with polynomial bounds on the resources. Meanwhile, we consider numerous query languages, implicit logic, choice logic, order invariant logic, and restrictions of second-order logic, and establish correspondences between all these formalisms for both deterministic and non-deterministic queries. To the degrees of non-determinism in the computations, correspond levels of non-determinism in the logical definitions. Our main contribution is to characterize various complexity classes between PTIME and PSPACE, by several logical means, thus translating open questions in complexity theory to open questions in logic related to the use of the non-determinism.

Linear logic automata

A Linear Logic automaton is a hybrid of a finite automaton and a non-deterministic Petri net. LL automata commands are represented by propositional Horn Linear Logic formulas. Computations performed by LL automata directly correspond to cut-free derivations in Linear Logic. A programming language of LL automata is developed in which typical sequential, non-deterministic and parallel programming constructs are expressed in the natural way. All non-deterministic computations, e.g. computations performed by programs built up of guarded commands in the Dijkstra's approach to non-deterministic programming, are directly simulated within the framework of Linear Logic automata, and thereby within the Horn framework of Linear Logic.

On sets bounded truth-table reducible to $P$-selective sets

We show that if every NP set in polynomial-time bounded truth-table reducible to some P-selective set, then NP is contained in DTIME (2 nO(1/ √ logn) . In the proof, we implement a recursive procedure that reduces the number of nondeterministic steps of a given nondeterministic computation.

On randomized versus deterministic computation

In contrast to deterministic or nondeterministic computation, it is a fundamental open problem in randomized computation how to separate different randomized time classes (at this point we do not even know how to separate linear randomized time from O(n log n randomized time) or how to compare them relative to corresponding deterministic time classes. In other words, we are far from understanding the power of random coin tosses in the computation, and the possible ways of simulating them deterministically. In this paper we study the relative power of linear and polynomial randomized time compared with exponential deterministic time. Surprisingly, we are able to construct an oracle A such that exponential time (with or without the oracle A) is simulated by linear time Las Vegas algorithms using the oracle A. For Las Vegas polynomial time ( ZPP) this will mean the following equalities of the time classes: ZPP A = EXPTIME A = EXPTIME (= DTIME(2 poly )). Furthermore, for all the sets M ⊆ ∑ ∗ , M ⩽ UR A ̄ a ́ t M ϵ EXPTIME (⩽ UR being unfaithful polynomial random reduction, cf. [10]). Thus A ̄ is ⩽ UR complete for EXPTIME, but interestingly not NP-hard under (deterministic) polynomial reduction unless EXPTIME = NEXPTIME. We also prove, for the first time, that randomized reductions are exponentially more powerful than deterministic or nondeterministic ones (cf. [2]). Moreover, a set B is constructed such that Monte Carlo polynomial time ( BPP) under the oracle B is exponentially more powerful than deterministic time with nondeterministic oracles, more precisely, BPP B = Δ 2 EXPTIME B = Δ 2 EXPTIME (= DTIME(2 poly ) NTIME( n) ). This strengthens considerably a result of Stockmeyer [17] about the polynomial time hierarchy that for some decidable oracle B, BPP B n ́ Δ 2P B . Under our oracle BPP B is exponentially more powerful than Δ 2 P B , and B does not add any power to Δ 2 EXPTIME. One of the consequences of this result is that under oracle B, Δ 2 EXPTIME has polynomial size circuits.

Visual Parallel Programming and Determinancy: A Language Specification, an Analysis Technique, and a Programming Tool

Phred is a visual parallel programming language in which programs can be statically analyzed for deterministic behavior. This paper presents the Phred language, techniques for analyzing the language, and a programming environment which supports Phred programming. There are many methods for specifying synchronization and data sharing in parallel programs. The Phred programmer uses graph constructs for describing parallelism, synchronization, and data sharing. These graphs are formally described in this paper as a graph grammar. The use of graphs in Phred provides an intuitive and visual representation for parallel computations. The inadvertent specification of nondeterministic computations is a common error in parallel programming. Phred addresses the issue of determinacy by visually indicating regions of a program where nondeterminacy may exist. This analysis and its integration into a programming environment is presented here. The Phred programming environment supports the specification, analysis, and execution of Phred programs. The distribution of the programming environment itself over several workstations is also described.

CONSTANT LEAF-SIZE HIERARCHY OF TWO-DIMENSIONAL ALTERNATING TURING MACHINES

“Leaf-size” (or “branching”) is the minimum number of leaves of some accepting computation trees of alternating devices. For example, one leaf corresponds to nondeterministic computation. In this paper, we investigate the effect of constant leaves of two-dimensional alternating Turing machines, and show the following facts: (1) For any function L(m, n), k leaf- and L(m, n) space-bounded two-dimensional alternating Turing machines which have only universal states are equivalent to the same space bounded deterministic Turing machines for any integer k≥1, where m (n) is the number of rows (columns) of the rectangular input tapes. (2) For square input tapes, k+1 leaf- and o(log m) space-bounded two-dimensional alternating Turing machines are more powerful than k leaf-bounded ones for each k≥1. (3) The necessary and sufficient space for three-way deterministic Turing machines to simulate k leaf-bounded two-dimensional alternating finite automata is nk+1, where we restrict the space function of three-way deterministic Turing machines to depend only on the number of columns of the given input tapes.

Nondeterminism within $P^ * $

Classes of machines using very limited amounts of nondeterminism are studied. The P=? NP question is related to questions about classes lying within P. Complete sets for these classes are given.

Using Inductive Counting to Simulate Nondeterministic Computation

Immerman and Szelepcsényi′s inductive counting technique demonstrated that, for space classes, the nondeterministic acceptance mechanism can simulate with no space penalty any reasonable acceptance mechanism based on censuses of configurations. However, the efficiency with which other acceptance mechanisms can simulate nondeterminism remains an open question. This paper uses inductive counting to study the cost of simulating nondeterminism with Valiant′s paradigm of unique computation-nondeterministic computation in which each input generates at most one accepting computation. We show that unique computation can simulate nondeterministic computation with a space penalty logarithmic in the ambiguity of the nondeterministic computation tree. Relatedly, we show that unique AuxPDAs and restricted SAC 1 circuits can efficiently simulate ambiguity-bounded nondeterministic computation. In particular, all nondeterministic logspace languages of polynonmial ambiguity are in WeakUnambRAC 1 , and thus are accepted by uniform, weak, unambiguous, shallow circuits.

STEADY, SIMULTANEOUS QUANTUM COMPUTATION: A PARADIGM FOR THE INVESTIGATION OF NONDETERMINISTIC AND NON-RECURSIVE COMPUTATION

We introduce the notion of a class of abstract digital computers based on quantum reversibility and indeterminism (not 011 the classical sequential architecture), which are compatible with quantum laws and may perform nondeterministic and non-recursive computation.

Deterministic and nondeterministic computation, and horn programs, on abstract data types

We investigate the notion of “semicomputability,” intended to generalize the notion of recursive enumerability of relations to abstract structures. Two characterizations are considered and shown to be equivalent: one in terms of “partial computable functions” (for a suitable notion of computability over abstract structures) and one in terms of definability by means of Horn programs over such structures. This leads to the formulation of a “Generalized Church-Turing Thesis” for definability of relations on abstract structures.

Deterministic realization of nondeterministic computations with a low measure of nondeterminism

Various modifications of Turing machines and pushdown automata are considered. The complexity of nondeterministic computations with a low degree of nondeterminism is compared to that of deterministic analogs.

Effectiveness of making internal representations redundant in neural networks for solving optimization problems

AbstractIn solving an optimization problem using a neural network, the representation schema which codes the solutions of the problem onto the configurations of the states of neurons must first be defined. The coding schema is called an internal representation of the problem and the representation is considered redundant when the schema uses only those configurations which are separate from each other at long Hamming distances. Under some conditions, the redundant representation is shown to be very effective in eliminating the local minima problem, which is one of the most crucial problems in the application of neural networks to optimization problems. In the redundant representation, a stochastic property which appears asymptotically when increasing the number of neurons plays an important role when the solution is read reliably from the random and erroneous states of networks. In these networks, a probabilistic states transition schema is introduced so that the network can escape from the local minima. By introducing the redundancy, the randomly changing configuration can keep the order in which the solution can be read while sufficiently preserving the randomness to escape from the local minima. The result in this paper shows a novel optimization capability of the network which has a highly parallel and nondeterministic computation schema as described in the foregoing.

A faithful embedding of parallel computations in star-finite models

The purpose of this paper is to show that there exist star-finite tree-structured sets in which the computations of parallel programs can be faithfully embedded, and that the theory of star-finite sets and relations therefore provides a new tool for the analysis of non-deterministic computations.

Continuous optimization problems and a polynomial hierarchy of real functions

The close connection between the maximization operation and nondeterministic computation has been observed in many different forms. We examine this relationship on real functions and give a characterization of NP-time computable real functions by the maximization operation. A natural extension of NP-time computable real functions to a polynomial hierarchy of real functions has a characterization by alternating operations of maximization and minimization. Although syntactically this hierarchy of real functions can be treated as a polynomial hierarchy of operators, the well-known Baker-Gill-Solovay separation result does not apply to this hierarchy. This phenomenon is explained by the inherent structural properties of real functions, and is compared with recent studies on positive relativization.

On powerdomains and modality

This note shows a simple connection between powerdomains and modal assertions that can be made about nondeterministic computations. We consider three kinds of powerdomains: the Plotkin powerdomain, the Smyth powerdomain, and one christened the Hoare powerdomain by Plotkin because it captures the partial correctness of a nondeterministic program. The modal operators are □ for ‘inevitably’ and ♦ for ‘possibly’. It is shown in a precise sense how the Smyth powerdomain is built up from assertions about the inevitable behaviour of a process, the Hoare powerdomain is built up from assertions about the possible behaviour of a process, while the Plotkin powerdomain is built up from both kinds of assertions taken together.