pinecone/core-2020-05-10-deduplication huggingface dataset:
Multi-prover Encoding Schemes and Three-prover Proof Systems

AbstractSuppose two provers agree in a polynomialpand want to reveal a single vaiuey=p(x) to a verifier wherexis chosen arbitrarily by the verifier. Whereas honest provers should be able to agree on any polynomialpthe verifier wants to be sure that with any (cheating) pair of provers the valueyhe receives is a polynomial function ofx. We formalize this question and introduce multi-prover (quasi-)encoding schemes to solve it. Using multi-prover quasi-encoding schemes we are able to develop new results about interactive proofs. The best previous result appears in [BGLR] and states the existence of one-round-four-prover interactive proof systems for the languages in NP achieving any constant error probability withO(logn) random bits andpoly(loglogn) answer size. We improve this result in two respects. First we decrease the number of provers to three, and then we decrease the answer-size to a constant. Using unrelated (parallel repetition) techniques the same was independently and simultaneously achieved by [FK] with only two provers. When the error-probability is required to approach zero, our technique is more efficient in the number of random bits and in the answer size. Showing the fast progress in this central topic of theoretical computer science in the short time since these results were achieved Raz's proof of the parallel repetition conjecture [R] lead to further improvements in the parameters of interactive proofs for NP problems
Random Strings Make Hard Instances

AbstractWe establish the truth of the “instance complexity conjecture” in the case of DEXT-complete sets over polynomial time computations, and r.e. complete sets over recursive computations. Specifically, we obtain for every DEXT-complete setAan exponentially dense subsetCand a constantksuch that for every nondecreasing polynomialt(n)=Ω(nk), ict(x:A)⩾Kt(x)−cholds for some constantcand allx∈C, where ictandKtare thet-bounded instance complexity and Kolmogorov complexity measures, respectively. For any r.e. complete setAwe obtain an infinite setC⊆Āsuch that ic(x:A)⩾K(x)−cholds for some constantcand allx∈C, where ic andKdenote the time-unbounded versions of instance and Kolmogorov complexities, respectively. The proofs are based on the observation thatKolmogorov random stringsare individually hard to recognize by bounded computations
On the Isomorphism Conjecture for Weak Reducibilities

AbstractAccording to the isomorphism conjecture all NP-complete sets are polynomial?time isomorphic to each other while according to the encrypted complete set conjecture there is ap-one way functionfand an NP-complete setAsuch thatAandf(A) are not polynomial-time isomorphic to each other. In this paper, these two conjectures are translated and investigated for reducibilities weaker than polynomial-time. It is shown that: 1. Relative to reductions computed by one-way logspace DTMs, both the conjectures are false. 2. Relative to reductions computed by one-way logspace NTMs, the isomorphism conjecture is true. 3. Relative to reductions computed by one-way, multi-head, oblivious logspace DTMs, the encrypted complete set conjecture is false. 4. Relative to reductions computed by constant-scan logspace DTMs, the encrypted complete set conjecture is true. It is also shown that the complete degrees of NP under the latter two reducibilities coincide
Logical Definability of Counting Functions

AbstractThe relationship between counting functions and logical expressibility is explored. The most well studied class of counting functions is #P, which consists of the functions counting the accepting computation paths of a nondeterministic polynomial-time Turing machine. For a logicL, #Lis the class of functions on finite structures counting the tuples (T, ) satisfying a given formulaψ(T, ) inL. Saluja, Subrahmanyam, and Thakur showed that on classes of ordered structures #FO=#P (where FO denotes first-order logic) and that every function in #Σ1has a fully polynomial randomized approximation scheme. We give a probabilistic criterion for membership in #Σ1. A consequence is that functions counting the number of cliques, the number of Hamilton cycles, and the number of pairs with distance greater than two in a graph, are not contained in #Σ1. It is shown that on ordered structures #Σ11captures the previously studied class spanP. On unordered structures #FO is a proper subclass of #P and #Σ11is a proper subclass of spanP; in fact, no class #Lcontains all polynomial-time computable functions on unordered structures. However, it is shown that on unordered structures every function in #P is identical almost everywhere with some function #FO, and similarly for #Sgr;11and spanP. Finally, we discuss the closure properties of #FO under arithmetical operations
Bounds on the Greedy Routing Algorithm for Array Networks

