arXiv subjects

Balagopal Komarath

Publications and source records attributed to Balagopal Komarath.

15 recordsLinked to original sources

arXiv2026

VP, VNP and Algebraic Branching Programs over Min-Plus Semirings

Arithmetic circuit complexity studies the complexity of computing polynomials using only arithmetic operations such as addition, multiplication, subtraction, and division. Polynomials over rings of integers model counting problems. Similarly, polynomials over semirings such as tropical semirings model optimization problems. Circuits over semirings then model so called pure algorithms, algorithms that only use the operations in the semiring. In this paper, we do a complexity-theoretic study of the power and limitations of circuits (which represent dynamic programs) over semirings: i) We define $\mathsf{VNP}$ over min-plus semirings, which can faithfully represent problems such as computing min-weight perfect matchings and min-weight Hamiltonian cycles where we have efficiently verifiable certificates. Unlike over rings, we complement the values in the certificate for free as complementation is impossible over min-plus semirings. We prove a dichotomy theorem that states that if we only complement logarithmically many values, this class is same as $\mathsf{VP}$ over min-plus semirings. If we complement super-logarithmically many values, then $\mathsf{VNP} \neq \mathsf{VP}$. ii) We consider constant-width ABPs (which are also called incremental dynamic programs that are restricted to use only a constant number of registers) and show that even simple problems like computing the min-weight $2$-edge-matching is impossible with width $2$ (or $2$ registers). However, with width $3$ (or $3$ registers), such programs can compute everything. More generally, we show that constant-depth formulas are efficiently simulated by constant-width ABPs. iii) We show that an exponential hypercube sum (min in the semiring) over even provably weak models such as width-$2$ ABPs and products of linear forms are the same as $\mathsf{VNP}$.

cs.CC↗

arXiv2025

Counting Patterns in Degenerate Graphs in Constant Space

For a fixed pattern graph, we study the algorithmic complexity of counting homomorphisms, subgraph isomorphisms, and induced subgraph isomorphisms into an $n$-vertex, $d$-degenerate host graph. Bressan (Algorithmica, 2021) introduced the notion of DAG treewidth and showed that counting homomorphisms and induced subgraphs can be performed efficiently using dynamic programming that requires polynomial space. In this work, we introduce a new graph parameter, called DAG treedepth, which enables efficient divide-and-conquer algorithms for counting homomorphisms in $d$-degenerate host graphs using only constant space. Bera, Gishboliner, Levanzov, Seshadhri, and Shapira (SODA, 2021) showed that a pattern graph has DAG treewidth one if and only if it contains no induced cycle of length at least six. This induced minor characterization leads to linear-time and linear-space algorithms. Building on this line of work, we derive an induced-minor characterization of graphs with DAG treedepth at most two that uses only constant space. Recently, Paul-Pena and Seshadhri (ICALP, 2025) proved that all pattern graphs on at most nine vertices can be counted in subquadratic time using polynomial space. We show that every pattern graph on at most nine vertices can be counted as an induced subgraph in $O(n^3)$ time using only constant space. Moreover, we show that patterns on at most eleven vertices can be counted in $O(n^2)$ time using polynomial space. Finally, we present a constant-space algorithm for counting induced subgraphs that matches the running time of Bressan algorithm. We further show that, when polynomial space is allowed, homomorphisms, subgraph isomorphisms, and induced subgraph isomorphisms can be counted faster than Bressan algorithm. In addition, we establish several other results related to DAG treewidth and DAG treedepth that may be of independent interest.

cs.DS↗

arXiv2025

Monotone Bounded Depth Formula Complexity of Graph Homomorphism Polynomials

