We prove near-optimal tradeoffs for quantifier depth (also called quantifier rank) versus number of variables in first-order logic by exhibiting pairs of n -element structures that can be distinguished by a k -variable first-order sentence but where every such sentence requires quantifier depth at least  n Ω ( k /log k ) . Our tradeoffs also apply to first-order counting logic and, by the known connection to the k -dimensional Weisfeiler–Leman algorithm, imply near-optimal lower bounds on the number of refinement iterations. A key component in our proof is the hardness condensation technique introduced by Razborov in the context of proof complexity. We apply this method to reduce the domain size of relational structures while maintaining the minimal quantifier depth needed to distinguish them in finite variable logics.

A polynomial program is one in which all assignments are given by polynomial expressions and in which all branching is nondeterministic (as opposed to conditional). Given such a program, an algebraic invariant is one that is defined by polynomial equations over the program variables at each program location. Müller-Olm and Seidl have posed the question of whether one can compute the strongest algebraic invariant of a given polynomial program. In this article, we show that, while strongest algebraic invariants are not computable in general, they can be computed in the special case of affine programs, that is, programs with exclusively linear assignments. For the latter result, our main tool is an algebraic result of independent interest: Given a finite set of rational square matrices of the same dimension, we show how to compute the Zariski closure of the semigroup that they generate.

A collection of sets displays a proximity gap with respect to some property if for every set in the collection, either (i) all members are δ-close to the property in relative Hamming distance or (ii) only a tiny fraction of members are δ-close to the property. In particular, no set in the collection has roughly half of its members δ-close to the property and the others δ-far from it. We show that the collection of affine spaces displays a proximity gap with respect to Reed–Solomon (RS) codes, even over small fields, of size polynomial in the dimension of the code, and the gap applies to any δ smaller than the Johnson/Guruswami–Sudan list-decoding bound of the RS code. We also show near-optimal gap results, over fields of (at least) linear size in the RS code dimension, for δ smaller than the unique decoding radius. Concretely, if δ is smaller than half the minimal distance of an RS code V ⊂ 𝔽 q n , then every affine space is either entirely δ-close to the code or, alternatively, at most an ( n/q )-fraction of it is δ-close to the code. Finally, we discuss several applications of our proximity gap results to distributed storage, multi-party cryptographic protocols, and concretely efficient proof systems. We prove the proximity gap results by analyzing the execution of classical algebraic decoding algorithms for Reed–Solomon codes (due to Berlekamp–Welch and Guruswami–Sudan) on a formal element of an affine space. This involves working with Reed–Solomon codes whose base field is an (infinite) rational function field. Our proofs are obtained by developing an extension (to function fields) of a strategy of Arora and Sudan for analyzing low-degree tests.

We give a domain-theoretic semantics to a statistical programming language, using the plain old category of dcpos, in contrast to some more sophisticated recent proposals. Remarkably, our monad of minimal valuations is commutative, which allows for program transformations that permute the order of independent random draws, as one would expect. A similar property is not known for Jones and Plotkin’s monad of continuous valuations. Instead of working with true real numbers, we work with exact real arithmetic, providing a bridge towards possible implementations (implementations by themselves are not addressed here). Rather remarkably, we show that restricting ourselves to minimal valuations does not restrict us much: All measures on the real line can be modeled by minimal valuations on the domain I ℝ ⊥ of exact real arithmetic. We give three operational semantics for our language, and we show that they are all adequate with respect to the denotational semantics. We also explore quite a few examples to demonstrate that our semantics computes exactly as one would expect and to debunk the myth that a semantics based on continuous maps would not be expressive enough to encode measures with non-compact support using only measures with compact support, or to encode measures via non-continuous density functions, for instance. Our examples also include some useful, non-trivial cases of distributions on higher-order objects.

We study the topological μ-calculus, based on both Cantor derivative and closure modalities, proving completeness, decidability, and finite model property over general topological spaces, as well as over T 0 and T D spaces. We also investigate the relational μ-calculus, providing general completeness results for all natural fragments of the μ-calculus over many different classes of relational frames. Unlike most other such proofs for μ-calculi, ours is model theoretic, making an innovative use of a known method from modal logic (the ‘final’ submodel of the canonical model), which has the twin advantages of great generality and essential simplicity.

