arXiv subjects

Karteek Sreenivasaiah

Publications and source records attributed to Karteek Sreenivasaiah.

7 recordsLinked to original sources

arXiv2026

New and Improved Concrete Lower Bounds for Orthogonal Vectors

The Orthogonal Vectors Problem (OV$_{n,d}$) takes as input two sets $A,B$ each containing $n$ $d$-dimensional Boolean vectors, and outputs $1$ if and only if there exists $a \in A$ and $b \in B$ such that $a$ and $b$ are orthogonal. The OV conjecture states that for every $\varepsilon > 0$, there exists a constant $c \geq 1$ such that there is no algorithm deciding OV$_{n,d}$ for $d = c \log n$ with running time $O(n^{2-\varepsilon})$. The analogous $k$-OV conjecture hypothesizes a lower bound of $n^{k-ε}$ for the same problem with $k$ sets. We prove these results and variants unconditionally in concrete computational models. We study a natural monotone version of the $k$-OV conjecture and shows that it holds for monotone circuits and constant-depth (not necessarily monotone) circuits when $d = n^{Ω(1)}.$ We show that the monotone version of the OV conjecture holds for monotone circuits. More formally, we show that for every $ε> 0$, there exists $c$ such that any monotone circuit family computing the negation of OV$_{n,d}$ with $d=c\log n$ must have size $Ω(n^{2-ε})$. We also prove stronger Boolean formula and branching program lower bounds for OV$_{n,d}$, strengthening a previous result of Kane and Williams (ITCS 2019). In particular, our Boolean formula lower bound of $Ω(n^2 d)$ is tight up to constant factors.

cs.CC↗

arXiv2025

Sensitivity and Query Complexity under Uncertainty

In this paper, we study the query complexity of Boolean functions in the presence of uncertainty, motivated by parallel computation with an unlimited number of processors where inputs are allowed to be unknown. We allow each query to produce three results: zero, one, or unknown. The output could also be: zero, one, or unknown, with the constraint that we should output ''unknown'' only when we cannot determine the answer from the revealed input bits. Such an extension of a Boolean function is called its hazard-free extension. - We prove an analogue of Huang's celebrated sensitivity theorem [Annals of Mathematics, 2019] in our model of query complexity with uncertainty. - We show that the deterministic query complexity of the hazard-free extension of a Boolean function is at most quadratic in its randomized query complexity and quartic in its quantum query complexity, improving upon the best-known bounds in the Boolean world. - We exhibit an exponential gap between the smallest depth (size) of decision trees computing a Boolean function, and those computing its hazard-free extension. - We present general methods to convert decision trees for Boolean functions to those for their hazard-free counterparts, and show optimality of this construction. We also parameterize this result by the maximum number of unknown values in the input. - We show lower bounds on size complexity of decision trees for hazard-free extensions of Boolean functions in terms of the number of prime implicants and prime implicates of the underlying Boolean function.

cs.CC↗

arXiv2024

Query Complexity with Unknowns

We initiate the study of a new model of query complexity of Boolean functions where, in addition to 0 and 1, the oracle can answer queries with ``unknown''. The query algorithm is expected to output the function value if it can be conclusively determined by the partial information gathered, and it must output ``unknown'' if not. We formalize this model by using Kleene's strong logic of indeterminacy on three variables to capture unknowns. We call this model the `u-query model'. We relate the query complexity of functions in the new u-query model with their analogs in the standard query model. We show an explicit function that is exponentially harder in the u-query model than in the usual query model. We give sufficient conditions for a function to have u-query complexity asymptotically the same as its query complexity. Using u-query analogs of the combinatorial measures of sensitivity, block sensitivity, and certificate complexity, we show that deterministic, randomized, and quantum u-query complexities of all total Boolean functions are polynomially related to each other, just as in the usual query models.

cs.CC↗

arXiv2019

A Fixed-Depth Size-Hierarchy Theorem for AC$^0[\oplus]$ via the Coin Problem

We prove the first Fixed-depth Size-hierarchy Theorem for uniform AC$^0[\oplus]$ circuits; in particular, for fixed $d$, the class $\mathcal{C}_{d,k}$ of uniform AC$^0[\oplus]$ formulas of depth $d$ and size $n^k$ form an infinite hierarchy. For this, we find the first class of explicit functions giving (up to polynomial factor) matching upper and lower bounds for AC$^0[\oplus]$ formulas, derived from the $δ$-Coin Problem, the computational problem of distinguishing between coins that are heads with probability $(1+δ)/2$ or $(1-δ)/2,$ where $δ$ is a parameter going to $0$. We study this problem's complexity and make progress on both upper bounds and lower bounds. Upper bounds. We find explicit monotone AC$^0$ formulas solving the $δ$-coin problem, having depth $d$, size $\exp(O(d(1/δ)^{1/(d-1)}))$, and sample complexity poly$(1/δ)$, for constant $d\ge2$. This matches previous upper bounds of O'Donnell and Wimmer (ICALP 2007) and Amano (ICALP 2009) in terms of size and improves the sample complexity. Lower bounds. The upper bounds are nearly tight even for the stronger model of AC$^0[\oplus]$ formulas (which allow NOT and Parity gates): any AC$^0[\oplus]$ formula solving the $δ$-coin problem must have size $\exp(Ω(d(1/δ)^{1/(d-1)})).$ This strengthens a result of Cohen, Ganor and Raz (APPROX-RANDOM 2014), who prove a similar result for AC$^0$, and a result of Shaltiel and Viola (SICOMP 2010), who give a superpolynomially weaker (still exponential) lower bound. The upper bound is a derandomization involving a use of Janson's inequality (as far as we know, the first such use of the inequality) and classical combinatorial designs. For the lower bound, we prove an optimal (up to constant factor) degree lower bound for multivariate polynomials over $\mathbb{F}_2$ solving the $δ$-coin problem, which may be of independent interest.