We introduce baggy elimination trees, a novel graph decomposition that generalises the classical elimination trees underlying treedepth, and use them to give a complete characterisation of the monotone bounded-depth formula complexity of graph homomorphism and coloured isomorphism polynomials. Specifically, we prove that the $\Delta$-product depth monotone formula complexity of these polynomials is $\Theta\!\left(n^{\lambda_\Delta(H)}\right)$, where $\lambda_\Delta(H)$ is the minimum cost of a baggy elimination tree for $H$ at BET-depth~$\Delta$. This result closes the last open case in the programme initiated by Komarath, Pandey and Rahul and continued by Bhargav, Chen, Curticapean and Dwivedi: tight size characterisations of monotone circuit complexity (via treewidth / bounded-depth treewidth), monotone ABP complexity (via pathwidth / bounded-depth pathwidth), and monotone formula complexity (via treedepth) were already known; our theorem supplies the missing bounded-depth formula characterisation via the new notion of bounded-depth baggy-elimination-tree cost $\lambda_\Delta$, completing the picture for all three models in algebraic complexity and their fixed depth variants. As applications, for constant-degree polynomial families we derive an almost-optimal separation between monotone circuits and monotone formulas at every fixed product depth: there exists a family computable by $O(N)$-size monotone circuits of product depth $\Delta$ that requires $\Omega(N^{\Delta/2})$-size monotone formulas of the same depth (and this exponent is optimal up to a constant factor). We also prove a strict depth hierarchy: for every $\Delta \geq 1$ and every constant $k \geq 2$, there is a constant-degree family with $O(s(N))$-size monotone formulas of product depth $\Delta$ that requires $\Omega(s(N)^k)$-size monotone formulas of product depth $\Delta - 1$.

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↗

arXiv2025

Hazard-free Decision Trees

Decision trees are one of the most fundamental computational models for computing Boolean functions $f : \{0, 1\}^n \mapsto \{0, 1\}$. It is well-known that the depth and size of decision trees are closely related to time and number of processors respectively for computing functions in the CREW-PRAM model. For a given $f$, a fundamental goal is to minimize the depth and/or the size of the decision tree computing it. In this paper, we extend the decision tree model to the world of hazard-free computation. 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 input bits. This setting naturally gives rise to ternary decision trees computing functions, which we call hazard-free decision trees. We prove various lower and upper bounds on the depth and size of hazard-free decision trees and compare them to their Boolean counterparts. We prove optimal separations and relate hazard-free decision tree parameters to well-known Boolean function parameters. We show that the analogues of sensitivity, block sensitivity, and certificate complexity for hazard-free functions are all polynomially equivalent to each other and to hazard-free decision tree depth. i.e., we prove the sensitivity theorem in the hazard-free model. We then prove that hazard-free sensitivity satisfies an interesting structural property that is known to hold in the Boolean world. Hazard-free functions with small hazard-free sensitivity are completely determined by their values in any Hamming ball of small radius in $\{0, u, 1\}^n$.

cs.CC↗

arXiv2023

Finding and Counting Patterns in Sparse Graphs

We consider algorithms for finding and counting small, fixed graphs in sparse host graphs. In the non-sparse setting, the parameters treedepth and treewidth play a crucial role in fast, constant-space and polynomial-space algorithms respectively. We discover two new parameters that we call matched treedepth and matched treewidth. We show that finding and counting patterns with low matched treedepth and low matched treewidth can be done asymptotically faster than the existing algorithms when the host graphs are sparse for many patterns. As an application to finding and counting fixed-size patterns, we discover $\otilde(m^3)$-time \footnote{$\otilde$ hides factors that are logarithmic in the input size.}, constant-space algorithms for cycles of length at most $11$ and $\otilde(m^2)$-time, polynomial-space algorithms for paths of length at most $10$.

cs.DS↗

arXiv2022

Karchmer-Wigderson Games for Hazard-free Computation

We present a Karchmer-Wigderson game to study the complexity of hazard-free formulas. This new game is both a generalization of the monotone Karchmer-Wigderson game and an analog of the classical Boolean Karchmer-Wigderson game. Therefore, it acts as a bridge between the existing monotone and general games. Using this game, we prove hazard-free formula size and depth lower bounds that are provably stronger than those possible by the standard technique of transferring results from monotone complexity in a black-box fashion. For the multiplexer function we give (1) a hazard-free formula of optimal size and (2) an improved low-depth hazard-free formula of almost optimal size and (3) a hazard-free formula with alternation depth $2$ that has optimal depth. We then use our optimal constructions to obtain an improved universal worst-case hazard-free formula size upper bound. We see our results as a significant step towards establishing hazard-free computation as an independent missing link between Boolean complexity and monotone complexity.