The study of approximate matching in the Massively Parallel Computations (MPC) model has recently seen a burst of breakthroughs. Despite this progress, we still have a limited understanding of maximal matching which is one of the central problems of parallel and distributed computing. All known MPC algorithms for maximal matching either take polylogarithmic time which is considered inefficient, or require a strictly super-linear space of n 1+Ω (1) per machine. In this work, we close this gap by providing a novel analysis of an extremely simple algorithm, which is a variant of an algorithm conjectured to work by Czumaj, Lacki, Madry, Mitrovic, Onak, and Sankowski [ 15 ]. The algorithm edge-samples the graph, randomly partitions the vertices, and finds a random greedy maximal matching within each partition. We show that this algorithm drastically reduces the vertex degrees. This, among other results, leads to an O (log log Δ) round algorithm for maximal matching with O(n) space (or even mildly sublinear in n using standard techniques). As an immediate corollary, we get a 2 approximate minimum vertex cover in essentially the same rounds and space, which is the optimal approximation factor under standard assumptions. We also get an improved O (log log Δ) round algorithm for 1 + ε approximate matching. All these results can also be implemented in the congested clique model in the same number of rounds.

The restoration lemma by Afek et al. [ 3 ] proves that, in an undirected unweighted graph, any replacement shortest path avoiding a failing edge can be expressed as the concatenation of two original shortest paths. However, the lemma is tiebreaking-sensitive : if one selects a particular canonical shortest path for each node pair, it is no longer guaranteed that one can build replacement paths by concatenating two selected shortest paths. They left as an open problem whether a method of shortest path tiebreaking with this desirable property is generally possible. We settle this question affirmatively with the first general construction of restorable tiebreaking schemes . We then show applications to various problems in fault-tolerant network design. These include a faster algorithm for subset replacement paths, more efficient fault-tolerant (exact) distance labeling schemes, fault-tolerant subset distance preservers and + 4 additive spanners with improved sparsity, and fast distributed algorithms that construct these objects. For example, an almost immediate corollary of our restorable tiebreaking scheme is the first nontrivial distributed construction of sparse fault-tolerant distance preservers resilient to three faults.

There has been a long history of studying randomized greedy matching algorithms since the work by Dyer and Frieze (RSA 1991). We follow this trend and consider the problem formulated in the oblivious setting, in which the vertex set of a graph is known to the algorithm, but not the edge set. The algorithm can make queries for the existence of the edge between any pair of vertices but must include the edge into the matching if it exists, i.e., as in the query-commit model by Gamlath et al. (SODA 2019). We revisit the Modified Randomized Greedy (MRG) algorithm by Aronson et al. (RSA 1995) that is proved to achieve a (0.5 + ϵ)-approximation. In each step of the algorithm, an unmatched vertex is chosen uniformly at random and matched to a randomly chosen neighbor (if exists). We study a weaker version of the algorithm named Random Decision Order (RDO) that, in each step, randomly picks an unmatched vertex and matches it to an arbitrary neighbor (if exists). We prove that the RDO algorithm provides a 0.639-approximation for bipartite graphs and 0.531-approximation for general graphs. As a corollary, we substantially improve the approximation ratio of MRG . Furthermore, we generalize the RDO algorithm to the edge-weighted case and prove that it achieves a 0.501 approximation ratio. This result solves the open question by Chan et al. (SICOMP 2018) and Gamlath et al. (SODA 2019) about the existence of an algorithm that beats greedy in edge-weighted general graphs, where the greedy algorithm probes the edges in descending order of edge-weights. We also present a variant of the algorithm that achieves a (1 − 1/ e )-approximation for edge-weighted bipartite graphs, which generalizes the (1 − 1/ e ) approximation ratio of Gamlath et al. (SODA 2019) for the stochastic setting to the case when the realizations of edges are arbitrarily correlated, where in the stochastic setting, there is a known probability associated with each pair of vertices that indicates the probability that an edge exists between the two vertices, when the pair is probed.

