Showing papers in "Journal of the ACM in 2019"
TL;DR: This work presents a solution for the multi-armed bandit problem, in which the strategies form a metric space, and the payoff function satisfies a Lipschitz condition with respect to the metric, and presents an algorithm that comes arbitrarily close to meeting this bound.
Abstract: In a multi-armed bandit problem, an online algorithm chooses from a set of strategies in a sequence of trials to maximize the total payoff of the chosen strategies. While the performance of bandit algorithms with a small finite strategy set is well understood, bandit problems with large strategy sets are still a topic of active investigation, motivated by practical applications, such as online auctions and web advertisement. The goal of such research is to identify broad and natural classes of strategy sets and payoff functions that enable the design of efficient solutions. In this work, we study a general setting for the multi-armed bandit problem, in which the strategies form a metric space, and the payoff function satisfies a Lipschitz condition with respect to the metric. We refer to this problem as the Lipschitz MAB problem. We present a solution for the multi-armed bandit problem in this setting. That is, for every metric space, we define an isometry invariant that bounds from below the performance of Lipschitz MAB algorithms for this metric space, and we present an algorithm that comes arbitrarily close to meeting this bound. Furthermore, our technique gives even better results for benign payoff functions. We also address the full-feedback (“best expert”) version of the problem, where after every round the payoffs from all arms are revealed.
64 citations
TL;DR: The adversarial stochastic input model, where an adversary controls the distributions from which the requests are drawn at each step, is introduced and an algorithm that obtains a 1−ε fraction of the optimal profit obtainable w.r.t. the worst distribution in the adversarial sequence is designed.
Abstract: We present prior robust algorithms for a large class of resource allocation problems where requests arrive one-by-one (online), drawn independently from an unknown distribution at every step. We design a single algorithm that, for every possible underlying distribution, obtains a 1−e fraction of the profit obtained by an algorithm that knows the entire request sequence ahead of time. The factor e approaches 0 when no single request consumes/contributes a significant fraction of the global consumption/contribution by all requests together. We show that the tradeoff we obtain here that determines how fast e approaches 0, is near optimal: We give a nearly matching lower bound showing that the tradeoff cannot be improved much beyond what we obtain.Going beyond the model of a static underlying distribution, we introduce the adversarial stochastic input model, where an adversary, possibly in an adaptive manner, controls the distributions from which the requests are drawn at each step. Placing no restriction on the adversary, we design an algorithm that obtains a 1−e fraction of the optimal profit obtainable w.r.t. the worst distribution in the adversarial sequence. Further, if the algorithm is given one number per distribution, namely the optimal profit possible for each of the adversary’s distribution, then we design an algorithm that achieves a 1−e fraction of the weighted average of the optimal profit of each distribution the adversary picks.In the offline setting we give a fast algorithm to solve very large linear programs (LPs) with both packing and covering constraints. We give algorithms to approximately solve (within a factor of 1+e) the mixed packing-covering problem with O(γ m log (n/δ)/e2) oracle calls where the constraint matrix of this LP has dimension n× m, the success probability of the algorithm is 1−δ, and γ quantifies how significant a single request is when compared to the sum total of all requests.We discuss implications of our results to several special cases including online combinatorial auctions, network routing, and the adwords problem.
62 citations
TL;DR: This framework builds new connections between the variable framework of the Lovász Local Lemma and some classical sampling algorithms such as the cycle-popping algorithm for rooted spanning trees and new algorithms to sample satisfying assignments of k-CNF formulas with bounded variable occurrences.
Abstract: We propose a new algorithmic framework, called partial rejection sampling, to draw samples exactly from a product distribution, conditioned on none of a number of bad events occurring. Our framework builds new connections between the variable framework of the Lovasz Local Lemma and some classical sampling algorithms such as the cycle-popping algorithm for rooted spanning trees. Among other applications, we discover new algorithms to sample satisfying assignments of k-CNF formulas with bounded variable occurrences.
35 citations
TL;DR: There is a polynomial-time algorithm with approximation guarantee 3/2+ε for the s-t-path TSP, for any fixed ε > 0, that “guesses” lonely cuts and edges and strengthens the LP.
Abstract: We show that there is a polynomial-time algorithm with approximation guarantee 3/2+e for the s-t-path TSP, for any fixed e > 0. It is well-known that Wolsey’s analysis of Christofide algorithm also works for the s-t-path TSP with its natural LP relaxation, except for the narrow cuts (in which the LP solution has a value less than two). A fixed optimum tour has either a single edge in a narrow cut (then call the edge and the cut lonely) or at least three (then call the cut busy). Our algorithm “guesses” (by dynamic programming) lonely cuts and edges. Then, we partition the instance into smaller instances and strengthen the LP, requiring a value of at least three for busy cuts. By setting up a k-stage recursive dynamic program, we can compute a spanning tree (V,S) and an LP solution y such that (½+O(2−k))y is in the T-join polyhedron, where T is the set of vertices whose degree in S has the wrong parity.
34 citations
TL;DR: It is proved that the Weisfeiler--Leman (WL) dimension of the class of all finite planar graphs is at most 3 and, apart from several exceptional graphs, the individualization of two appropriately chosen vertices of a colored 3-connected planar graph followed by the one-dimensional WL-algorithm produces the discrete vertex partition.
Abstract: We prove that the Weisfeiler--Leman (WL) dimension of the class of all finite planar graphs is at most 3. In particular, every finite planar graph is definable in first-order logic with counting using at most 4 variables. The previously best-known upper bounds for the dimension and number of variables were 14 and 15, respectively. First, we show that, for dimension 3 and higher, the WL-algorithm correctly tests isomorphism of graphs in a minor-closed class whenever it determines the orbits of the automorphism group of every arc-colored 3-connected graph belonging to this class. Then, we prove that, apart from several exceptional graphs (which have WL-dimension at most 2), the individualization of two appropriately chosen vertices of a colored 3-connected planar graph followed by the one-dimensional WL-algorithm produces the discrete vertex partition. This implies that the three-dimensional WL-algorithm determines the orbits of arc-colored 3-connected planar graphs. As a byproduct of the proof, we get a classification of the 3-connected planar graphs with fixing number 3.
31 citations
TL;DR: An algorithm to approximately count the number of solutions to a CNF formula Φ when the width is logarithmic in the maximum degree is introduced, which closes an exponential gap between the known upper and lower bounds.
Abstract: In this article, we introduce a new approach to approximate counting in bounded degree systems with higher-order constraints. Our main result is an algorithm to approximately count the number of solutions to a CNF formula Φ when the width is logarithmic in the maximum degree. This closes an exponential gap between the known upper and lower bounds. Moreover, our algorithm extends straightforwardly to approximate sampling, which shows that under Lovasz Local Lemma-like conditions it is not only possible to find a satisfying assignment, it is also possible to generate one approximately uniformly at random from the set of all satisfying assignments. Our approach is a significant departure from earlier techniques in approximate counting, and is based on a framework to bootstrap an oracle for computing marginal probabilities on individual variables. Finally, we give an application of our results to show that it is algorithmically possible to sample from the posterior distribution in an interesting class of graphical models.
29 citations
TL;DR: These constructions are based on the notion of “inference dimension,” recently introduced by the authors in the context of active classification with comparison queries, and can be viewed as another contribution to the fruitful link between machine learning and discrete geometry, which goes back to the discovery of the VC dimension.
Abstract: We construct near-optimal linear decision trees for a variety of decision problems in combinatorics and discrete geometry. For example, for any constant k, we construct linear decision trees that solve the k-SUM problem on n elements using O(n log2 n) linear queries. Moreover, the queries we use are comparison queries, which compare the sums of two k-subsets; when viewed as linear queries, comparison queries are 2k-sparse and have only l −1,0,1r coefficients. We give similar constructions for sorting sumsets A+B and for solving the SUBSET-SUM problem, both with optimal number of queries, up to poly-logarithmic terms. Our constructions are based on the notion of “inference dimension,” recently introduced by the authors in the context of active classification with comparison queries. This can be viewed as another contribution to the fruitful link between machine learning and discrete geometry, which goes back to the discovery of the VC dimension.
27 citations
TL;DR: The non-existence of an F(k)-FPT-approximation algorithm for any function F was shown under Gap-ETH and to prove hardness of approximation of a certain parameterized variant of the label cover problem, it suffices to devise a specific protocol for a communication problem that depends on which hypothesis the authors rely on.
Abstract: We study the parameterized complexity of approximating the k-Dominating Set (DomSet) problem where an integer k and a graph G on n vertices are given as input, and the goal is to find a dominating set of size at most F(k) ⋅ k whenever the graph G has a dominating set of size k. When such an algorithm runs in time T(k) ⋅ poly (n) (i.e., FPT-time) for some computable function T, it is said to be an F(k)-FPT-approximation algorithm for k-DomSet. Whether such an algorithm exists is listed in the seminal book of Downey and Fellows (2013) as one of the “most infamous” open problems in parameterized complexity. This work gives an almost complete answer to this question by showing the non-existence of such an algorithm under W[1] ≠ FPT and further providing tighter running time lower bounds under stronger hypotheses. Specifically, we prove the following for every computable functions T, F and every constant e > 0:• Assuming W[1] ≠ FPT, there is no F(k)-FPT-approximation algorithm for k-DomSet.• Assuming the Exponential Time Hypothesis (ETH), there is no F(k)-approximation algorithm for k-DomSet that runs in T(k) ⋅ no(k) time.• Assuming the Strong Exponential Time Hypothesis (SETH), for every integer k ≥ 2, there is no F(k)-approximation algorithm for k-DomSet that runs in T(k) ⋅ nk − e time.• Assuming the k-SUM Hypothesis, for every integer k ≥ 3, there is no F(k)-approximation algorithm for k-DomSet that runs in T(k) ⋅ n⌈ k/2 ⌉ − e time.Previously, only constant ratio FPT-approximation algorithms were ruled out under sf W[1] ≠ FPT and (log1/4 m this allows us to easily apply known techniques to solve them.
26 citations
TL;DR: This work develops a systematic approach, based on convex programming and real analysis, for obtaining upper bounds on the capacity of the binary deletion channel and, more generally, channels with i.i.d. insertions and deletions, and derives the first set of capacity upper bounds for the Poisson-repeat channel.
Abstract: We develop a systematic approach, based on convex programming and real analysis for obtaining upper bounds on the capacity of the binary deletion channel and, more generally, channels with i.i.d. insertions and deletions. Other than the classical deletion channel, we give special attention to the Poisson-repeat channel introduced by Mitzenmacher and Drinea (IEEE Transactions on Information Theory, 2006). Our framework can be applied to obtain capacity upper bounds for any repetition distribution (the deletion and Poisson-repeat channels corresponding to the special cases of Bernoulli and Poisson distributions). Our techniques essentially reduce the task of proving capacity upper bounds to maximizing a univariate, real-valued, and often concave function over a bounded interval. The corresponding univariate function is carefully designed according to the underlying distribution of repetitions, and the choices vary depending on the desired strength of the upper bounds as well as the desired simplicity of the function (e.g., being only efficiently computable versus having an explicit closed-form expression in terms of elementary, or common special, functions). Among our results, we show the following: (1) The capacity of the binary deletion channel with deletion probability d is at most (1 − d) φ for d ≥ 1/2 and, assuming that the capacity function is convex, is at most 1 − d log(4/φ) for d d outside the limiting case d → 0 that is fully explicit and proved without computer assistance. (2) We derive the first set of capacity upper bounds for the Poisson-repeat channel. Our results uncover further striking connections between this channel and the deletion channel and suggest, somewhat counter-intuitively, that the Poisson-repeat channel is actually analytically simpler than the deletion channel and may be of key importance to a complete understanding of the deletion channel. (3) We derive several novel upper bounds on the capacity of the deletion channel. All upper bounds are maximums of efficiently computable, and concave, univariate real functions over a bounded domain. In turn, we upper bound these functions in terms of explicit elementary and standard special functions, whose maximums can be found even more efficiently (and sometimes analytically, for example, for d = 1/2).
22 citations
TL;DR: The theorem yields in one stroke significant improvements over the best known exponential-time algorithms for several well-studied problems, including d-HITTING SET, FEEDBACK VERTEX SET, NODE UNIQUE LABEL COVER, and WEIGHTED d-SAT.
Abstract: We give a new general approach for designing exact exponential-time algorithms for subset problems. In a subset problem the input implicitly describes a family of sets over a universe of size n and the task is to determine whether the family contains at least one set. A typical example of a subset problem is WEIGHTED d-SAT. Here, the input is a CNF-formula with clauses of size at most d, and an integer W. The universe is the set of variables and the variables have integer weights. The family contains all the subsets S of variables such that the total weight of the variables in S does not exceed W and setting the variables in S to 1 and the remaining variables to 0 satisfies the formula. Our approach is based on “monotone local search,” where the goal is to extend a partial solution to a solution by adding as few elements as possible. More formally, in the extension problem, we are also given as input a subset X of the universe and an integer k. The task is to determine whether one can add at most k elements to X to obtain a set in the (implicitly defined) family. Our main result is that a cknO(1) time algorithm for the extension problem immediately yields a randomized algorithm for finding a solution of any size with running time O((2−1/c)n). In many cases, the extension problem can be reduced to simply finding a solution of size at most k. Furthermore, efficient algorithms for finding small solutions have been extensively studied in the field of parameterized algorithms. Directly applying these algorithms, our theorem yields in one stroke significant improvements over the best known exponential-time algorithms for several well-studied problems, including d-HITTING SET, FEEDBACK VERTEX SET, NODE UNIQUE LABEL COVER, and WEIGHTED d-SAT. Our results demonstrate an interesting and very concrete connection between parameterized algorithms and exact exponential-time algorithms. We also show how to derandomize our algorithms at the cost of a subexponential multiplicative factor in the running time. Our derandomization is based on an efficient construction of a new pseudo-random object that might be of independent interest. Finally, we extend our methods to establish new combinatorial upper bounds and develop enumeration algorithms.
21 citations
TL;DR: This work gives fault-tolerant algorithms for establishing synchrony in distributed systems in which each of the n nodes has its own clock and gives the first sublinear-time algorithm for the pulse synchronisation problem.
Abstract: We give fault-tolerant algorithms for establishing synchrony in distributed systems in which each of the n nodes has its own clock. Our algorithms operate in a very strong fault model: we require self-stabilisation, i.e., the initial state of the system may be arbitrary, and there can be up to f
TL;DR: This work shows that when lower bounds are proved using random restrictions, it can construct PRGs which are essentially best possible without in turn improving the lower bounds.
Abstract: One powerful theme in complexity theory and pseudorandomness in the past few decades has been the use of lower bounds to give pseudorandom generators (PRGs). However, the general results using this hardness vs. randomness paradigm suffer from a quantitative loss in parameters, and hence do not give nontrivial implications for models where we don’t know super-polynomial lower bounds but do know lower bounds of a fixed polynomial. We show that when such lower bounds are proved using random restrictions, we can construct PRGs which are essentially best possible without in turn improving the lower bounds. More specifically, say that a circuit family has shrinkage exponent Γ if a random restriction leaving a p fraction of variables unset shrinks the size of any circuit in the family by a factor of pΓ + o(1). Our PRG uses a seed of length s1/(Γ + 1) + o(1) to fool circuits in the family of size s. By using this generic construction, we get PRGs with polynomially small error for the following classes of circuits of size s and with the following seed lengths: (1) For de Morgan formulas, seed length s1/3+o(1); (2) For formulas over an arbitrary basis, seed length s1/2+o(1); (3) For read-once de Morgan formulas, seed length s.234...; (4) For branching programs of size s, seed length s1/2+o(1). The previous best PRGs known for these classes used seeds of length bigger than n/2 to output n bits, and worked only for size s=O(n) [8].
TL;DR: The resampling algorithm of Moser and Tardos is a powerful approach to develop constructive versions of the Lovász Local Lemma, and this work generalizes this to partial resampled: When a bad event holds, an appropriately random subset of the variables that define this event rather than the entire set is resample.
Abstract: The resampling algorithm of Moser and Tardos is a powerful approach to develop constructive versions of the Lovasz Local Lemma. We generalize this to partial resampling: When a bad event holds, we resample an appropriately random subset of the variables that define this event rather than the entire set, as in Moser and Tardos. This is particularly useful when the bad events are determined by sums of random variables. This leads to several improved algorithmic applications in scheduling, graph transversals, packet routing, and so on. For instance, we settle a conjecture of Szabo and Tardos (2006) on graph transversals asymptotically and obtain improved approximation ratios for a packet routing problem of Leighton, Maggs, and Rao (1994).
TL;DR: This paper considers testers over continuous-time Boolean signals that use clock variables to enforce duration constraints, as in timed automata, and rewrite the MITL formula into a “simple” formula using a limited set of temporal modalities.
Abstract: We show how to construct temporal testers for the logic MITL, a prominent linear-time logic for real-time systems. A temporal tester is a transducer that inputs a signal holding the Boolean value of atomic propositions and outputs the truth value of a formula along time. Here we consider testers over continuous-time Boolean signals that use clock variables to enforce duration constraints, as in timed automata. We first rewrite the MITL formula into a “simple” formula using a limited set of temporal modalities. We then build testers for these specific modalities and show how to compose testers for simple formulae into complex ones. Temporal testers can be turned into acceptors, yielding a compositional translation from MITL to timed automata. This construction is much simpler than previously known and remains asymptotically optimal. It supports both past and future operators and can easily be extended.
TL;DR: An algorithm for a single agent with constant memory that explores any n-vertex graph using O(log log n) pebbles, even when n is not known a priori, and can be realized with additional constant-memory agents rather than pebbling.
Abstract: We study the problem of deterministically exploring an undirected and initially unknown graph with n vertices either by a single agent equipped with a set of pebbles or by a set of collaborating agents. The vertices of the graph are unlabeled and cannot be distinguished by the agents, but the edges incident to a vertex have locally distinct labels. The graph is explored when all vertices have been visited by at least one agent. In this setting, it is known that for a single agent without pebbles Θ(log n) bits of memory are necessary and sufficient to explore any graph with at most n vertices. We are interested in how the memory requirement decreases as the agent may mark vertices by dropping and retrieving distinguishable pebbles or when multiple agents jointly explore the graph. We give tight results for both questions showing that for a single agent with constant memory Θ(log log n) pebbles are necessary and sufficient for exploration. We further prove that using collaborating agents instead of pebbles does not help as Θ(log log n) agents with constant memory each are necessary and sufficient for exploration. For the upper bounds, we devise an algorithm for a single agent with constant memory that explores any n-vertex graph using O(log log n) pebbles, even when n is not known a priori. The algorithm terminates after polynomial time and returns to the starting vertex. We further show that the algorithm can be realized with additional constant-memory agents rather than pebbles, implying that O(log log n) agents with constant memory can explore any n-vertex graph. For the lower bound, we show that the number of agents needed for exploring any graph with at most n vertices is already Ω(log log n) when we allow each agent to have at most O((log n)1-e) bits of memory for any e > 0. Our argument also implies that a single agent with sublogarithmic memory needs Θ(log log n) pebbles to explore any n-vertex graph.
TL;DR: In this article, a (1 + e)-approximation algorithm with quasi-polynomial running time for computing a maximum weight independent set of polygons from a given set of polygonal polygons in the plane is presented.
Abstract: We present a (1+e)-approximation algorithm with quasi-polynomial running time for computing a maximum weight independent set of polygons from a given set of polygons in the plane. Contrasting this, the best-known polynomial time algorithm for the problem has an approximation ratio of ne. Surprisingly, we can extend the algorithm to the problem of computing the maximum cardinality subset of the given set of polygons whose intersection graph fulfills some sparsity condition. For example, we show that one can approximate the maximum subset of polygons such that the intersection graph of the subset is planar or does not contain a cycle of length 4 (i.e., K2,2). Our algorithm relies on a recursive partitioning scheme, whose backbone is the existence of balanced cuts with small complexity that intersect polygons from the optimal solution of a small total weight. For the case of large axis-parallel rectangles, we provide a polynomial time (1 + e)-approximation for the maximum weight independent set. Specifically, we consider the problem where each rectangle has one edge whose length is at least a constant fraction of the length of the corresponding edge of the bounding box of all the input elements. This is now the most general case for which a PTAS is known, and it requires a new and involved partitioning scheme, which should be of independent interest.
TL;DR: In this article, the authors investigated quantifier alternation hierarchies in first-order logic on finite words and proved that one can decide membership of a regular language in the levels BΣ2 (finite Boolean combinations of formulas having only one alternation) and Σ3 (formulas having only two alternations and beginning with an existential block).
Abstract: We investigate quantifier alternation hierarchies in first-order logic on finite words. Levels in these hierarchies are defined by counting the number of quantifier alternations in formulas. We prove that one can decide membership of a regular language in the levels BΣ2 (finite Boolean combinations of formulas having only one alternation) and Σ3 (formulas having only two alternations and beginning with an existential block). Our proofs work by considering a deeper problem, called separation, which, once solved for lower levels, allows us to solve membership for higher levels.
TL;DR: In this paper, it was shown that the greedy algorithm that always takes the shortest augmenting path from the newly inserted vertex (denoted the SAP protocol) uses at most amortized O(log 2n) replacements per insertion, where n is the total number of vertices inserted.
Abstract: In the online bipartite matching problem with replacements, all the vertices on one side of the bipartition are given, and the vertices on the other side arrive one-by-one with all their incident edges. The goal is to maintain a maximum matching while minimizing the number of changes (replacements) to the matching. We show that the greedy algorithm that always takes the shortest augmenting path from the newly inserted vertex (denoted the SAP protocol) uses at most amortized O(log 2n) replacements per insertion, where n is the total number of vertices inserted. This is the first analysis to achieve a polylogarithmic number of replacements for any replacement strategy, almost matching the Ω (log n) lower bound. The previous best strategy known achieved amortized O(√ n) replacements [Bosek, Leniowski, Sankowski, Zych, FOCS 2014]. For the SAP protocol in particular, nothing better than the trivial O(n) bound was known except in special cases. Our analysis immediately implies the same upper bound of O(log 2n) reassignments for the capacitated assignment problem, where each vertex on the static side of the bipartition is initialized with the capacity to serve a number of vertices.We also analyze the problem of minimizing the maximum server load. We show that if the final graph has maximum server load L, then the SAP protocol makes amortized O(min l L log2n , √ nlog nr) reassignments. We also show that this is close to tight, because Ω (min l L, √ nr) reassignments can be necessary.
TL;DR: This work studies learning problems involving arbitrary classes of functions F, underlying measures , and targets Y, and proper learning procedures, i.e., procedures that are only allowed to select func...
Abstract: We study learning problems involving arbitrary classes of functions F, underlying measures μ, and targets Y. Because proper learning procedures, i.e., procedures that are only allowed to select functions in F, tend to perform poorly unless the problem satisfies some additional structural property (e.g., that F is convex), we consider unrestricted learning procedures that are free to choose functions outside the given class. We present a new unrestricted procedure whose sample complexity is almost the best that one can hope for and holds for (almost) any problem, including heavy-tailed situations. Moreover, the sample complexity coincides with what one could expect if F were convex, even when F is not. And if F is convex, then the unrestricted procedure turns out to be proper.
TL;DR: It is shown that under the assumption that collision-resistant hash function exists (which follows from the hardness of problems such as factoring, discrete-log, and learning with errors) the white-box Ramsey problem is hard and this is true even if one is looking for a much smaller clique or independent set than the theorem guarantees.
Abstract: Ramsey theory assures us that in any graph there is a clique or independent set of a certain size, roughly logarithmic in the graph size. But how difficult is it to find the clique or independent set? If the graph is given explicitly, then it is possible to do so while examining a linear number of edges. If the graph is given by a black-box, where to figure out whether a certain edge exists the box should be queried, then a large number of queries must be issued. But what if one is given a program or circuit for computing the existence of an edge? This problem was raised by Buss and Goldberg and Papadimitriou in the context of TFNP, search problems with a guaranteed solution.We examine the relationship between black-box complexity and white-box complexity for search problems with guaranteed solution such as the above Ramsey problem. We show that under the assumption that collision-resistant hash function exists (which follows from the hardness of problems such as factoring, discrete-log, and learning with errors) the white-box Ramsey problem is hard and this is true even if one is looking for a much smaller clique or independent set than the theorem guarantees. This is also true for the colorful Ramsey problem where one is looking, say, for a monochromatic triangle.In general, one cannot hope to translate all black-box hardness for TFNP into white-box hardness: we show this by adapting results concerning the random oracle methodology and the impossibility of instantiating it.Another model we consider is that of succinct black-box, where the complexity of an algorithm is measured as a function of the description size of the object in the box (and no limitation on the computation time). In this case, we show that for all TFNP problems there is an efficient algorithm with complexity proportional to the description size of the object in the box times the solution size. However, for promise problems this is not the case.Finally, we consider the complexity of graph property testing in the white-box model. We show a property that is hard to test even when one is given the program for computing the graph (under the appropriate assumptions such as hardness of Decisional Diffie-Hellman). The hard property is whether the graph is a two-source extractor.
TL;DR: The key component of the proof is a quantitative solution to strongly connected mean-payoff bidding games in which the connection with random-turn games is extended to these games, and the higher bidder pays his bid to the other player and moves the token.
Abstract: Two-player games on graphs are widely studied in formal methods, as they model the interaction between a system and its environment. The game is played by moving a token throughout a graph to produce an infinite path. There are several common modes to determine how the players move the token through the graph; e.g., in turn-based games the players alternate turns in moving the token. We study the bidding mode of moving the token, which, to the best of our knowledge, has never been studied in infinite-duration games. The following bidding rule was previously defined and called Richman bidding. Both players have separate budgets, which sum up to 1. In each turn, a bidding takes place: Both players submit bids simultaneously, where a bid is legal if it does not exceed the available budget, and the higher bidder pays his bid to the other player and moves the token. The central question studied in bidding games is a necessary and sufficient initial budget for winning the game: a threshold budget in a vertex is a value t ∈ l0, 1r such that if Player 1’s budget exceeds t, he can win the game; and if Player 2’s budget exceeds 1 − t, he can win the game. Threshold budgets were previously shown to exist in every vertex of a reachability game, which have an interesting connection with random-turn games—a sub-class of simple stochastic games in which the player who moves is chosen randomly. We show the existence of threshold budgets for a qualitative class of infinite-duration games, namely parity games, and a quantitative class, namely mean-payoff games. The key component of the proof is a quantitative solution to strongly connected mean-payoff bidding games in which we extend the connection with random-turn games to these games, and construct explicit optimal strategies for both players.
TL;DR: This article investigates the “price of non-coordinating,” in terms of search performance, and shows that this price is actually quite small, and an optimal non- coordination algorithm for Bayesian search is described.
Abstract: Coordinating the actions of agents (e.g., volunteers analyzing radio signals in SETIchome) yields efficient search algorithms. However, such an efficiency is often at the cost of implementing complex coordination mechanisms which may be expensive in terms of communication and/or computation overheads. Instead, non-coordinating algorithms, in which each agent operates independently from the others, are typically very simple, and easy to implement. They are also inherently robust to slight misbehaviors, or even crashes of agents. In this article, we investigate the “price of non-coordinating,” in terms of search performance, and we show that this price is actually quite small. Specifically, we consider a parallel version of a classical Bayesian search problem, where set of k≥1 searchers are looking for a treasure placed in one of the boxes indexed by positive integers, according to some distribution p. Each searcher can open a random box at each step, and the objective is to find the treasure in a minimum number of steps. We show that there is a very simple non-coordinating algorithm which has expected running time at most 4(1−1/k+1)2 OPT+10, where OPT is the expected running time of the best fully coordinated algorithm. Our algorithm does not even use the precise description of the distribution p, but only the relative likelihood of the boxes. We prove that, under this restriction, our algorithm has the best possible competitive ratio with respect to OPT. For the case where a complete description of the distribution p is given to the search algorithm, we describe an optimal non-coordinating algorithm for Bayesian search. This latter algorithm can be twice as fast as our former algorithm in practical scenarios such as uniform distributions. All these results provide a complete characterization of non-coordinating Bayesian search. The take-away message is that, for their simplicity and robustness, non-coordinating algorithms are viable alternatives to complex coordinating mechanisms subject to significant overheads. Most of these results apply as well to linear search, in which the indices of the boxes reflect their relative importance, and where important boxes must be visited first.
TL;DR: The communication complexity of secret key agreement protocols that produce a secret key of maximal length for protocols with public randomness is established and it is shown that if the communication complexity drops below the established threshold, then only very short secret keys can be obtained.
Abstract: We show that the mutual information, in the sense of Kolmogorov complexity, of any pair of strings x and y is equal, up to logarithmic precision, to the length of the longest shared secret key that two parties—one having x and the complexity profile of the pair and the other one having y and the complexity profile of the pair—can establish via a probabilistic protocol with interaction on a public channel. For e > 2, the longest shared secret that can be established from a tuple of strings (x1, …, xe) by e parties—each one having one component of the tuple and the complexity profile of the tuple—is equal, up to logarithmic precision, to the complexity of the tuple minus the minimum communication necessary for distributing the tuple to all parties. We establish the communication complexity of secret key agreement protocols that produce a secret key of maximal length for protocols with public randomness. We also show that if the communication complexity drops below the established threshold, then only very short secret keys can be obtained.
TL;DR: In this paper, it was shown that conditional distributions are computable when measurements are corrupted by independent computable noise with a sufficiently smooth bounded density, which is a fundamental notion in probability theory and a cornerstone of Bayesian statistics.
Abstract: As inductive inference and machine-learning methods in computer science see continued success, researchers are aiming to describe ever more complex probabilistic models and inference algorithms. It is natural to ask whether there is a universal computational procedure for probabilistic inference. We investigate the computability of conditional probability, a fundamental notion in probability theory, and a cornerstone of Bayesian statistics. We show that there are computable joint distributions with noncomputable conditional distributions, ruling out the prospect of general inference algorithms, even inefficient ones. Specifically, we construct a pair of computable random variables in the unit interval such that the conditional distribution of the first variable given the second encodes the halting problem. Nevertheless, probabilistic inference is possible in many common modeling settings, and we prove several results giving broadly applicable conditions under which conditional distributions are computable. In particular, conditional distributions become computable when measurements are corrupted by independent computable noise with a sufficiently smooth bounded density.
TL;DR: NO(1) size regular resolution proofs for arbitrary degree 2 identities on array, diagonal, and Booth multipliers and nO(log n) size proofs for these identities on Wallace tree multipliers are given.
Abstract: We eliminate a key roadblock to efficient verification of nonlinear integer arithmetic using CDCL SAT solvers, by showing how to construct short resolution proofs for many properties of the most widely used multiplier circuits. Such short proofs were conjectured not to exist. More precisely, we give nO(1) size regular resolution proofs for arbitrary degree 2 identities on array, diagonal, and Booth multipliers and nO(log n) size proofs for these identities on Wallace tree multipliers.
TL;DR: The technique is generalized to trees, and the corresponding algorithm is generalized from word equations to context unification, which shows that context unification is in PSPACE (in EXPTIME , when tree regular constraints are also allowed).
Abstract: In first-order term unification, variables represent well-formed terms over a given signature, and we are to solve equations built using function symbols from the signature and such variables; this problem is well-known to be decidable (in linear time). In second-order term unification, the variables take arguments (i.e., other terms) and a substitution uses those arguments an arbitrary number of times; for instance, an equation f(X(c),X(c)) = X(f(c,c)) has a solution X = b, where b is a special symbol denoting the place in which the argument is substituted. Under this substitution, both sides evaluate to f(c,c). There are other solutions, for instance X = f(b,b), which evaluates both sides tof(f(c,c),f(c,c)); in general, a solution that evaluates both sides to full binary tree of arbitrary height is easy to construct. Second-order unification is in general undecidable. Context unification is a natural problem in between first- and second-order unification—we deal with equations over terms, the variables take arguments, but we restrict the set of solutions: The argument is used exactly once. Formally, contexts are terms with exactly one occurrence of the special symbol b and in context unification, we are given an equation over terms with variables representing contexts and ask about the satisfiability of this equation. For instance, when the aforementioned equation f(X(c),X(c)) = X(f(c,c)) is treated as a context unification problem, then it has exactly one solution: X = b. Other substitutions that are solutions of it as an instance of the second-unification problem, say X = f(b, b), are not valid, as b is used more than once. Context unification also generalizes satisfiability of word equations, which is decidable (in PSPACE). The decidability status of context unification remained unknown for almost two decades. In this article, we show that context unification is in PSPACE (in EXPTIME , when tree regular constraints are also allowed). Those results are obtained by extending the recently developed recompression technique, which was previously defined for strings and used to obtain a new PSPACE algorithm for satisfiability of word equations. In this article, the technique is generalized to trees, and the corresponding algorithm is generalized from word equations to context unification. The idea of recompression is to apply simple compression rules (replacing pairs of neighboring function symbols) to the solution of the context equation; to this end, we appropriately modify the equation (without the knowledge of the actual solution) so compressing the solution can be simulated by compressing parts of the equation. It is shown that if the compression operations are appropriately chosen, then the size of the instance is polynomial during the whole algorithm, thus giving a PSPACE-upper bound.
TL;DR: This work investigates the compatibility of several variants of BI with Constructive Type Theory (CTT), a dependent type theory in the spirit of Martin-Löf's extensional theory and provides novel insights regarding BI, such as the non-truncated version of BI on monotone bars being intuitionistically false.
Abstract: Powerful yet effective induction principles play an important role in computing, being a paramount component of programming languages, automated reasoning, and program verification systems. The Bar Induction (BI) principle is a fundamental concept of intuitionism, which is equivalent to the standard principle of transfinite induction. In this work, we investigate the compatibility of several variants of BI with Constructive Type Theory (CTT), a dependent type theory in the spirit of Martin-Lof’s extensional theory. We first show that CTT is compatible with a BI principle for sequences of numbers. Then, we establish the compatibility of CTT with a more general BI principle for sequences of name-free closed terms. The formalization of the latter principle within the theory involved enriching CTT’s term syntax with a limit constructor and showing that consistency is preserved. Furthermore, we provide novel insights regarding BI, such as the non-truncated version of BI on monotone bars being intuitionistically false. These enhancements are carried out formally using the Nuprl proof assistant that implements CTT and the formalization of CTT within the Coq proof assistant presented in previous works.
TL;DR: For every d ≥ 2 and k ≥ 0, deciding if a pure, d-dimensional, simplicial complex is k-decomposable is NP-hard.
Abstract: We prove that for every d ≥ 2, deciding if a pure, d-dimensional, simplicial complex is shellable is NP-hard, hence NP-complete. This resolves a question raised, e.g., by Danaraj and Klee in 1978. Our reduction also yields that for every d ≥ 2 and k ≥ 0, deciding if a pure, d-dimensional, simplicial complex is k-decomposable is NP-hard. For d ≥ 3, both problems remain NP-hard when restricted to contractible pure d-dimensional complexes. Another simple corollary of our result is that it is NP-hard to decide whether a given poset is CL-shellable.
TL;DR: A complexity theory for approximate real computations, intended to model actual numerical computations that are usually performed in floating point arithmetic, and it is proved that P is not NP in this theory if and only if P isNot NP in the BSS theory over the reals.
Abstract: We develop a complexity theory for approximate real computations. We first produce a theory for exact computations but with condition numbers. The input size depends on a condition number, which is not assumed known by the machine. The theory admits deterministic and nondeterministic polynomial time recognizable problems. We prove that P is not NP in this theory if and only if P is not NP in the BSS theory over the reals. Then we develop a theory with weak and strong approximate computations. This theory is intended to model actual numerical computations that are usually performed in floating point arithmetic. It admits classes P and NP and also an NP-complete problem. We relate the P vs. NP question in this new theory to the classical P vs. NP problem.
TL;DR: In this article, the authors proposed a combinatorial relaxation approach to solve a linear algebraic problem by iteratively relaxing it into an efficiently solvable combinative optimization problem, which can be applied to nonlinear DAEs by regarding nonlinear terms as parameters.
Abstract: Differential-algebraic equations (DAEs) are widely used for the modeling of dynamical systems. The difficulty in numerically solving a DAE is measured by its differentiation index. For highly accurate simulation of dynamical systems, it is important to convert high-index DAEs into low-index DAEs. Most of the existing simulation software packages for dynamical systems are equipped with an index-reduction algorithm given by Mattsson and Soderlind. Unfortunately, this algorithm fails if there are numerical cancellations.These numerical cancellations are often caused by accurate constants in structural equations. Distinguishing those accurate constants from generic parameters that represent physical quantities, Murota and Iri introduced the notion of a mixed matrix as a mathematical tool for faithful model description in a structural approach to systems analysis. For DAEs described with the use of mixed matrices, efficient algorithms to compute the index have been developed by exploiting matroid theory.This article presents an index-reduction algorithm for linear DAEs whose coefficient matrices are mixed matrices, i.e., linear DAEs containing physical quantities as parameters. Our algorithm detects numerical cancellations between accurate constants and transforms a DAE into an equivalent DAE to which Mattsson–Soderlind’s index-reduction algorithm is applicable. Our algorithm is based on the combinatorial relaxation approach, which is a framework to solve a linear algebraic problem by iteratively relaxing it into an efficiently solvable combinatorial optimization problem. The algorithm does not rely on symbolic manipulations but on fast combinatorial algorithms on graphs and matroids. Our algorithm is proved to work for any linear DAEs whose coefficient matrices are mixed matrices. Furthermore, we provide an improved algorithm under an assumption based on dimensional analysis of dynamical systems. Through numerical experiments, it is confirmed that our algorithms run sufficiently fast for large-scale DAEs and output DAEs such that physical meanings of coefficients are easy to interpret. Our algorithms can also be applied to nonlinear DAEs by regarding nonlinear terms as parameters.