cs.CC↗

arXiv2020

Graph Homomorphism Polynomials: Algorithms and Complexity

We study homomorphism polynomials, which are polynomials that enumerate all homomorphisms from a pattern graph $H$ to $n$-vertex graphs. These polynomials have received a lot of attention recently for their crucial role in several new algorithms for counting and detecting graph patterns, and also for obtaining natural polynomial families which are complete for algebraic complexity classes $\mathsf{VBP}$, $\mathsf{VP}$, and $\mathsf{VNP}$. We discover that, in the monotone setting, the formula complexity, the ABP complexity, and the circuit complexity of such polynomial families are exactly characterized by the treedepth, the pathwidth, and the treewidth of the pattern graph respectively. Furthermore, we establish a single, unified framework, using our characterization, to collect several known results that were obtained independently via different methods. For instance, we attain superpolynomial separations between circuits, ABPs, and formulas in the monotone setting, where the polynomial families separating the classes all correspond to well-studied combinatorial problems. Moreover, our proofs rediscover fine-grained separations between these models for constant-degree polynomials. The characterization additionally yields new space-time efficient algorithms for several pattern detection and counting problems.

cs.CC↗

arXiv2020

On the complexity of detecting hazards

Detecting and eliminating logic hazards in Boolean circuits is a fundamental problem in logic circuit design. We show that there is no $O(3^{(1-ε)n} \text{poly}(s))$ time algorithm, for any $ε> 0$, that detects logic hazards in Boolean circuits of size $s$ on $n$ variables under the assumption that the strong exponential time hypothesis is true. This lower bound holds even when the input circuits are restricted to be formulas of depth four. We also present a polynomial time algorithm for detecting $1$-hazards in DNF (or, $0$-hazards in CNF) formulas. Since $0$-hazards in DNF (or, $1$-hazards in CNF) formulas are easy to eliminate, this algorithm can be used to detect whether a given DNF or CNF formula has a hazard in practice.

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↗

arXiv2017

Comparator Circuits over Finite Bounded Posets

Comparator circuit model was originally introduced by Mayr and Subramanian (1992) (and further studied by Cook, Filmus and Le (2012)) to capture problems which are not known to be P-complete but still not known to admit efficient parallel algorithms. The class CC is the complexity class of problems many-one logspace reducible to the Comparator Circuit Value Problem and we know that NL is contained in CC which is inturn contained in P. Cook, Filmus and Le (2012) showed that CC is also the class of languages decided by polynomial size comparator circuits. We study generalizations of the comparator circuit model that work over fixed finite bounded posets. We observe that there are universal comparator circuits even over arbitrary fixed finite bounded posets. Building on this, we show that general (resp. skew) comparator circuits of polynomial size over fixed finite distributive lattices characterizes CC (resp. L). Complementing this, we show that general comparator circuits of polynomial size over arbitrary fixed finite lattices exactly characterizes P even when the comparator circuit is skew. In addition, we show a characterization of the class NP by a family of polynomial sized comparator circuits over fixed {\em finite bounded posets}. These results generalize the results by Cook, Filmus and Le (2012) regarding the power of comparator circuits. As an aside, we consider generalizations of Boolean formulae over arbitrary lattices. We show that Spira's theorem (1971) can be extended to this setting as well and show that polynomial sized Boolean formulae over finite fixed lattices capture exactly NC^1.

cs.CC↗

arXiv2017

On the Complexity of L-reachability