AbstractWe analyze the performance of greedy routing for array networks by providing bounds on the average delay and the average number of packets in the system for the dynamic routing problem. In this model packets are generated at each node according to a Poisson process, and each packet is sent to a destination chosen uniformly at random. Our bounds are based on comparisons with computationally simpler queueing networks, and the methods used are generally applicable to other network systems. A primary contribution we provide is a new lower bound technique that also improves on the previous lower bounds by Stamoulis and Tsitsiklis for heavily loaded hypercube networks. On heavily loaded array networks, our lower and upper bounds differ by only a small constant factor. We further examine extensions of the problem where our methods prove useful. For example, we consider variations where edges can have different transmission rates or the destination distribution is non-uniform. In particular, we study to what extent optimally configured array networks outperform the standard array network
Improved Parity-Declustered Layouts for Disk Arrays

AbstractRecently, parity-declustered layouts have been studied as a tool for reducing the time needed to reconstruct a failed disk in a disk array. Construction of such layouts for large disk arrays generally involves the use of a balanced incomplete block design (BIBD), a type of subset system over the set of disks. This research has been somewhat hampered by the dearth of effective, easily implemented constructions of BIBDs on large sets and by inefficiencies in some parity-distribution methods that create layouts that are larger than necessary. We make progress on these problems in several ways. In particular, we•demonstrate new BIBD constructions that generalize some previous constructions and yield simpler BIBDs that are optimally small in some cases,•show how relaxing some of the balance constraints on data layouts leads to constructions of approximately-balanced layouts that greatly increase the number of feasible layouts for large arrays, and•give a new method for distributing parity that produces smaller data layouts, resulting in tight bounds on the size of data layouts derived from BIBDs.Our results use a variety of algebraic, combinatorial, and graph-theoretic techniques, and together greatly increase the number of parity-declustered data layouts that are appropriate for use in large disk arrays
List Ranking and List Scan on the CRAYC90

AbstractAlthough parallel algorithms using linked lists, trees, and graphs have been studied extensively by the research community, implementations have met with limited success, even for the simplest algorithms. In this paper we present our results of a careful implementation study of parallel list ranking (and the related list-scan operation) and show that it can have substantial speed up over fast workstations. Obtaining good parallel performance for list ranking is a challenge for two reasons. First, although there are many asymptotic work-efficient algorithms, it is hard to keep the constants comparable to those of the sequential algorithm. In this paper we introduce a new parallel algorithm that both is work efficient and has small constant but sacrifices logarithmic time; it achieves only anO(log2n) time. We contend, however, that work efficiency and small constants are more important, given that multiprocessor machines are used for problems that are much larger than the number of processors and, therefore, the optimalO(logn) time is never achieved in practice. Second, list ranking is highly communication intensive and its memory access patterns are dynamic. We show, however, that by using high memory bandwidth multiprocessors, such as CrayC90 computers, programmed with virtual processors to hide latency we can ameliorate these problems. To the best of our knowledge, our implementation of list ranking and list scan on the CrayC90 is the fastest to date and is the first implementation that substantially outperforms fast workstations. The success of our algorithm is due to its moderate grain size and simplicity; the success of the implementation is due to pipelining reads and writes through vectorization to hide latency and optimizing performance by analyzing the expected execution time of the algorithm
Dynamic Load Balancing by Random Matchings

AbstractThe fundamental problems in dynamic load balancing and job scheduling in parallel and distributed networks involve moving load between processors. In this paper we consider a new model for load movement in synchronous machines. In each step of our model, load can be moved across only a matching set of communication links but across each link any amount of load can be moved. We present an efficient local algorithm for the dynamic load balancing problem under our model of load movement. Our algorithm works on networks of arbitrary topology under possible failure of links. The running time of our algorithm is related to the eigenstructure of the underlying graph. We also present experimental results analyzing issues in load balancing related to our algorithms
Construction of the Mesh and the Torus Tolerating a Large Number of Faults