We consider the allocation of m balls (jobs) into n bins (servers). In the standard Two-Choice process, at each step t = 1, 2, …, m we first sample two randomly chosen bins, compare their two loads and then place a ball in the least loaded bin. It is well-known that for any m ≥ n , this results in a gap (difference between the maximum and average load) of log  2 log  n + Θ (1) (with high probability). In this work, we consider Two-Choice in different settings with noisy load comparisons. One key setting involves an adaptive adversary whose power is limited by some threshold \(g \in \mathbb {N} \) . In each step, such adversary can determine the result of any load comparison between two bins whose loads differ by at most g , while if the load difference is greater than g , the comparison is correct. For this adversarial setting, we first prove that for any m ≥ n the gap is \(\mathcal {O}(g+\log n) \) with high probability. Then through a refined analysis we prove that if g ≤ log  n , then for any m ≥ n the gap is \(\mathcal {O}(\frac{g}{\log g} \cdot \log \log n) \) . For constant values of g , this generalizes the heavily loaded analysis of [19, 61] for the Two-Choice process, and establishes that asymptotically the same gap bound holds even if load comparisons among “similarly loaded” bins are wrong. Finally, we complement these upper bounds with tight lower bounds, which establish an interesting phase transition on how the parameter g impacts the gap. The analysis also applies to settings with outdated and delayed information. For example, for the setting of [18] where balls are allocated in consecutive batches of size b = n , we present an improved and tight gap bound of \(\Theta \big (\frac{\log n}{\log \log n}\big) \) . This bound also extends for a range of values of b and applies to a relaxed setting where the reported load of a bin can be any load value from the last b steps.

Multipoint evaluation is the computational task of evaluating a polynomial given as a list of coefficients at a given set of inputs. Besides being a natural and fundamental question in computer algebra on its own, fast algorithms for this problem are also closely related to fast algorithms for other natural algebraic questions like polynomial factorization and modular composition. And while nearly linear time algorithms have been known for the univariate instance of multipoint evaluation for close to five decades due to a work of Borodin and Moenck [7], fast algorithms for the multivariate version have been much harder to come by. In a significant improvement to the state of art for this problem, Umans [25] and Kedlaya & Umans [16] gave nearly linear time algorithms for this problem over field of small characteristic and over all finite fields respectively, provided that the number of variables n is at most d o (1) where the degree of the input polynomial in every variable is less than d . They also stated the question of designing fast algorithms for the large variable case (i.e. n ∉ d o (1) ) as an open problem. use in the preparation of the documentation of their work. In this work, we show that there is a deterministic algorithm for multivariate multipoint evaluation over a field \(\mathbb {F}_{q} \) of characteristic p which evaluates an n -variate polynomial of degree less than d in each variable on N inputs in time \[ \left((N + d^n)^{1 + o(1)}\text{poly}(\log q, d, n, p)\right) \,, \] provided that p is at most d o (1) , and q is at most (exp (exp (exp (⋅⋅⋅(exp ( d ))))), where the height of this tower of exponentials is fixed. When the number of variables is large (e.g. n ∉ d o (1) ), this is the first nearly linear time algorithm for this problem over any (large enough) field. Our algorithm is based on elementary algebraic ideas and this algebraic structure naturally leads to the following two independently interesting applications. • We show that there is an algebraic data structure for univariate polynomial evaluation with nearly linear space complexity and sublinear time complexity over finite fields of small characteristic and quasipolynomially bounded size. This provides a counterexample to a conjecture of Miltersen [21] who conjectured that over small finite fields, any algebraic data structure for polynomial evaluation using polynomial space must have linear query complexity. • We also show that over finite fields of small characteristic and quasipolynomially bounded size, Vandermonde matrices are not rigid enough to yield size-depth tradeoffs for linear circuits via the current quantitative bounds in Valiant’s program [26]. More precisely, for every fixed prime p , we show that for every constant ϵ > 0, and large enough n , the rank of any n × n Vandermonde matrix V over the field \(\mathbb {F}_{p^a} \) can be reduced to ( n /exp ( Ω (poly(ϵ)log  0.53 n ))) by changing at most n Θ (ϵ) entries in every row of V , provided a ≤ poly(log  n ). Prior to this work, similar upper bounds on rigidity were known only for special Vandermonde matrices. For instance, the Discrete Fourier Transform matrices and Vandermonde matrices with generators in a geometric progression [9].