Incrementally verifiable computation (IVC) is a computationally sound proof system that allows a prover to certify the correctness of a long or ongoing computation in an incremental manner, by repeatedly updating a proof certifying the computation so far. Updating the proof does not require access to the entire trace of the computation, which makes the IVC-prover memory efficient. Recently, such schemes were constructed for deterministic Turing machines from standard cryptographic assumptions (Paneth and Pass, FOCS 2022, and Devadas et al., FOCS 2022). In this work we generalize and extend IVC to support incremental certification and verifiability of a large set of computation models, focusing on distributed and online computation. This allows distributed algorithms to efficiently certify their own execution using low memory and communication overhead. We construct IVC for a variety of computation models by proving one generic lifting theorem from a classical (non-incremental) delegation scheme (also known as SNARG) into full-fledged IVC, while preserving the delegation scheme's succinctness properties (up to an additive factor which is polynomial in the security parameter and independent of the size of the computation). Using this lifting theorem, we obtain IVC for the following computation models: RAM and exclusive-read exclusive-write (EREW) PRAM algorithms, using existing delegation schemes for these models. Streaming algorithms, using the natural memory-efficiency properties of the model. Massively parallel computation (MPC). Notably, in this model, memory efficiency is a critical bottleneck: the machines participating in an MPC algorithm usually cannot store the entire trace of their computation. Thus, certifying MPC algorithms naturally benefits from IVC. Moreover, since prior to our work, no delegation scheme for this model was known, we also construct a delegation scheme for one-round massively parallel computations, and then apply our lifting theorem to it. Distributed graph algorithms, using existing distributed delegation schemes (also known as locally verifiable distributed SNARGs). Here, in order to use our lifting theorem we have to first make some observations about the verification procedure of these existing schemes. At the heart of this work is a new abstraction, updatable batch arguments for NP (UpBARGs), which we define and construct. Standard BARGs allow one to prove a batch of k NP-statements using a proof whose length barely grows with k; however, the statements and their witnesses must all be known in advance. In contrast, UpBARGs support adding statements and witnesses on the fly, making them a flexible tool for constructing IVC across different computational models. 2012 ACM Subject Classification Theory of computation -> Cryptographic protocols
The Range Avoidance (Avoid) problem rho-Avoid[n, m(n)] asks that, given a circuit in a class rho with input length n and output length m(n) > n, find a string not in the range of the circuit. This problem has been a central piece in several recent frameworks for proving circuit lower bounds and constructing explicit combinatorial objects. Previous work by Korten (FOCS' 21) and by Ren, Santhanam, and Wang (FOCS' 22) showed that algorithms for Avoid are closely related to circuit lower bounds. In particular, Korten's work reinterpreted an earlier result from bounded arithmetic, originally proved by Jerabek (Ann. Pure Appl. Log. 2004), as an equivalence in computational complexity between the existence of FPNP algorithms for the general Avoid problem and 2(Omega(n)) lower bounds against general Boolean circuits for the class E-NP. In this work, we significantly complement these works by generalizing the equivalence result to restricted circuit classes and obtain the following: For any constant depth unbounded fan-in circuit class rho superset of AC(0), there is an FPNP algorithm for rho-Avoid[n, n(1+epsilon)] (for any constant epsilon > 0) if and only if E-NP cannot be computed by rho circuits of size 2(o(n)). This addresses an open problem by Korten (Bulletin of EATCS' 25). If E-NP cannot be computed by o(2(n) /n) size formulas, then there is an FPNP algorithm for NC0-Avoid[n, 2n]. Note that by an extension of Ren, Santhanam, and Wang (FOCS' 22), an FPNP algorithm for NC40 -Avoid[n, n + n(delta)] for any constant delta is an element of(0, 1) implies E-NP cannot be computed by o(2(n) /n) size formulas. These results yield the first characterizations of FPNP rho-Avoid algorithms for low-complexity circuit classes such as AC(0). We also consider the average-case analog of Avoid, the Remote Point (Remote-Point) problem, and establish: For some suitable function c(n) and constant gamma > 0, there is an FPNP algorithm for Remote-Point[ n, n(6+gamma), c(O gamma (log n))] if and only if E-NP cannot be (1/2 - c(n))-approximated by circuits of size 2(o(n)). Finally, we also present two improved algorithms for NC0-Avoid: A family of 2(n1-e/k-1+o(1)) time algorithms for NCk0 -Avoid[ n, n(1+epsilon)] for any epsilon > 0, exhibiting the first subexponential-time algorithm for any super-linear stretch. Faster local algorithms for NCk0 -Avoid[n, n+1] running in time O(n2(k-2/k-1 n), improving the naive 2(n) center dot poly(n) bound. 2012 ACM Subject Classification Theory of computation -> Complexity classes; Theory of computation -> Circuit complexity; Theory of computation -> Pseudorandomness and derandomization; Theory of computation -> Expander graphs and randomness extractors
We prove algorithmic versions of the polynomial Freiman-Ruzsa theorem of Gowers, Green, Manners, and Tao (Annals of Mathematics, 2025) in additive combinatorics. In particular, we give classical and quantum polynomial-time algorithms that, for A subset of F (n)(2) with doubling constant K, learn an explicit description of a subspace V subset of F (n)(2) of size |V|<=|A| such that A can be covered by K-C translates of V, for a universal constant C > 1. 2012 ACM Subject Classification Theory of computation -> Randomness, geometry and discrete structures
We study the d-dimensional knapsack problem. We are given a set of items, each with a d-dimensional cost vector and a profit, along with a d-dimensional budget vector. The goal is to select a set of items that do not exceed the budget in all dimensions and maximize the total profit. A polynomial-time approximation scheme (PTAS) with running time n theta( d/epsilon) has long been known for this problem, where epsilon is the error parameter and n is the encoding size. Despite decades of active research, the best running time of a PTAS has remained O( n([d/e]-d)). Unfortunately, existing lower bounds only cover the special case with two dimensions d = 2, and do not answer whether there is a n(o)( d/epsilon)-time PTAS for larger values of d. In this work, we show that the running times of the best-known PTAS cannot be improved up to a polylogarithmic factor assuming the Exponential Time Hypothesis (ETH). Our techniques are based on a robust reduction from 2-CSP, which embeds 2-CSP constraints into a desired number of dimensions. Then, using a recent result of [Bafna Karthik and Minzer, STOC'25], we succeed in exhibiting tight trade-off between d and epsilon for all regimes of the parameters assuming d is sufficiently large. Informally, our result also shows that under ETH, for any function f there is no f (d/epsilon) center dot n (O) over tilde ((d/epsilon)_) time (1 - epsilon)-approximation for d-dimensional knapsack, where n is the number of items and (O) over tilde hides polylogarithmic factors in d/epsilon. 2012 ACM Subject Classification Theory of computation -> Approximation algorithms analysis; Theory of computation. Problems, reductions and completeness; Theory of computation -> Parameterized complexity and exact algorithms
We initiate the study of a new abstraction called incremental decentralized data archival (iDDA). Specifically, imagine that there is an ever-growing, massive database such as a blockchain, a comprehensive human knowledge base like Wikipedia, or the Internet archive. We want to build a decentralized archival system for such datasets to ensure long-term robustness and sustainability. We identify several important properties that an iDDA scheme should satisfy. First, to promote heterogeneity and decentralization, we want to encourage even weak nodes with limited space (e.g., users' home computers) to contribute. The minimum space requirement to contribute should be approximately independent of the data size. Second, if a collection of nodes together receive rewards commensurate with contributing a total of m blocks of space, then we want the following reassurances: 1) if m is at least the database size, we should be able to reconstruct the entire dataset; and 2) these nodes should actually be committing roughly m space in aggregate - specifically, when m is much larger than the data size, these nodes cannot store only one copy of the database, and be able to impersonate arbitrarily many pseudonyms and get unbounded rewards. We propose new definitions that mathematically formalize the aforementioned requirements of an iDDA scheme. We also devise an efficient construction in the random oracle model which satisfies the desired security requirements. Our scheme incurs only (O) over tilde (1) audit cost, as well as (O) over tilde (1) update cost for both the publisher and each node, where (O) over tilde(center dot) hides polylogarithmic factors. Further, the minimum space provisioning required to contribute is as small as polylogarithmic. Our construction exposes several interesting technical challenges. Specifically, we show that a straightforward application of the standard hierarchical data structure fails, since both our security definition and the underlying cryptographic primitives we employ lack the desired compositional guarantees. We devise novel techniques to overcome these compositional issues, resulting in a construction with provable security while still retaining efficiency. Finally, our new definitions also make a conceptual contribution, and lay the theoretical groundwork for the study of iDDA. We raise several interesting open problems along this direction. 2012 ACM Subject Classification Security and privacy -> Mathematical foundations of cryptography
Interactive proofs of proximity (IPPs) are a relaxation of interactive proofs, analogous to property testing, in which soundness is required to hold only for inputs that are.-far from the property being verified, where. > 0 is a proximity parameter. In such proof systems, the verifier has oracle access to the input, and it engages in two types of activities before making its decision: querying the input oracle and communicating with the prover. The main objective is to achieve protocols where both the query and communication complexities are extremely low. In this work, we focus on computationally sound IPPs (cs-IPPs). We study their power in two aspects: Query complexity: We show that, assuming the existence of collision-resistant hashing functions (CRHFs), any public-coin cs-IPP that has query complexity q can be transformed into a cs-IPP that makes only O(1/epsilon.) queries, while increasing the communication complexity by roughly q. If we further assume the existence of a good computational PIR (private information retrieval) scheme, then a similar transformation holds for general (i.e., possibly private-coin) cs-IPPs. Coordination: Aside from the low query complexity, the resulting cs-IPP has only minimal coordination between the verifier's two activities. The general definition of IPPs allows the verifier to fully coordinate its interaction with the prover and its queries to the input oracle. Goldreich, Rothblum, and Skverer (ITCS 2023) introduced two restricted models of IPPs that are minimally coordinated: The pre-coordinated model, where no information flows between the querying and interacting activities, but they may use a common source of randomness, and the isolated model, where the two activities are fully independent, each operating with a separate source of randomness. Our transformation shows that (under the aforementioned computational assumptions) any cs-IPP can be made to be in the pre-coordinated model, while preserving its efficiency. Hence, pre-coordinated cs-IPPs are essentially as powerful as general cs-IPPs. In contrast, we show that cs-IPPs in the isolated model are extremely limited, offering almost no advantage over property testers. Specifically, extending on a result shown by Goldreich et al. for unconditionally sound IPPs in the isolated model, we show that if a property has a cs-IPP in the isolated model that makes q queries and uses c > 0 bits of communication, then it has a tester with query complexity O( c center dot q). 2012 ACM Subject Classification Theory of computation -> Interactive proof systems
The space complexity of deterministic streaming algorithms for approximating the length of the longest increasing subsequence (LIS) in a string of length n has been known to be (theta) over tilde (root n) for almost two decades. In contrast, the space complexity of this problem for randomized streaming algorithms remains one of the few longstanding open problems in one-pass streaming. In fact, no better than Omega(log n) lower bounds are known, and the best upper bounds are no better than their deterministic counterparts. In this paper, we push the limits of our understanding of the streaming space complexity of the approximate LIS length problem by studying it in the white-box adversarial streaming model. This model is an intermediate model between deterministic and randomized streaming algorithms that has recently attracted attention. In the white-box model, the streaming algorithm can draw fresh randomness when processing each incoming element, but an adversary generating the stream observes all previously used randomness and adaptively chooses the subsequent elements of the stream. We prove a tight (up to logarithmic factors) Omega( root n) space lower bound for any white-box streaming algorithm that approximates the length of the LIS of a stream of length n to within a factor better than 1.1. Thus, for this problem, white-box algorithms offer no improvement over deterministic ones. 2012 ACM Subject Classification Theory of computation -> Streaming, sublinear and near linear time algorithms
Longest increasing subsequence (LIS) is a classical textbook problem which is still actively studied in various computational models. In this work, we present a few results for the range longest increasing subsequence problem (Range-LIS) and its variants. The input to Range-LIS is a sequence S of n real numbers and a collection Q of m query ranges and for each query in Q, the goal is to report the LIS of the sequence S restricted to that query. Our two main results are for the following generalizations of the Range-LIS problem: 2D Range Queries: In this variant of the Range-LIS problem, each query is a pair of ranges, one of indices and the other of values, and we provide a randomized algorithm with running time(1) (O) over tilde (mn(1/2) + n(3/2)) + O(k), where k is the cumulative length of the m output subsequences. This improves on the elementary (O) over tilde (mn) runtime algorithm when m = Omega(root n). Previously, the only known result breaking the quadratic barrier was of Tiskin [SODA'10] which could only handle 1D range queries (i.e., each query was a range of indices) and also just outputted the length of the LIS (instead of reporting the subsequence achieving that length). Subsequent to our paper, Gawrychowski, Gorbachev, and Kociumaka in a preprint have extended Tiskin's approach to handle reporting 1D range queries in O(n(log n)(3) + m + k) time. Colored Sequences: In this variant of the Range-LIS problem, each element in S is colored and for each query in Q, the goal is to report a monochromatic LIS contained in the sequence S restricted to that query. For 2D queries, we provide a randomized algorithm for this colored version with running time (O) over tilde (mn(2/3) + n(5/3)) + O(k). Moreover, for 1D queries, we provide an improved algorithm with running time (O) over tilde (mn(1/2) + n(3/2)) + O(k). Thus, we again improve on the elementary (O) over tilde (mn) runtime algorithm. Additionally, we prove that assuming the well-known Combinatorial Boolean Matrix Multiplication Hypothesis, that the runtime for 1D queries is essentially tight for combinatorial algorithms. Our algorithms combine several tools such as dynamic programming (to precompute increasing subsequences with some desirable properties), geometric data structures (to efficiently compute the dynamic programming entries), random sampling (to capture elements which are part of the LIS), classification of query ranges into large LIS and small LIS, and classification of colors into light and heavy. We believe that our techniques will be of interest to tackle other variants of LIS problem and other range-searching problems. 2012 ACM Subject Classification Theory of computation -> Data structures design and analysis; Theory of computation -> Computational geometry
The class ACC(0) consists of Boolean functions that can be computed by constant-depth circuits of polynomial size with AND, NOT and MODm gates, where m is a natural number. At the frontier of our understanding lies a widely believed conjecture asserting that MAJORITY does not belong to ACC(0). A few years ago, Bhrushundi, Hosseini, Lovett and Rao (ITCS 2019) introduced torus polynomial approximations as an approach towards this conjecture. Torus polynomials approximate Boolean functions when the fractional part of their value on Boolean points is close to half the value of the function. They reduced the conjecture that MAJORITY is not an element of ACC(0) to a conjecture concerning the non-existence of low degree torus polynomials that approximate MAJORITY. We reduce the non-existence problem further, to a statement about finding feasible solutions for an infinite family of linear programs. The main advantage of this statement is that it allows for incremental progress, which means finding feasible solutions for successively larger collections of these programs. As an immediate first step, we find feasible solutions for a large class of these linear programs, leaving only a finite set for further consideration. Our method is inspired by the method of dual polynomials, which is used to study the approximate degree of Boolean functions. Using our method, we also propose a way to progress further. We prove several additional key results with the same method, which include: A lower bound on the degree of symmetric torus polynomials that approximate the AND function. As a consequence, we get a separation that symmetric torus polynomials are weaker than their asymmetric counterparts. An error-degree trade-off for symmetric torus polynomials approximating the MAJORITY function, strengthening the corresponding result of Bhrushundi, Hosseini, Lovett and Rao (ITCS 2019). The first lower bounds against torus polynomials approximating AND, showcasing the power of the machinery we develop. This lower bound nearly matches the corresponding upper bound. Hence, we get an almost complete characterization of the torus polynomial approximation degree of AND. Lower bounds against asymmetric torus polynomials approximating MAJORITY, or AND, in the very low error regime. This partially answers a question posed in Bhrushundi, Hosseini, Lovett and Rao (ITCS 2019) about error-reduction for torus polynomials. 2012 ACM Subject Classification Theory of computation -> Circuit complexity
Nondeterministic reductions have yielded powerful results in the theory of computational complexity, yet are effectively useless in a cryptographic context. The reason for this is simple, a nondeterministic polynomial time adversary can trivially break almost any cryptographic primitive by simply guessing the "key." In order to use this powerful nondeterministic tool kit in the cryptographic context, we initiate the study of cryptography against adversaries with limited nondeterminism: polynomial time nondeterministic algorithms that are restricted to just a few bits of nondeterminism. We demonstrate that limited nondeterministic security is sufficient to prove two foundational results that have eluded our grasp for decades: dream hardness amplification, and extracting omega(log n) hardcore bits. 2012 ACM Subject Classification Theory of computation -> Computational complexity and cryptography; Security and privacy -> Cryptography
This work initiates the study of memory-query tradeoffs for graph problems, with a focus on correlation clustering. Correlation clustering asks for a partition of the vertices that minimizes disagreements: non-edges inside clusters plus edges across clusters. Our first result is a tight query lower bound: to output a partition whose cost approximates the optimum up to an additive error of epsilon n(2), any algorithm requires Omega( n/epsilon 2) adjacency-matrix queries. Under memory constraints, we show that even for the seemingly easier task of approximating the optimal clustering cost (without producing a partition), any algorithm in the random query model must make >> n/epsilon(2) adjacencymatrix queries. Finally, we prove the first general graph model query lower bound for correlation clustering, where algorithms are allowed adjacency-matrix, neighbor, and degree queries. The latter two bounds are not yet tight, leaving room for sharper results. 2012 ACM Subject Classification Theory of computation -> Lower bounds and information complexity
In Function Secret Sharing (FSS), a dealer with a given function f : {0, 1}(n) -> G from n bits to a commutative group G such that f is in a function class F shares succinct keys with two properties. Evaluating each key separately on a common input x results in additive shares of f(x) and any subset of the keys does not provide information on f. Two-party FSS schemes which are reducible to One-way Functions (OWF) have applications in cryptography, complexity, and in practical data security systems. We establish a two-way transformation between a two-party FSS scheme for a function class F, which is black-box reducible to an OWF, or even black-box reducible to a family of Pseudo-Random Functions (PRF) and a dynamic data structure that supports range queries on F. A data structure of this type enables dynamically adding functions to a multiset of functions F. F, and answering range queries on the output of F, i.e., returning Sigma(integral)is an element of(F) f(x) for a query x. The data structures are defined in one of several models which abstract RAM. The correspondence together with known lower bounds on the update time and the query time in data structures leads to the first non-trivial lower bounds on FSS schemes which are black-box reducible to PRF. These lower bounds apply to FSS schemes with polynomial key size and include: For Fd box, the class of all functions which assign a constant group element ss. G to any input in a specified d-dimensional box and 0 to all other inputs: if the key sharing function, Gen, runs in time polynomial in n and the evaluation function is Eval then: If d >= 2 and G = Z(2) then Eval's running time is Omega(n(3/2)/log(3)n). If d >= 2 and G is cyclic such that log |G| = (1 + epsilon) n then Eval's running time is Omega((n/log n))(2) If d > 2 is a constant and further, Gen and Eval correspond to operations on data structures in the Oblivious Group Model (this includes all known FSS from OWF techniques), then the product of Eval's time and the key size is Omega( n(d-1)). For F-mono, the class of all monomials ax(b) is an element of F(2)n[X] such that b <= B, assuming n omega((1))<= B <= 2(n/4): if Gen runs in polynomial time, then Eval's running time is Omega( n root logB / log(2)n ) 2012 ACM Subject Classification Theory of computation -> Cell probe models and lower bounds; Theory of computation -> Cryptographic protocols
The sum-of-squares (SoS) complexity of a d-multiquadratic polynomial f (quadratic in each of d blocks of n variables) is the minimum s such that f = Sigma(s)(i=1) g(i)(2) with each g(i) d-multilinear. In the case d = 2, Hrubes, Wigderson and Yehudayoff [13] showed that an n(1+Omega(1)) lower bound on the SoS complexity of explicit biquadratic polynomials implies an exponential lower bound for non-commutative arithmetic circuits. In this paper, we establish an analogous connection between general multiquadratic sum-of-squares and commutative arithmetic formulas. Specifically, we show that an n(d-o(log d)) lower bound on the SoS complexity of explicit d-multiquadratic polynomials, for any d = d(n) with omega(1) <= d(n) <= O(log n/log log n), would separate the algebraic complexity classes VNC1 and VNP. 2012 ACM Subject Classification Theory of computation -> Algebraic complexity theory
Recently, Goos et al. [14] showed that Res Lambda uSA = RevRes in the following sense: if a formula rho has refutations of size at most s and width/degree at most omega in both Res and uSA, then there is a refutation for rho of size at most poly( s center dot 2(omega)) in RevRes. Their proof relies on the TFNP characterization of the aforementioned proof systems. In our work, we give a direct and simplified proof of this result, simultaneously achieving better bounds: we show that if for a formula rho there are refutations of size at most s in both Res and uSA, then there is a refutation of rho of size at most poly(s) in RevRes. This potentially allows us to "lift" size lower bounds from RevRes to Res for the formulas for which there are upper bounds in uSA. This kind of lifting was not possible before because of the exponential blow-up in size from the width. Similarly, we improve the bounds in another intersection theorem from [14] by giving a direct proof of Res Lambda uNS - RevResT. Finally, we generalize those intersection theorems to some proof systems for which we currently do not have a TFNP characterization. For example, we show that Res(circle plus) Lambda u-wRes(circle plus) = RevRes(circle plus), which effectively allows us to reduce the problem of proving Pigeonhole Principle lower bounds in Res(circle plus) to proving Pigeonhole Principle lower bounds in RevRes(circle plus), a potentially weaker proof system. 2012 ACM Subject Classification Theory of computation -> Proof complexity
Non-malleable codes allow a sender to transmit a message to a receiver, while providing a "bestpossible" integrity guarantee to ensure that no attacker - who cannot already decode the message can meaningfully tamper the message in transit. If tampered, the received message should either be invalid or unrelated to the original message. Non-malleable time-lock puzzles (TLPs) are a special case of non-malleable codes for bounded polynomial-depth tampering with very efficient encoding. In this work, we give generic techniques for constructing non-malleable codes and non-malleable TLPs with improved rate, which captures the ratio of a message's length to its encoding length. A key contribution of our work is identifying a security notion for non-malleability, which we term "CCA-hiding", sufficient for our compilers. CCA-hiding is a relaxation of CCA-security for encryption or commitments to the fine-grained setting of codes, and requires that the encoded message remains hidden, even given a decoding oracle for any other codeword. Intriguingly, CCA-hiding does not imply non-malleability in the fine-grained setting, as is the case for encryption and commitments. Using our new techniques, we give the following constructions: Rate-1 CCA-hiding TLPs in the plain model. Rate-1 non-malleable codes for bounded polynomial-depth tampering in the auxiliary-input random oracle model (AI-ROM). Rate-(1/2) non-malleable TLPs in the AI-ROM. 2012 ACM Subject Classification Theory of computation -> Computational complexity and cryptography
We consider the communication complexity of the graph connectivity problem, where the edges of an n-vertex undirected graph G are distributed between two parties Alice and Bob, who are then required to communicate to determine if G is connected. We show that in any randomized protocol with two-rounds of communication, Alice and Bob must exchange Omega(n log n) bits; such a lower bound for one-round protocols was shown by Sun and Woodruff (APPROX/RANDOM 2015). A one-round deterministic protocol, where Alice sends O(n log n) bits and Bob determines the answer, was observed by Hajnal, Maass and Turan (STOC 1988); they also showed a matching lower bound of O(n log n) bits for deterministic protocols with unbounded rounds of communication. For randomized protocols, a reduction from the set disjointness problem due to Babai, Frankl and Simon (FOCS 1986) implies a randomized lower bound of Omega(n) even with unbounded rounds of communication. Whether this lower bound can be improved to Omega(n log n) has been an outstanding open question, whose algorithmic implications were recently emphasized by Apers, Efron, Gawrychowski, Lee, Mukopadhyay and Nanongkai (FOCS 2022). Our lower bound for randomized two-round protocols is based on a reduction from a restricted version of the two-player pointer chasing problem originally studied by Papadimitriou and Sipser (JCSS 1984). Using this reduction, we show an omega(n) lower bounds on graph connectivity for any constant number of rounds by extending deterministic lower bounds shown by Ponzio, Radhakrishnan and Venkatesh (JCSS 2001) to the randomized setting. 2012 ACM Subject Classification Theory of computation -> Communication complexity
We present a simple greedy procedure to compute an (alpha, beta)-spanner for a graph G. We then show that this procedure is useful for building fault-tolerant spanners, as well as spanners for weighted graphs. Our first main result is an algorithm that, given a multigraph G, outputs an f edge fault-tolerant (k, k - 1)-spanner H of size O(fn(1+1/k)) which is tight. To our knowledge, this is the first tight result concerning the price of fault tolerance in spanners which are not multiplicative, in any model of faults. Our second main result is a new construction of a spanner for weighted graphs. We show that any weighted graph G has a subgraph H with O(n(1+1/k)) edges such that any path P of hop-length l in G has a replacement path P' in H of weighted length <= w(P) + (2k - 2)w((1/2))(P) where w(P) is the total edge weight of P, and w((1/2)) denotes the sum of the largest [l/2]. edge weights along P. Moreover, we show such approximation is optimal for shortest paths of hop-length 2. To our knowledge, this is the first construction of a "spanner" for weighted graphs that strictly improves upon the stretch of multiplicative (2k - 1)-spanners for all non-adjacent vertex pairs, while maintaining the same size bound. Our technique is based on using clustering and ball-growing, which are methods commonly used in designing spanner algorithms, to analyze simple greedy algorithms. This allows us to combine the flexibility of clustering approaches with the unique properties of the greedy algorithm to get improved bounds. In particular, our methods give a very short proof that the parallel greedy spanner adds O(kn(1 vertical bar 1/k)) edges, improving upon known bounds. 2012 ACM Subject Classification Mathematics of computing -> Graph algorithms
Proving lower bounds on the size of noncommutative arithmetic circuits is an important problem in arithmetic circuit complexity. For explicit n variate polynomials of degree circle minus(n), the best known general bound is Omega( n log n) [7, 1]. Recent work of Chatterjee and Hrubes [4] has provided stronger (Omega(n(2))) bounds for the restricted class of homogeneous circuits. The present paper extends these results to a broader class of circuits by using syntactic degree as a complexity measure. The syntactic degree of a circuit is a well known parameter which measures the extent to which high degree computation is used in the circuit. A homogeneous circuit computing a degree d polynomial can be assumed, without loss of generality, to have syntactic degree exactly equal to d [5]. We generalize this by considering circuits that are not necessarily homogeneous but have low syntactic degree. Specifically, for an explicit n variate, degree n polynomial f we show that any circuit with syntactic degree Omega(n) computing f must have size Omega(n(1+c)) for some constant c > 0. We also show that any circuit with syntactic degree o( n log n) computing the same f must have size.( n log n). We further analyze the circuit size required to compute f based on the number of distinct syntactic degrees appearing in the circuit. Our analysis yields an.( n log n) size lower bound for all but a narrow parameter regime where an improved bound is not obtained. Finally, we observe that low syntactic degree circuits are more powerful than homogeneous circuits in a fine grained sense: there exists an n variate, degree o(n) polynomial that has a circuit of size O( n log(2) n) and syntactic degree O(n) but any homogeneous circuit computing it requires size O(n(2)). 2012 ACM Subject Classification Theory of computation -> Algebraic complexity theory
In modern applications of geometric algorithms, it is often unrealistic to assume that the input representation fully captures all relevant aspects of the problem, because the input data is often large and dynamic. To address this challenge, we consider the notion of average sensitivity, which is defined as the average earth mover's distance between the output distributions of the algorithm when run on an input and the same input with one point removed, where the average is over removed points and the distance between two outputs is measured using the symmetric difference size. We start by showing that a number of classical problems from computational geometry, in particular the convex hull, Delaunay triangulation, and Voronoi diagram problems, are "simple" from the viewpoint of average sensitivity by proving tight bounds for the average sensitivity of any algorithm for these problems. Then, we continue by constructing an algorithm with low average sensitivity that computes, for any is an element of > 0, a set of (1/3 + is an element of)n guards for the art gallery problem. This is the main technical contribution of this work, which combines algorithms from computational geometry with results from the theory of local computation algorithms (LCAs) and property testing. 2012 ACM Subject Classification Theory of computation -> Computational geometry; Theory of computation -> Streaming, sublinear and near linear time algorithms
We revisit the question of whether worst-case hardness of the time-bounded Kolmogorov complexity problem, MINKpoly - that is, determining whether a string is "structured" (i.e., K-t(x) < n - 1) or "random" (i.e., K-poly(t) >= n - 1) - suffices to imply the existence of one-way functions (OWF). Liu-Pass (CRYPTO'25) recently showed that worst-case hardness of a boundary version of MINKpoly - where, roughly speaking, the goal is to decide whether given an instance x, (a) x is K-poly-random (i.e., K-poly(t)(x) >= n - 1), or just close to K-poly-random (i.e., K-t(x) < n - 1 but K-poly(t) > n - log n) - characterizes OWF, but with either of the following caveats (1) considering a non-standard notion of probabilistic K-t, as opposed to the standard notion of K-t, or (2) assuming somewhat strong, and non-standard, derandomization assumptions. In this paper, we present an alternative method for establishing their result which enables significantly weakening the caveats. First, we show that boundary hardness of the more standard randomized K-t problem suffices (where randomized K-t(x) is defined just like Kt(x) except that the program generating the string x may be randomized). As a consequence of this result, we can provide a characterization also in terms of just "plain" K-t under the most standard derandomization assumption (used to derandomize just BPP into P) namely E not subset of ioSIZE[2(o(n))]. Our proof relies on language compression schemes of Goldberg-Sipser (STOC'85); using the same technique, we also present the the first worst-case to average-case reduction for the exact MINKpoly problem (under the same standard derandomization assumption), improving upon Hirahara's celebrated results (STOC'18, STOC'21) that only applied to a gap version of the MINKpoly problem, referred to as GapMINK(poly), where the goal is to decide whether K-t(x) <= n-O(log n)) or K-poly(t)(x) >= n - 1 and under the same derandomization assumption. 2012 ACM Subject Classification Theory of computation -> Computational complexity and cryptography