AbstractSuppose ach node (and each edge) of a network is independently faulty with probability at mostp(andq, respectively), where 0<p,q<1 are arbitrary constants independent of the size of the network. For each fixed integerd⩾2, we construct a network withO(N) nodes and with degreeO(loglogN) such that, after removing all the faulty nodes and edges, it still contains theN-noded-dimensionalN1/d×…×N1/dtorus, and hence the mesh of the same size, with probability 1−N−Ω(loglogN). This is derived as a consequence of a simple constant-degree construction which tolerates random faults, where the failure probability of each node isO(log−3d N). We also give a simple constant-degree construction withO(N) nodes that toleratesO(N(1−2−d)/d) worst case faults
On the Parallel Complexity of Gaussian Elimination with Pivoting

AbstractConsider the Gaussian elimination algorithm with the well-known partial pivoting strategy for improving numerical stability (GEPP). Vavasis proved that the problem of determining the pivot sequence used by GEPP is log space-complete forP, and thus inherently sequential. AssumingP≠C, we prove here that either the latter problem cannot be solved in parallel timeO(N1/2−ε) or all the problems inPadmit polynomial speedup. HereNis the order of the input matrix andεis any positive constant. This strengthens the P-completeness result mentioned above. We conjecture that the result proved in this paper holds for the stronger boundO(N1−ε) as well, and provide supporting evidence for the conjecture. Note that this is equivalent to asserting the asymptotic optimality of the naive parallel algorithm for GEPP (moduloP≠NC)
Efficient Low-Contention Parallel Algorithms

AbstractThe queue-read, queue-write (qrqw) parallel random access machine (pram) model permits concurrent reading and writing to shared memory locations, but at a cost proportional to the number of readers/writers to any one memory location in a given step. Theqrqw prammodel reflects the contention properties of most commercially available parallel machines more accurately than either the well-studiedcrcw pramorerew prammodels, and can be efficiently emulated with only logarithmic slowdown on hypercube-type noncombining networks. This paper describes fast, low-contention, work-optimal, randomizedqrqw pramalgorithms for the fundamental problems of load balancing, multiple compaction, generating a random permutation, parallel hashing, and distributive sorting. These logarithmic or sublogarithmic time algorithms considerably improve upon the best knownerew pramalgorithms for these problems, while avoiding the high-contention steps typical ofcrcw pramalgorithms. An illustrative experiment demonstrates the performance advantage of a newqrqwrandom permutation algorithm when compared with the popularerewalgorithm. Finally, this paper presents new randomized algorithms for integer sorting and general sorting
An Optimal Predicate Locking Scheduler

AbstractThe paper presents a predicate locking scheduler that maximizes concurrency by locking as many of the database entities as possible without compromising the correctness of execution of the database transactions. The scheduling strategy that guarantees the maximal concurrency is first identified, then a predicate language allowing an efficient implementation of this strategy is given. The optimal predicate locking scheduler is successively presented, based on a lattice-theoretic formalization of the underlying concepts. Finally, the range of applicability of the optimal scheduling strategy is circumscribed, by showing that any significant extension to the expressive power of the predicate language accepted by the optimal scheduler causes an irreparable loss of efficiency
A Threshold for Unsatisfiability

AbstractA propositional formula is in 2-CNF (2-conjunctive normalform) iff it is the conjunction of clauses each of which has exactly two literals. We show: IfC=1+ε, whereε>0 is fixed andq(n)⩾C·n, then almost all formulas in 2-CNF withq(n) different clauses, wherenis the number of variables, are unsatisfiable. IfC=1−εandq(n)⩽C·n, then almost all formulas withq(n) clauses are satisfiable. By “almost all” we mean that the probability of the set of unsatisfiable or satisfiable formulas among all formulas withq(n) clauses approaches 1 asn→∞. SoC=1 gives us a threshold separating satisfiability and unsatisfiability of formulas in 2-CNF in a probabilistic, asymptotic sense. To prove our result we translate the satisfiability problem for formulas in 2-CNF into a graph theoretical question. Then we apply techniques from the theory of random graphs
The Complexity of Nested Counterfactuals and Iterated Knowledge Base Revisions