We initiate a complexity theoretic study of the language based graph reachability problem (L-REACH) : Fix a language L. Given a graph whose edges are labeled with alphabet symbols of the language L and two special vertices s and t, test if there is path P from s to t in the graph such that the concatenation of the symbols seen from s to t in the path P forms a string in the language L. We study variants of this problem with different graph classes and different language classes and obtain complexity theoretic characterizations for all of them. Our main results are the following: 1.Restricting the language using formal language theory we show that the complexity of L-REACH increases with the power of the formal language class. We show that there is a regular language for which the L-REACH is NL-complete even for undirected graphs. In the case of linear languages, the complexity of L-REACH does not go beyond the complexity of L itself. Further, there is a deterministic context-free language L for which L-DAGREACH is LogCFL-complete. 2.We use L-REACH as a lens to study structural complexity. In this direction we show that there is a language A in TC0 for which A-DAGREACH is NP-complete. Using this we show that P vs NP question is equivalent to P vs DAGREACH-1(P) question. This leads to the intriguing possibility that by proving DAGREACH-1(P) is contained in some subclass of P, we can prove an upward translation of separation of complexity classes. Note that we do not know a way to upward translate the separation of complexity classes.

cs.CC↗

arXiv2016

Pebbling Meets Coloring: Reversible Pebble Game On Trees

The reversible pebble game is a combinatorial game played on rooted DAGs. This game was introduced by Bennett (1989) motivated by applications in designing space efficient reversible algorithms. Recently, Chan (2013) showed that the reversible pebble game number of any DAG is the same as its Dymond-Tompa pebble number and Raz-Mckenzie pebble number. We show, as our main result, that for any rooted directed tree T, its reversible pebble game number is always just one more than the edge rank coloring number of the underlying undirected tree U of T. It is known that given a DAG G as input, determining its reversible pebble game number is PSPACE-hard. Our result implies that the reversible pebble game number of trees can be computed in polynomial time. We also address the question of finding the number of steps required to optimally pebble various families of trees. It is known that trees can be pebbled in $n^{O(\log(n))}$ steps where $n$ is the number of nodes in the tree. Using the equivalence between reversible pebble game and the Dymond-Tompa pebble game (Chan, 2013), we show that complete binary trees can be pebbled in $n^{O(\log\log(n))}$ steps, a substantial improvement over the naive upper bound of $n^{O(\log(n))}$. It remains open whether complete binary trees can be pebbled in polynomial (in $n$) number of steps. Towards this end, we show that almost optimal (i.e., within a factor of $(1 + ε)$ for any constant $ε> 0$) pebblings of complete binary trees can be done in polynomial number of steps. We also show a time-space trade-off for reversible pebbling for families of bounded degree trees by a divide-and-conquer approach: for any constant $ε> 0$, such families can be pebbled using $O(n^ε)$ pebbles in $O(n)$ steps. This generalizes an analogous result of Kralovic (2001) for chains.

cs.CC↗

arXiv2013

Pebbling, Entropy and Branching Program Size Lower Bounds

We contribute to the program of proving lower bounds on the size of branching programs solving the Tree Evaluation Problem introduced by Cook et. al. (2012). Proving a super-polynomial lower bound for the size of nondeterministic thrifty branching programs (NTBP) would separate $NL$ from $P$ for thrifty models solving the tree evaluation problem. First, we show that {\em Read-Once NTBPs} are equivalent to whole black-white pebbling algorithms thus showing a tight lower bound (ignoring polynomial factors) for this model. We then introduce a weaker restriction of NTBPs called {\em Bitwise Independence}. The best known NTBPs (of size $O(k^{h/2+1})$) for the tree evaluation problem given by Cook et. al. (2012) are Bitwise Independent. As our main result, we show that any Bitwise Independent NTBP solving $TEP_{2}^{h}(k)$ must have at least $\frac{1}{2}k^{h/2}$ states. Prior to this work, lower bounds were known for NTBPs only for fixed heights $h=2,3,4$ (See Cook et. al. (2012)). We prove our results by associating a fractional black-white pebbling strategy with any bitwise independent NTBP solving the Tree Evaluation Problem. Such a connection was not known previously even for fixed heights. Our main technique is the entropy method introduced by Jukna and Z{á}k (2001) originally in the context of proving lower bounds for read-once branching programs. We also show that the previous lower bounds given by Cook et. al. (2012) for deterministic branching programs for Tree Evaluation Problem can be obtained using this approach. Using this method, we also show tight lower bounds for any $k$-way deterministic branching program solving Tree Evaluation Problem when the instances are restricted to have the same group operation in all internal nodes.

cs.CC↗