Polynomial Number Of Processors Research Articles

Порождение малых сложностных классов с помощью логических формул, схем и операций ограниченной конкатенации

The FO and FOM classes are small classes of recursive functions that characterize parallel computing with constant running time and a polynomial number of processors. The article provides an overview of the results describing the basic properties of the FO and FOM classes. Various ways of defining these classes and proving the equivalence of these definitions are given. The position of FO and FOM in the hierarchy of complexity classes is characterized. The results on the affiliation of various functions to the FO and FOM classes are presented. Superposition bases in the FO and FOM classes are described and a complete proof of the result on the superposition basis in the FOM class, consisting only of simple, mainly arithmetic functions, is given.

The algebraic structure of the densification and the sparsification tasks for CSPs

The tractability of certain CSPs for dense or sparse instances is known from the 90s. Recently, the densification and the sparsification of CSPs were formulated as computational tasks and the systematical study of their computational complexity was initiated. We approach this problem by introducing the densification operator, i.e. the closure operator that, given an instance of a CSP, outputs all constraints that are satisfied by all of its solutions. According to the Galois theory of closure operators, any such operator is related to a certain implicational system (or, a functional dependency) Σ. We are specifically interested in those classes of fixed-template CSPs, parameterized by constraint languages Γ, for which there is an implicational system Σ whose size is a polynomial in the number of variables n. We show that in the Boolean case, such implicational systems exist if and only if Γ is of bounded width. For such languages, Σ can be computed in log-space or in a logarithmic time with a polynomial number of processors. Given an implicational system Σ, the densification task is equivalent to the computation of the closure of input constraints. The sparsification task is equivalent to the computation of the minimal key.

A global parallel algorithm for enumerating minimal transversals of geometric hypergraphs

We consider the problem of enumerating all minimal hitting sets of a given hypergraph (V,R), where V is a finite set, called the vertex set and R is a set of subsets of V called the hyperedges. We show that, when the hypergraph admits a balanced subdivision, then a recursive decomposition can be used to obtain efficiently all minimal hitting sets of the hypergraph. We apply this decomposition framework to get incremental polynomial-time algorithms for finding minimal hitting sets and minimal set covers for a number of hypergraphs induced by a set of points and a set of geometric objects. The set of geometric objects includes half-spaces, hyper-rectangles and balls, in fixed dimension. A distinguishing feature of the algorithms we obtain is that they admit an efficient global parallel implementation, in the sense that all minimal hitting sets can be generated in polylogarithmic time in |V|, |R| and the total number of minimal transversals M, using a polynomial number of processors. For half-spaces in R2, we show that the above two enumeration problems can be solved, using a different technique, with amortized polynomial delay.

A parallel algorithm for generating bicompatible elimination orderings of proper interval graphs

In this paper, we first show how a certain ordering of vertices, called bicompatible elimination ordering (BCO), of a proper interval graph can be used to solve efficiently several problems in proper interval graphs. We, then, propose an NC parallel algorithm (i.e., polylogarithmic-time employing a polynomial number of processors) in SIMD CRCW PRAM (Single Instruction Stream Multiple Data Stream Concurrent Read Concurrent Write Parallel Random Access Machine) model of parallel computation to compute a BCO of a proper interval graph. To the best of our knowledge, this is the first NC parallel algorithm to compute a BCO of a proper interval graph.

Molecular solution to the 0–1 knapsack problem based on DNA computing

Many combinatorial optimization problems are known to be NP-complete. A common point of view is that finding fast algorithms for such problems using a polynomial number of processors is unlikely. However, facts of this kind are usually established for “worst” case situations, and in practice many instances of NP-complete problems are successfully solved in polynomial time by such traditional combinatorial optimization techniques such as dynamic programming, branch-and-bound. New opportunities for an effective solution of combinatorial problems emerged with the advent of parallel machines. In this paper, we describe an algorithm which generates an optimal solution for the 0/1 integer knapsack problem on DNA computing.