AbstractWe consider the computational complexity of evaluating nested counterfactuals over a propositional knowledge base. A counterfactualp>qis a conditional query with the meaning “Ifpwould be true in the knowledge base, would it then hold that alsoqis true,” which is different from material implicationp⇒q. A nested counterfactual is a counterfactual statement where the premisepor the conclusionqis a counterfactual. Statements of the formp1>(p2…(pn>q)…) intuitively correspond to conditional queries involving a sequence of revisions. We show that evaluating such statements isΠP2-complete and that this task becomes PSPACE-complete if negation is allowed in a nesting of this form. We also consider nesting a counterfactual in the premise, i.e., (p>q)>r, and show that evaluating such statements isΠP4-complete, thus most likely much harder than evaluatingp>(q>r). Finally, we also address iterated nestings in the premise and the mix of nestings in the premise and the conclusion
River Routing with a Generalized Model

AbstractTraditional restrictions on river routing confine the connecting wires to the channel between the terminal rows. In (J. Comput. System Sci.28(1984), 420–438) these restrictions were somewhat relaxed, thereby permitting a limited type of routing outside of the channel. Here, the constraints are further relaxed to allow for a new class of “generalized” river routings. We show that this new class of generalized river routings contains routings that are significantly more compact than those previously considered. In addition, we give a fast polynomial time algorithm for producing optimal routings in this new class. The run time of our algorithm is the best possible and is identical to the time required to produce optimal river routings under the traditional model
On Completeness under Random Reductions

AbstractIn this paper, we study the notion of completeness under random reductions and explore how that depends on the type and success probability of the reduction. We obtain absolute separations between completeness notions under various random reductions and between random reductions and deterministic reductions. These separations are obtained in appropriately high complexity classes where these questions do not have contradictory relativizations. Our results show that the notion of completeness under random reductions is sensitive tovery smallchanges in success probability, since we can separate completeness under reductions with very small differ- ences in success probability. We also obtain optimal separations between completeness under various deterministic reductions and random reductions
Regular Description of Context-free Graph Languages

AbstractA set of (labeled) graphs can be defined by a regular tree language and one regular string language for each possible edge label, as follows. For each treetfrom the regular tree language the graph gr(t) has the same nodes ast(with the same labels), and there is an edge with labelαfrom nodexto nodeyif the string of labels of the nodes on the shortest path fromxtoyintbelongs to the regular string language forα. Slightly generalizing this definition scheme, we allow gr(t) to have only those nodes oftthat have certain labels, and we allow a relabeling of these nodes. It is shown that in this way exactly the class of C-edNCE graph languages (generated by C-edNCE graph grammars) is obtained, one of the largest known classes of context-free graph languages
Partition Triples: A Tool for Reduction of Data Sets

AbstractData sets discussed in this paper are presented as tables with rows corresponding to examples (entities, objects) and columns to attributes. A partition triple is defined for such a table as a triple of partitions on the set of examples, the set of attributes, and the set of attribute values, respectively, preserving the structure of a table. The idea of a partition triple is an extension of the idea of a partition pair, introduced by J. Hartmanis and J. Stearns in automata theory. Results characterizing partition triples and algorithms for computing partition triples are presented. The theory is illustrated by an example of an application in machine learning from examples
Program Synthesis in the Presence of Infinite Number of Inaccuracies

AbstractMost studies modeling inaccurate data in Gold style learning consider cases in which the number of inaccuracies is finite. The present paper argues that this approach is not reasonable for modelling inaccuracies in concepts that are infinite in nature (for example, graphs of computable functions). The effect of an infinite number of inaccuracies in the input data in Gold's model of learning is considered in the context of identification in the limit of computer programs from graphs of computable functions. Three kinds of inaccuracies, namely, noisy data, incomplete data, and imperfect data, are considered. The amount of each of these inaccuracies in the input is measured using certain density notions. A number of interesting hierarchy results are shown based on the densities of inaccuracies present in the input data. Several results establishing trade-offs between the density and type of inaccuracies are also derived
Fully Parallelized Multi-prover Protocols for NEXP-Time

AbstractA major open problem in the theory of multi-prover interactive proofs is to characterize the languages which can be accepted by fully parallelized multi-prover protocols with an exponentially low probability of cheating. In this paper we solve this problem by proving that any language which can be accepted by a sequential multi-prover protocol can also be accepted by a single-round multi-party protocol, and thus the multi-prover round hierarchy collapses to its first level: MIP(poly)=MIP(1)=NEXP-time
Connected Components inO(log3/2n) Parallel Time for the CREW PRAM

AbstractFinding the connected components of an undirected graphG=(V, E) onn=|V| vertices andm=|E| edges is a fundamental computational problem. The best known parallel algorithm for the CREW PRAM model runs inO(log2n) time usingn2/log2nprocessors. For the CRCW PRAM model, in which concurrent writing is permitted, the best known algorithm runs inO(logn) time using slightly more than (n+m)/lognprocessors. Simulating this algorithm on the weaker CREW model increases its running time toO(log2n). We present here a simple algorithm that runs inO(log3/2n) time usingn+mCREW processors. Finding ano(log2n) parallel connectivity algorithm for this model was an open problem for many years
All Pairs Shortest Paths for Graphs with Small Integer Length Edges

AbstractThe authors have solved the all pairs shortest distances (APSD) problem for graphs with integer edge lengths. Our algorithm is subcubic for edge lengths of small (⩽M) absolute value. In this paper we show how to transform these algorithms to solve the all pairs shortest paths (APSP), in the same time complexity, up to a polylogarithmic factor. Forn=|V| the number of vertices,Mthe bound on edge length, andωthe exponent of matrix multiplication, we get the following results: 1. A directed nonnegative APSP(n, M) algorithm which runs inÕ(T(n, M)) time, where T(n, m)=\big\{\begin{align}M^{\omega -1)/2} n^{3+\omega )/2}, & 1\le M\le n^{3-\omega )/(\omega +1)}\\ Mn^{5\omega -3)/(\omega +1)}, & n^{(3-\omega )/(\omega +1)}\le M\le n^2(3-\omega )/(\omega +1)}.\end{align} 2. An undirected APSP(n, M) algorithm which runs inÕ(M(ω+1)/2nωlog(Mn)) time. 3. A general APSP(n, M) algorithm which runs inÕ((Mn)(3+ω)/2)
On the Exponent of the All Pairs Shortest Path Problem

AbstractThe upper bound on the exponent,ω, of matrix multiplication over a ring that was three in 1968 has decreased several times and since 1986 it has been 2.376. On the other hand, the exponent of the algorithms known for the all pairs shortest path problem has stayed at three all these years even for the very special case of directed graphs with uniform edge lengths. In this paper we give an algorithm of timeO(nνlog3n),ν=(3+ω)/2, for the case of edge lengths in {−1, 0, 1}. Thus, for the current known bound onω, we get a bound on the exponent,ν<2.688. In case of integer edge lengths with absolute value bounded above byM, the time bound isO((Mn)νlog3n) and the exponent is less than 3 forM=O(nα), forα<0.116 and the current bound onω
The Expressive Powers of Stable Models for Bound and Unbound DATALOG Queries

AbstractVarious types of stable models are known in the literature:T-stable(total stable),P-stable(partial stable, also calledthree-valued stable),M-stable(maximal stable, also known under various different names), andL-stable(least undefined stable). For each type of stable model, the paper analyzes two versions of deterministic semantics:possiblesemantics, which is based on the union of all stable models of the given type, anddefinitesemantics, which is instead based on their intersection and is like classicalcertainsemantics except that it makes no inference if no model exists. For total stable models, which are the only type of stable models whose existence is not guaranteed for every program, certain semantics is taken into account as well. The expressive powers of each type of stable model under the above versions of semantics are investigated for bothbound(i.e., ground) andunboundqueries on DATALOG programs with negation. As deterministic semantics is argued to be inappropriate for unbound queries, a non-deterministic semantics is also proposed for them and its expressive power is fully characterized as well