cs.CC↗

arXiv2018

Graph Pattern Polynomials

We study the time complexity of induced subgraph isomorphism problems where the pattern graph is fixed. The earliest known example of an improvement over trivial algorithms is by Itai and Rodeh (1978) who sped up triangle detection in graphs using fast matrix multiplication. This algorithm was generalized by Nešetřil and Poljak (1985) to speed up detection of k-cliques. Improved algorithms are known for certain small-sized patterns. For example, a linear-time algorithm is known for detecting length-4 paths. In this paper, we give the first pattern detection algorithm that improves upon Nešetřil and Poljak's algorithm for arbitrarily large pattern graphs (not cliques). The algorithm is obtained by reducing the induced subgraph isomorphism problem to the problem of detecting multilinear terms in constant-degree polynomials. We show that the same technique can be used to reduce the induced subgraph isomorphism problem of many pattern graphs to constructing arithmetic circuits computing homomorphism polynomials of these pattern graphs. Using this, we obtain faster combinatorial algorithms (algorithms that do not use fast matrix multiplication) for k-paths and k-cycles. We also obtain faster algorithms for 5-paths and 5-cycles that match the runtime for triangle detection. We show that these algorithms are expressible using polynomial families that we call graph pattern polynomial families. We then define a notion of reduction among these polynomials that allows us to compare the complexity of various pattern detection problems within this framework. For example, we show that the induced subgraph isomorphism polynomial for any pattern that contains a k-clique is harder than the induced subgraph isomorphism polynomial for k-clique. An analogue of this theorem is not known with respect to general algorithmic hardness.

cs.CC↗

arXiv2018

On the complexity of hazard-free circuits

The problem of constructing hazard-free Boolean circuits dates back to the 1940s and is an important problem in circuit design. Our main lower-bound result unconditionally shows the existence of functions whose circuit complexity is polynomially bounded while every hazard-free implementation is provably of exponential size. Previous lower bounds on the hazard-free complexity were only valid for depth 2 circuits. The same proof method yields that every subcubic implementation of Boolean matrix multiplication must have hazards. These results follow from a crucial structural insight: Hazard-free complexity is a natural generalization of monotone complexity to all (not necessarily monotone) Boolean functions. Thus, we can apply known monotone complexity lower bounds to find lower bounds on the hazard-free complexity. We also lift these methods from the monotone setting to prove exponential hazard-free complexity lower bounds for non-monotone functions. As our main upper-bound result we show how to efficiently convert a Boolean circuit into a bounded-bit hazard-free circuit with only a polynomially large blow-up in the number of gates. Previously, the best known method yielded exponentially large circuits in the worst case, so our algorithm gives an exponential improvement. As a side result we establish the NP-completeness of several hazard detection problems.

cs.CC↗

arXiv2013

Small Depth Proof Systems

A proof system for a language L is a function f such that Range(f) is exactly L. In this paper, we look at proofsystems from a circuit complexity point of view and study proof systems that are computationally very restricted. The restriction we study is: they can be computed by bounded fanin circuits of constant depth (NC^0), or of O(log log n) depth but with O(1) alternations (polylog AC^0). Each output bit depends on very few input bits; thus such proof systems correspond to a kind of local error-correction on a theorem-proof pair. We identify exactly how much power we need for proof systems to capture all regular languages. We show that all regular language have polylog AC^0 proof systems, and from a previous result (Beyersdorff et al, MFCS 2011, where NC^0 proof systems were first introduced), this is tight. Our technique also shows that MAJ has polylog AC^0 proof system. We explore the question of whether TAUT has NC^0 proof systems. Addressing this question about 2TAUT, and since 2TAUT is closely related to reachability in graphs, we ask the same question about Reachability. We show that both Undirected Reachability and Directed UnReachability have NC^0 proof systems, but Directed Reachability is still open. In the context of how much power is needed for proof systems for languages in NP, we observe that proof systems for a good fraction of languages in NP do not need the full power of AC^0; they have SAC^0 or coSAC^0 proof systems.

cs.CC↗