PARALLEL ALGORITHMS FOR VEHICLE ROUTING PROBLEMS

Vehicle routing problems involve the navigation of one or more vehicles through a network of locations. Locations have associated handling times as well as time windows during which they are active. The arcs connecting locations have time costs associated with them. In this paper, we consider two different problems in single vehicle routing. The first is to find least time cost routes between all pairs of nodes in a network for navigating vehicles; we call this the all pairs routing problem. We show that there is an O( log 3 n) time parallel algorithm using a polynomial number of processors for this problem on a CREW PRAM. We next consider the problem in which a vehicle services all locations in a network. Here, locations can be passed through at any time but only serviced during their time window. The general problem is [Formula: see text] -complete under even fairly stringent restrictions but polynomial algorithms have been developed for some special cases. In particular, when the network is a line, there is no time cost in servicing a location, and all time windows are unbounded at either their lower or upper end, O(n2) algorithms have been developed. We show that under the same conditions, we can reduce this problem to the all pairs routing problem and therefore obtain an O( log 3 n) time parallel algorithm on a CREW PRAM.

The monotone theory for the PAC-model

In this paper we extend the Monotone Theory to the PAC-learning Model with membership queries. Using this extention we show that a DNF formula that has at least one “1/ poly -heavy” clause in one of its CNF representation (a clause that is not satisfied with probability 1/ poly ( n , s ) where n is the number of variables and s is the number of terms in f ) with respect to a distribution D is weakly learnable under this distribution. So DNF that are not weakly learnable under the distribution D do not have any “1/ poly -heavy” clauses in any of their CNF representations. A DNF f is called τ -CDNF if there is τ ′ > τ and a CNF representation of f that contains poly ( n , s ) clauses that τ ′ -approximates f according to a distribution D . We show that the class of all τ -CDNF is weakly ( τ + ϵ )-PAC-learnable with membership queries under the distribution D . We then show how to change our algorithm to a parallel algorithm that runs in polylogarithmic time with a polynomial number of processors. In particular, decision trees are (strongly) PAC-learnable with membership queries under any distribution in parallel in polylogarithmic time with a polynomial number of processors. Finally we show that no efficient parallel exact learning algorithm exists for decision trees.

Algorithms for generalized vertex-rankings of partial [formula omitted]-trees

A c-vertex-ranking of a graph G for a positive integer c is a labeling of the vertices of G with integers such that, for any label i, deletion of all vertices with labels >i leaves connected components, each having at most c vertices with label i. A c-vertex-ranking is optimal if the number of labels used is as small as possible. We present sequential and parallel algorithms to find an optimal c-vertex-ranking of a partial k-tree, that is, a graph of treewidth bounded by a fixed integer k. The sequential algorithm takes polynomial-time for any positive integer c. The parallel algorithm takes O( log n) parallel time using a polynomial number of processors on the common CRCW PRAM, where n is the number of vertices in G.

A sublinear parallel algorithm for stable matching

A parallel algorithm for the stable matching problem is presented. The algorithm is based on the primal-dual interior path-following method for linear programming. The main result is that a stable matching can be found in O ∗( m ) time by a polynomial number of processors, where m is the total length of preference lists of individuals.

Parallel RAMs with owned global memory and deterministic context-free language recognition

We identify and study a natural and frequently occurring subclass of Concurrent Read, Exclusive Write Parallel Random Access Machines (CREW-PRAMs). Called Concurrent Read, Owner Write, or CROW-PRAMS, these are machines in which each global memory location is assigned a unique “owner” processor, which is the only processor allowed to write into it. Considering the difficulties that would be involved in physically realizinga full CREW-PRAM model and demonstrate its stability under several definitional changes. Second, we precisely characterize the power of the CROW-PRAM by showing that the class of languages recognizable by it in time O (log n) (and implicity with a polynomial number of processors) is exactly the class LOGDCFL of languages log space reducible to deterministic context-free languages. Third, using the same basic machinery, we show that the recognition problem for deterministic context-free languages can be solved quickly on a deterministic auxilliary pushdown automation having random access to its input tape, a log n space work tape, and pushdown store of small maximum height. For example, time O ( n 1 + ε ) is achievable with pushdown height O (log 2 n ). These result extend and unify work of von Braunmöhl, Cook, Mehlhorn, and Verbeek, Klein and Reif; and Rytter.

PARALLEL VERTEX COLOURING OF INTERVAL GRAPHS

Evidence is given to suggest that minimally vertex colouring an interval graph may not be in NC 1. This is done by showing that 3-colouring a linked list is NC 1-reducible to minimally colouring an interval graph. However, it is shown that an interval graph with a known interval representation and an O(1) chromatic number can be minimally coloured in NC 1. For the CRCW PRAM model, an o( log n) time, polynomial processors algorithm is obtained for minimally colouring an interval graph with o( log n) chromatic number and a known interval representation. In particular, when the chromatic number is O(( log n)1-ε), 0<ε<1, the algorithm runs in O( log n/ log log n) time. Also, an O( log n) time, O(n) cost, EREW PRAM algorithm is found for interval graphs of arbitrary chromatic numbers. The following lower bound result is also obtained: even when the left and right endpoints of the interval are separately sorted, minimally colouring an interval graph needs Ω( log n/ log log n) time, on a CRCW PRAM, with a polynomial number of processors.

The Dynamic Parallel Complexity of Computational Circuits

We establish connections between parallel circuit evaluation and uniform algebraic closure properties of unary function classes. We use this connection in the development of time-efficient and processor-efficient parallel algorithms for the evaluation of algebraic circuits. Our algorithm provides a nontrivial upper bound on the parallel complexity of the circuit value problem over $\{{\Bbb R},\min,\max,+\}$ and $\{{\Bbb R}^{+},\min,\max,\times\}$. We partially answer an open question of Miller, Ramachandran, and Kaltofen by showing that circuits over a polynomial-bounded noncommutative semiring and circuits over infinite noncommutative semirings with a polynomial-bounded dimension over a commutative semiring can be evaluated in polylogarithmic time in their size and degree using a polynomial number of processors. We also present an improved parallel algorithm for Boolean circuits.

On parallel evaluation of game trees

A class of parallel algorithms for evaluating game trees is presented. These algorithms parallelize a standard sequential algorithm for evaluating AND/OR trees and the α-β pruning procedure for evaluating MIN/MAX trees. It is shown that, uniformly on all instances of uniform AND/OR trees, the parallel AND/OR tree algorithm achieves an asymptotic linear speedup using a polynomial number of processors in the height of the tree. The analysis of linear speedup using more than a linear number of processors is due to J. Harting. A numerical lower bound rigorously establishes a good speedup for the uniform AND/OR trees with parameters that are typical in practice. The performance of the parallel α-β algorithm on best-ordered MIN/MAX trees is analyzed.

A polynomial algorithm for the extendability problem in bipartite graphs

Let G = [ V, E] be a simple connected graph and let k be an integer such that 0 < k < ¦V¦ 2 . G is said to be k-extendable if it contains a perfect matching and every matching of k edges extends to, i.e. is a subset of, a perfect matching. The extendability problem consists in finding the maximum value of k, denoted k 0, such that G is k-extendable. We give in this paper the first polynomial algorithm for the extendability problem when the graph is bipartite. Its complexity is O( m · min( k 0 3 + n, k 0 · n)) where n and m designate the number of vertices and edges of the graph respectively. Furthermore, if a perfect matching or a special orientation of the edges are known then this algorithm can be run in parallel in O( k 0 · log n) time using a polynomial number of processors on a concurrent-read concurrent-write PRAM machine.

Parallel algorithm and dynamic exponent for diffusion-limited aggregation

A parallel algorithm for diffusion-limited aggregation (DLA) is described and analyzed from the perspective of computational complexity. The dynamic exponent z of the algorithm is defined with respect to the probabilistic parallel random-access machine model of parallel computation according to T\ensuremath{\sim}${\mathrm{L}}^{\mathrm{z}}$, where L is the cluster size, T is the running time, and the algorithm uses a number of processors polynomial in L. It is argued that z=D-${\mathrm{D}}_{2}$/2, where D is the fractal dimension and ${\mathrm{D}}_{2}$ is the second generalized dimension. Simulations of DLA are carried out to measure ${\mathrm{D}}_{2}$ and to test scaling assumptions employed in the complexity analysis of the parallel algorithm. It is plausible that the parallel algorithm attains the minimum possible value of the dynamic exponent in which case z characterizes the intrinsic history dependence of DLA.

A new parallel algorithm for time-slot assignment in hierarchical switching systems

The time-slot assignment (TSA) problem in a TDM switching system is to find a conflict-free assignment of traffic-units to slots such that the frame-length is minimized. In this paper, we develop a new parallel algorithm for the TSA problem in hierarchical switching systems (HSS). To design the parallel algorithm, we first reduce the TSA problem to the problem of routing permutations in three-stage Clos networks; we also show how this reduction can be achieved in polylogarithmic time using a polynomial number of processors on the EREW PRAM model. Once this reduction is achieved, we use existing parallel algorithms in literature to route permutations in Clos networks. The overall time-complexity of our parallel algorithm is O(log/sup 3/ X) using O(MX) processors, where X=max{M, L}, M is the number of inputs of the HSS, and L is the length of the time-slot assignment. This result is a significant improvement upon the earlier parallel algorithms, which require O(M/sup 2/ log M log L) time and O(ML) processors to solve the TSA problem.

Exact Learning of Formulas in Parallel

We investigate the parallel complexity of learning formulas from membership and equivalence queries. We show that many restricted classes of boolean functions cannot be efficiently learned in parallel with a polynomial number of processors.

On path equivalence of nondeterministic finite automata

Two nondeterministic finite automata (NFAs) are said to be path equivalent if each string is accepted by the two automata via the same number of computation paths. In this paper we show the following. 1. (1) The path equivalence problem for NFAs without λ-cycles is solvable not only in polynomial sequential time but also in O( log 2( n)) parallel time using a polynomial number of processors, where n is the total number of states in two NFAs. 2. (2) The path equivalence problem for NFAs with λ-cycles is PSPACE-complete, hence decidable.

A new unifying heuristic algorithm for the undirected minimum cut problems using minimum range cut algorithms

Given a connected undirected multigraph with n vertices and m edges, we first propose a new unifying heuristic approach to approximately solving the minimum cut and the s- t minimum cut problems by using efficient algorithms for the corresponding minimum range cut problems. Our method is based on the association of the range value of a cut and its cut value when each edge weight is chosen uniformly randomly from the fixed interval. Our computational experiments demonstrate that this approach produces very good approximate solutions. We shall also propose an O(log 2 n) time parallel algorithm using O( n 2) processors on an arbitrary CRCW PRAM model for the minimum range cut problems, by which we can efficiently obtain approximate minimum cuts in poly-log time using a polynomial number of processors.

An Optimal Parallel Algorithm for Learning DFA

Sequential algorithms given by Alguin (1987) and Schapire (1992) learn deterministic finite automata (dfa) exactly from Membership and Equivalence queries. These algorithms are feasible, in the sense that they take time polynomial in n and m, where n is the number of states of the automaton and m is the length of the longest counterexample to an Equivalence query. This paper studies whether parallelism can lead to substantially more efficient algorithms for the problem. We show that no CRCW PRAM machine using a number of processors polynomial in n and m can identify dfa in o(n/logn) time. Furthermore, this lower bound is tight up to constant factors: we develop a CRCW PRAM learning algorithm that uses polynomially many processors and exactly learns dfa in time O(n/logn).