Balagopal Komarath

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 superpolynomial lower bound for the size of nondeterministic thrifty branching programs would be an important step toward separating NL from P using the tree evaluation problem. First, we show that Read-Once Nondeterministic Thrifty BPs 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 nondeterministic thrifty branching programs called Bitwise Independence. The best known [Cook et al. 2012] nondeterministic thrifty branching programs (of size O(kh/2 + 1)) for the tree evaluation problem are Bitwise Independent. As our main result, we show that any Bitwise Independent Nondeterministic Thrifty Branching Program solving BT2(h, k) must have at least (k2)h/2 states. Prior to this work, lower bounds were known for nondeterministic thrifty branching programs only for fixed heights h = 2, 3, 4 [Cook et al. 2012]. We prove our results by associating a fractional black-white pebbling strategy with any bitwise independent nondeterministic thrifty branching program 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 known [Cook et al. 2012] for deterministic branching programs for the 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 the Tree Evaluation Problem when the instances are restricted to have the same group operation in all internal nodes.

On the Complexity of L-reachability*

We initiate a complexity theoretic study of the language based reachability problem (L-reach) : Fix a language L. Given a graph whose edges are labelled with alphabet symbols 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 characterisations for all of them. Our main results are the following:

Reversible Pebble Game on Trees

A surprising equivalence between different forms of pebble games on graphs - Dymond-Tompa pebble game (studied in [4]), Raz-McKenzie pebble game (studied in [10]) and reversible pebbling (studied in [1]) - was established recently by Chan[2]. Motivated by this equivalence, we study the reversible pebble game and establish the following results.

Circuit Complexity of Properties of Graphs with Constant Planar Cutwidth

We study the complexity of several of the classical graph decision problems in the setting of bounded cutwidth and how imposing planarity affects the complexity. We show that for 2-coloring, for bipartite perfect matching, and for several variants of disjoint paths, the straightforward NC 1 upper bound may be improved to AC 0[2], ACC 0, and AC 0 respectively for bounded planar cutwidth graphs. We obtain our upper bounds using the characterization of these circuit classes in tems of finite monoids due to Barrington and Therien. On the other hand we show that 3-coloring and Hamilton cycle remain hard for NC 1 under projection reductions, analogous to the NP-completeness for general planar graphs. We also show that 2-coloring and (non-bipartite) perfect matching are hard under projection reductions for certain subclasses of AC 0[2]. In particular this shows that our bounds for 2-coloring are quite close.

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 in (Stephen A. Cook, Pierre McKenzie, Dustin Wehr, Mark Braverman, and Rahul Santhanam, 2012). Proving an exponential lower bound for the size of the non-deterministic thrifty branching programs would separate NL from P under the thrifty hypothesis. In this context, we consider a restriction of non-deterministic thrifty branching programs called bitwise-independence. We show that any bitwise-independent non-deterministic thrifty branching program solving BT_2(h,k) must have at least 1/2 k^{h/2} states. Prior to this work, lower bounds were known for general branching programs only for fixed heights h=2,3,4 (Stephen A. Cook, Pierre McKenzie, Dustin Wehr, Mark Braverman, and Rahul Santhanam, 2012). Our lower bounds are also tight (up to a factor of k), since the known (Stephen A. Cook, Pierre McKenzie, Dustin Wehr, Mark Braverman, and Rahul Santhanam, 2012) non-deterministic thrifty branching programs for this problem of size O(k^{h/2+1}) are bitwise-independent. We prove our results by associating a fractional pebbling strategy with any bitwise-independent non-deterministic thrifty branching program 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 Zak (S. Jukna and S. Žak, 2003) originally in the context of proving lower bounds for read-once branching programs. We also show that the previous lower bounds known (Stephen A. Cook, Pierre McKenzie, Dustin Wehr, Mark Braverman, and Rahul Santhanam, 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.

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 [1] motivated by applications in designing space efficient reversible algorithms. Recently, Siu Man Chan [2] 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 . The most striking implication of this result is that the reversible pebble game number of a tree does not depend upon the direction of edges, a fact that does not hold in general for DAGs. 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 as edge rank coloring number of trees can be computed in linear time ([8]). 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 nO(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 [2], we show that complete binary trees can be pebbled in nO(log log(n)) steps, a substantial improvement over the naive upper bound of nO(log(n)). It remains open whether complete binary trees can be pebbled in polynomial number of steps (i.e., nk for some constant k). 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. ∗Sponsored by TCS Research Fellowship

Comparator Circuits over Finite Bounded Posets

Abstract The comparator circuit model was originally introduced by Mayr et al. (1992) (and further studied by Cook et al. (2014)) to capture problems that 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 NLOG ⊆ CC ⊆ P . Cook et al. (2014) showed that CC is also the class of languages decided by polynomial size comparator circuit families. 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 the following: • Comparator circuits of polynomial size over fixed finite distributive lattices characterize the class CC . When the circuit is restricted to be skew, they characterize LOG . Noting that (uniform) polynomial sized Boolean circuits (resp. skew) characterize P (resp. NLOG ), this indicates a comparison between P vs CC and NLOG vs LOG problems. • Complementing this, we show that comparator circuits of polynomial size over arbitrary fixed finite lattices characterize the class 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 finite bounded posets . As an aside, we consider generalizations of Boolean formulae over arbitrary lattices. We show that Spiras theorem (Spira, 1971) can be extended to this setting as well and show that polynomial sized Boolean formulae over finite fixed lattices capture the class NC 1 . These results generalize results in Cook et al. (2014) regarding the power of comparator circuits. Our techniques involve design of comparator circuits and finite posets. We then use known results from lattice theory to show that the posets that we obtain can be embedded into appropriate lattices. Our results give new methods to establish CC upper bounds for problems and also indicate potential new approaches towards the problems P vs CC and NLOG vs LOG using lattice theoretic methods.

On the Complexity of L -reachability

We initiate a complexity theoretic study of the language based reachability problem (L-reach) : Fix a language L. Given a graph whose edges are labelled with alphabet symbols 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 characterisations for all of them. Our main results are the following: