pinecone/core-2020-05-10-deduplication huggingface dataset:
Linear-Consistency Testing

AbstractWe extend the notion of linearity testing to the task of checking linear consistency of multiple functions. Informally, functions are “linear” if their graphs form straight lines on the plane. Two such functions are “consistent” if the lines have the same slope. We propose a variant of a test of M. Blum et al. (J. Comput. System Sci.47 (1993), 549–595) to check the linear consistency of three functions f1, f2, f3 mapping a finite Abelian group G to an Abelian group H:Pick x, y∈G uniformly and independently at random and check if f1(x)+f2(y)=f3(x+y). We analyze this test for two cases: (1) G and H are arbitrary Abelian groups and (2) G=Fn2 and H=F2. Questions bearing close relationship to linear-consistency testing seem to have been implicitly considered in recent work on the construction of PCPs and in particular in the work of J. Håstad [9] (in “Proceedings of the Twenty-Ninth Annual ACM Symposium on Theory of Computing, El Paso, Texas, 4–6 May 1997,” pp. 1–10). It is abstracted explicitly for the first time here. As an application of our results we give yet another new and tight characterization of NP, namely ∀ε>0, NP=MIP1−ε, 1/2[O(logn), 3, 1]. That is, every language in NP has 3-prover 1-round proof systems in which the verifier tosses O(logn) coins and asks each of the three provers one question each. The provers respond with one bit each such that the verifier accepts instance of the language with probability 1−ε and rejects noninstances with probability at least 12. Such a result is of some interest in the study of probabilistically checkable proofs
Translating Regular Expressions into Small ε-Free Nondeterministic Finite Automata

AbstractWe prove that every regular expression of size n can be converted into an equivalent nondeterministic ε-free finite automaton (NFA) with O(n(logn)2) transitions in time O(n2logn). The best previously known conversions result in NFAs of worst-case size Θ(n2). We complement our result by proving an almost matching lower bound. We exhibit a sequence of regular expressions of size O(n) and show the number of transitions required in equivalent NFAs is Ω(nlogn). This also proves there does not exist a linear-size conversion from regular expressions to NFAs
Refinements of Complexity Results on Type Consistency for Object-Oriented Databases

AbstractThe method invocation mechanism is one of the essential features in object-oriented programming languages. This mechanism contributes to data encapsulation and code reuse, but there is a risk of a run-time type error. In the case of object-oriented databases (OODBs), a run-time error causes rollback. Therefore, it is desirable to ensure that a given OODB schema is consistent; i.e., no run-time type error occurs during the execution of queries under any database instance of the OODB schema. This paper discusses the computational complexity of the type-consistency problem. As a model of OODB schemas, we adopt update schemas introduced by R. Hull et al., which have all of the basic features of OODBs such as class hierarchy, inheritance, and complex objects. For several subclasses of update schemas, the complexity of the type-consistency problem is presented. Importantly, it turns out that nonflatness of the class hierarchy, recursion in the queries, and update operations in the queries each make the problem difficult
Fairness in Routing and Load Balancing

AbstractWe consider the issue of network routing subject to explicit fairness conditions. The optimization of fairness criteria interacts in a complex fashion with the optimization of network utilization and throughput; in this work, we undertake an investigation of this relationship through the framework of approximation algorithms. In a range of settings including both high-speed networks and Internet applications, max–min fairness has emerged as a widely accepted formulation of the notion of fairness. Informally, we say that an allocation of bandwidth is max–min fair if there is no way to give more bandwidth to any connection without decreasing the allocation to a connection of lesser or equal bandwidth. Given a collection of transmission routes, this criterion imposes a certain equilibrium condition on the bandwidth allocation, and some simple flow control mechanisms converge quickly to this equilibrium state. Indeed, the vast majority of previous work on max–min fairness has focused on this issue of associating rates with connections that are specified by a fixed set of paths. Very little work has been devoted to understanding the relationship between the way in which one selects paths for routing, and the amount of throughput one obtains from the resulting max–min fair allocation on these paths. In this work, we consider the problem of selecting paths for routing in order to provide a bandwidth allocation that is as fair as possible (in the max–min sense). We obtain the first approximation algorithms for this basic optimization problem, for single-source unsplittable routings in an arbitrary directed graph. Special cases of our model include several fundamental load balancing problems, endowing them with a natural fairness criterion to which our approach can be applied
Compression Using Efficient Multicasting

AbstractMany multiprocessor systems have the ability to broadcast and/or multicast information efficiently. However, this ability is often overlooked when designing algorithms for these systems. In this paper, we introduce a new compression technique that uses efficient multicasting to significantly reduce the amount of information communicated during parallel and distributed computation, resulting in significantly faster algorithms for Fast Fourier Transforms and sorting on shared memory parallel models with limited bandwidth. These algorithms demonstrate the importance of taking advantage of efficient multicasting. The compression technique uses a new, natural variant of Ramsey theory, which may be of independent interest
Sharing the Cost of Multicast Transmissions

AbstractWe investigate cost-sharing algorithms for multicast transmission. Economic considerations point to two distinct mechanisms, marginal cost and Shapley value, as the two solutions most appropriate in this context. We prove that the former has a natural algorithm that uses only two messages per link of the multicast tree, while we give evidence that the latter requires a quadratic total number of messages. We also show that the welfare value achieved by an optimal multicast tree is NP-hard to approximate within any constant factor, even for bounded-degree networks. The lower-bound proof for the Shapley value uses a novel algebraic technique for bounding from below the number of messages exchanged in a distributed computation; this technique may prove useful in other contexts as well
Combining Fairness with Throughput: Online Routing with Multiple Objectives

AbstractThis paper presents online algorithms for routing and bandwidth allocation which simultaneously approximate fair and max-throughput solutions. In fact, the algorithms solve a more difficult problem: for any bandwidth b, the number of sessions that get bandwidth b in the online algorithm is not smaller than the number of sessions receiving γb offline, where γ is the competitive ratio. This problem is provably harder than the problem of maximizing throughput (e.g., [4]) or the problem of maximizing the bandwidth assigned to the most starved session (e.g., [3]). For the case where the algorithm assigns bandwidths, we present an O(log2nlog1+εU/ε)-competitive algorithm, for any ε, where U is the minimum (over all choices of routes) of the maximum number of sessions routed along any single link. We also show an Ω(log1+εU/ε) lower bound in this model. For a more practically interesting model where the algorithm assigns routes and weights, and where these weights are used to drive the Weighted Fair Queuing policy in the routers, we present an O(log2nlogU)-competitive algorithm. We also show that the dependence on U is necessary by presenting an Ω(logU) lower bound. Previous upper and lower bounds for online maximization of throughput become invalid if we are allowed to assign weights. We prove an Ω(logn) lower bound for this model and present an O(lognloglogn)-competitive online algorithm. We present preliminary simulation results which show that our algorithm is effective in attaining high throughput without significantly sacrificing fairness
The Combinatorics of Cache Misses during Matrix Multiplication

AbstractIn this paper we construct an analytic model of cache misses during matrix multiplication. The analysis in this paper applies to square matrices of size 2m where the array layout function is given in terms of a function Θ that interleaves the bits in the binary expansions of the row and column indices. We first analyze the number of cache misses for direct-mapped caches and then indicate how to extend this analysis to A-way associative caches. The work in this paper accomplishes two things. First, we construct fast algorithms to estimate the number of cache misses. Second, we develop a theoretical understanding of cache misses that will allow us, in subsequent work, to approach the problem of minimizing cache misses by appropriately choosing the bit interleaving function that goes into the array layout function
Recommendation Systems: A Probabilistic Analysis

AbstractA recommendation system tracks past actions of a group of users to make recommendations to individual members of the group. The growth of computer-mediated marketing and commerce has led to increased interest in such systems. We introduce a simple analytical framework for recommendation systems, including a basis for defining the utility of such a system. We perform probabilistic analyses of algorithms within this framework. These analyses yield insights into how much utility can be derived from knowledge of past user actions
Language Learning from Texts: Degrees of Intrinsic Complexity and Their Characterizations

AbstractThis paper deals with two problems: (1) what makes languages learnable in the limit by natural strategies of varying hardness, and (2) what makes classes of languages the hardest ones to learn. To quantify hardness of learning, we use intrinsic complexity based on reductions between learning problems. Two types of reductions are considered: weak reductions mapping texts (representations of languages) to texts and strong reductions mapping languages to languages. For both types of reductions, characterizations of complete (hardest) classes in terms of their algorithmic and topological potentials have been obtained. To characterize the strong complete degree, we discovered a new and natural complete class capable of “coding” any learning problem using density of the set of rational numbers. We have also discovered and characterized rich hierarchies of degrees of complexity based on “core” natural learning problems. The classes in these hierarchies contain “multidimensional” languages, where the information learned from one dimension aids in learning other dimensions. In one formalization of this idea, the grammars learned from the dimensions 1, 2, …, k specify the “subspace” for the dimension k+1, while the learning strategy for every dimension is predefined. In our other formalization, a “pattern” learned from the dimension k specifies the learning strategy for the dimension k+1. A number of open problems are discussed
The Communication Complexity of Enumeration, Elimination, and Selection

AbstractLet k, n∈N and f:{0, 1}n×{0, 1}n→{0, 1}. Assume Alice has x1, …, xk∈ {0, 1}n, Bob has y1, …, yk∈{0, 1}n, and they want to compute fk(x1x2···xk, y1y2···yk)=(f(x1, y1), …, f(xk, yk)) (henceforth f(x1, y1)···f(xk, yk)) communicating as few bits as possible. The direct sum conjecture (henceforth DSC) of Karchmer, Raz, and Wigderson states that the obvious way to compute it (computing f(x1, y1), then f(x2, y2), etc.) is, roughly speaking, the best. This conjecture arose in the study of circuits since a variant of it implies NC1≠NC2. We consider two related problems. Enumeration:Alice and Bob output e⩽2k−1 elements of {0, 1}k, one of which is f(x1, y1)···f(xk, yk). Elimination :Alice and Bob output b such that b≠f(x1, y1)···f(xk, yk). Selection :(k=2) Alice and Bob output i∈{1, 2} such that if f(x1, y1) =1∨f(x2, y2)=1 then f(xi, yi)=1. (a)We devise the enumeration conjecture (henceforth ENC) and the elimination conjecture (henceforth ELC) which roughly state that the obvious ways to compute enumeration and elimination are the best. We use these conjectures to formulate an attack on DSC.  (b)For several natural functions f, any deterministic protocol for the elimination problem for fk requires Ω(n) bits. This establishes a weak form of ELC for these functions.  (c)For several graph properties f we show that any deterministic protocol for the elimination problem for fk requires Ω(|V|) bits. To accomplish this we establish some very general theorems about the communication complexity of graph properties which are of independent interest.  (d)For several natural functions f, any randomized protocol for the elimination problem for fk requires Ω(n(loglog(n))(log(n))) bits. This establishes a weak randomized version of ELC for these functions.  (e)Under a reasonable (but unproven) assumption, the elimination problem for f2requiresΩ(D(f)) bits, where D(f) is the deterministic complexity of f. This links a weak version of ELC to other assumptions
Branching Program Size Is Almost Linear in Formula Size

AbstractCircuit size, formula size, and branching program size are the most important complexity measures for boolean functions. Although the corresponding computation models and the relations between these complexity measures have been investigated quite well in the past, we are still lacking a tight upper bound for the branching program size in terms of formula size. The best previously known simulation of B2-formulas of size ℓ by branching programs achieves a branching program size of O(ℓ1.195) (1999, M. Sauerhoff, I. Wegener, and R. Werchner, Lecture Notes in Computer Science, Vol. 1563, pp. 57–67, Springer-Verlag, Berlin/New York). This work presents a proof showing that every B2-formula of size ℓ can be transformed into a branching program of size O(ℓ1+ε) for an arbitrary ε>0. The proof is based on three major steps. First, a given formula is balanced appropriately. Then, a technique due to R. Cleve (1991, Comput. Complexity1, 91–105) to simulate balanced algebraic formulas of size s by algebraic straight-line programs that employ a constant number of registers and have length O(s1+ε) is applied. Finally, it is shown how branching programs of the stated size can be obtained from the constructed straight-line programs
Easiness Assumptions and Hardness Tests: Trading Time for Zero Error

AbstractWe propose a new approach toward derandomization in the uniform setting, where it is computationally hard to find possible mistakes in the simulation of a given probabilistic algorithm. The approach consists in combining both easiness and hardness complexity assumptions: if a derandomization method based on an easiness assumption fails, then we obtain a certain hardness test that can be used to remove error in BPP algorithms. As an application, we prove that every RP algorithm can be simulated by a zero-error probabilistic algorithm, running in expected subexponential time, that appears correct infinitely often (i.o.) to every efficient adversary. A similar result by Impagliazzo and Wigderson (FOCS'98) states that BPP allows deterministic subexponential-time simulations that appear correct with respect to any efficiently sampleable distribution i.o., under the assumption that EXP≠BPP; in contrast, our result does not rely on any unproven assumptions. As another application of our techniques, we get the following gap theorem for ZPP: either every RP algorithm can be simulated by a deterministic subexponential-time algorithm that appears correct i.o. to every efficient adversary or EXP=ZPP. In particular, this implies that if ZPP is somewhat easy, e.g., ZPP⊆DTIME(2nc) for some fixed constant c, then RP is subexponentially easy in the uniform setting described above
On the Complexity of Some Problems on Groups Input as Multiplication Tables

AbstractThe Cayley group membership problem (CGM) is to input a groupoid (binary algebra) G given as a multiplication table, a subset X of G, and an element t of G and to determine whether t can be expressed as a product of elements of X. For general groupoids CGM is P-complete, and for associative algebras (semigroups) it is NL-complete. Here we investigate CGM for particular classes of groups. The problem for general groups is in SL (symmetric log space), but any kind of hardness result seems difficult because proving it would require constructing the entire multiplication table of a group. We introduce the complexity class FOLL, or FO(loglogn), of problems solvable by uniform poly-size circuit families of unbounded fan-in and depth O(loglogn). No problem in FOLL can be hard for L or for any other class containing parity, but FOLL is not known to be contained even in SL. We show that CGM for cyclic groups is in FOLL∩L and that CGM for abelian groups is in FOLL. We then examine the case of some solvable groups, showing in particular that CGM for nilpotent groups is also provably not hard for any class containing parity. We also consider the problem of testing for various properties of a group input as a table: we prove that cyclicity and nilpotency can each be tested in FOLL∩L. Finally, we examine the implications of our results for the complexity of iterated multiplication, powering, and division of integers in the context of the recent results of Chiu, Davida, and Litow and of Hesse
Time–Space Tradeoffs for SAT on Nonuniform Machines

AbstractThe arguments used by R. Kannan (1984, Math. Systems Theory17, 29–45), L. Fortnow (1997, in “Proceedings, Twelfth Annual IEEE Conference on Computational Complexity, Ulm, Germany, 24–27 June, 1997,” pp. 52–60), and R. J. Lipton and A. Viglas (1999, in “40th Annual Symposium on Foundations of Computer Science, New York, 17–19 Oct. 1999,” pp. 459–469) are generalized and combined with an argument for diagonalizing over machines taking n bits of advice on inputs of length n to obtain the first nontrivial time–space lower bounds for SAT on nonuniform machines. In particular, we show that for any a<2 and any ε>0, SAT cannot be computed by a random access deterministic Turing machine using na time, no(1) space, and o(n2/2−ε) advice nor by a random access deterministic Turing machine using n1+o(1) time, n1−ε space, and n1−ε advice. More generally, we show that if for some ε>0 there exists a random access deterministic Turing machine solving SAT using na time, nb space, and o(n(a+b)/2−ε) advice, then a⩾12(b2+8−b). Lower bounds for computing \overline{{\bfSAT}} on random access nondeterministic Turing machines taking sublinear advice are also obtained. Moreover, we show that SAT does not have NC1 circuits of size nl+o(1) generated by a nondeterministic log–space machine taking no(1) advice. Additionally, new separations of uniform classes are obtained. We show that for all ε>0 and all rational numbers r⩾1, DTISP(nr, n1−ε) is properly contained in NTIME(nr)
Integer Circuit Evaluation Is PSPACE-Complete

AbstractK. W. Wagner (1984, Technical report N/84/52, Friedrich–Schiler-Universität Jena) introduced the integer circuit evaluation problem. Informally, the problem concerns a circuit that takes singleton sets, each containing one integer, and combines them using three types of set operations: A∪B, A ⊗B={a·b∣a∈A, b∈B}, and A⊗B={a+b∣a∈A, b∈B}. The problem is to determine whether the set output by the circuit contains a particular integer. In this paper we show that the integer circuit problem is PSPACE-complete, resolving an open problem posed by P. McKenzie, H. Vollmer, and K. W. Wagner (2000, in “Proceedings of the 2000 FSTTCS conference, New Delhi, India, December)
Quantum Neural Networks

AbstractThis paper initiates the study of quantum computing within the constraints of using a polylogarithmic (O(logkn), k⩾1) number of qubits and a polylogarithmic number of computation steps. The current research in the literature has focussed on using a polynomial number of qubits. A new mathematical model of computation called Quantum Neural Networks (QNNs) is defined, building on Deutsch's model of quantum computational network. The model introduces a nonlinear and irreversible gate, similar to the speculative operator defined by Abrams and Lloyd. The precise dynamics of this operator are defined and while giving examples in which nonlinear Schrödinger's equations are applied, we speculate on its possible implementation. The many practical problems associated with the current model of quantum computing are alleviated in the new model. It is shown that QNNs of logarithmic size and constant depth have the same computational power as threshold circuits, which are used for modeling neural networks. QNNs of polylogarithmic size and polylogarithmic depth can solve the problems in NC, the class of problems with theoretically fast parallel solutions. Thus, the new model may indeed provide an approach for building scalable parallel computers
Heuristics for Semirandom Graph Problems

AbstractWe consider semirandom graph models for finding large independent sets, colorings, and bisections in graphs. These models generate problem instances by blending random and adversarial decisions. To generate semirandom independent set problems, an independent set S of αn vertices is randomly chosen. Each edge connecting S with S is chosen with probability p, and an adversary is then allowed to add new edges arbitrarily, provided that S remains an independent set. The smaller p is, the greater the control the adversary has over the semirandom graph. We give a heuristic that with high probability recovers an independent set of size αn whenever p> (1+ε)lnn/αn, for any constant ε>0. We show that when p<(1−ε)lnn /αn, an independent set of size |S| cannot be recovered, unless NP⊆BPP. We use our result for maximum independent sets to obtain greatly improved heuristics for the model of k-colorable semirandom graphs introduced by Blum and Spencer. For constant k, our results are optimal up to constant factors in the edge probabilities. In the semirandom model for graph bisection, a random bisection (S, S) of the vertices is chosen. Each edge (u, v)∈S×S is independently chosen with probability q and each edge (u, v)∉S×S is independently chosen with probability p>q. The adversary may then arbitrarily remove edges in S×S and add edges not in S×S. Extending the work of Boppana, we give a heuristic that recovers this bisection with high probability when p−q⩾cplogn/n, for c a sufficiently large constant