This work is a culmination of exploration of four themes in combinatorics, algorithm design, and algebraic complexity – graph algorithms, homomorphism polynomials, graph parameters, and monotone computations. While each of these themes are of independent interest, a strong interplay among them has become quite apparent in the recent years, and has lead to several new advancements in algorithms and complexity.
The first theme is of graph algorithms, where the algorithms that are relevant to this work are those corresponding to pattern detection and counting. Loosely speaking, in such problems, we look for the “presence” of a graph , called the pattern graph in another graph , called the host graph111In this paper, the pattern graph and the host graph are always simple, undirected graphs.. The notions of presence of one graph in another graph that have been the most prevalent are subgraph isomorphism, induced subraph isomorphism, and homomorphism. In detection and counting algorithms for subgraph isomorphism (resp. induced subgraph isomorphism), we want to detect and count subgraphs (resp. induced subraphs) of an -vertex host graph which is isomorphic to the pattern graph. Whereas, while looking for the occurrence of the pattern graph in the host graph, if we relax the mapping to allow multiple vertices in the pattern graph to be mapped to a single vertex in the host graph, while preserving the edge relations, we get a homomorphism of the pattern graph in the host graph. When the notion is homomorphism, then we are interested in detecting and counting homomorphisms from the pattern graph to the host graph.
All the above mentioned problems have found many applications, both in theory and practice. For instance, detecting and counting (induced) subgraph isomorphisms are used in extremal graph theory in the study of dense graphs and quasirandom graphs [CGW89, LOV12, LS08], and in many applications which boil down to analyzing real-world graphs. This includes finding protein interactions in biomolecular networks [ADH+08, MSI+02], finding active chemicals of interest in the research for drug synthesis [BB02], for advertisement targeting by finding and counting certain social structure patterns in the analysis of social networks [KZY13, ZWc.], and also finding user patterns for recommender services on platforms like Amazon and Yelp [ZYL+17]. The homomorphism counting problem appears for instance, in statistical physics via partition functions, in graph property testing, and extremal graph theory (see [BCL+06] for a survey). When both the host graph and the pattern graph are parts of the input, then it can be shown that all these pattern detection problems are -complete, since they generalize the problem, whereas the corresponding counting problems are all known to be -complete. On the other hand, in almost all the real-world applications pointed above, we have a fixed pattern graph which we are trying to detect or count in a given host graph. Thus, in this work, we focus on the setting when the pattern graph is a fixed graph, and the host graph is a part of the input, Here, since the pattern graph is of a fixed size, say its number of vertices is , all the above problems can be solved using a trivial algorithm, based on exhaustive search, that runs in time and space where
is the number of vertices in the host graph. However, in almost all the real-world applications pointed above, the host graph is massive, and hence one desires faster algorithms, preferably linear or even sub-linear algorithms. Hence, there is a lot of interest and advances in improving upon this trivial algorithm using ideas from combinatorics, algebraic circuits, and machine learning (see[MP14] for a survey, also see [BKS18, LPH+20] and references therein). In fact, these problems are also very interesting from the perspective of complexity theory. For instance, it is conjectured that the best known algorithms for variants of these pattern detection and counting problems can not be further improved. If true, this would imply in a rather strong way (see [LRR17, MAR10, ROS18, KR20]). Recently, it was discovered by Curticapean, Dell and Marx [CDM17] (also see [DST02]) that counting subgraph isomorphisms corresponds to counting linear combinations of homomorphisms, and hence establishing that it is sufficient to just consider the homomorphism counting problem. Several advances have been attained by considering homomorphism problems [BKS18, KKM00, KLL13, FKL+15a, WWW+15].
Our second theme – homomorphism polynomials, corresponds to one of the most successful ways by which progress has been made towards homomorphism problems, and hence towards (induced) subgraph isomorphism problems too. For a pattern graph and a host graph , the homomorphism polynomial is the polynomial whose monomials enumerate homomorphisms from to . For using homomorphism polynomials for obtaining new algorithms for the above graph problems for a pattern graph , it suffices to consider the homomorphism polynomial from to , the clique on vertices. Thus, we call the homomorphism polynomial from to as the homomorphism polynomial of (see Definition 6 for a formal definition). It turns out that efficient arithmetic circuit (see Section 2 for definition) constructions of homomorphism polynomials can be used to obtain almost all known better algorithms for detecting induced subgraph isomorphisms as well (See [BKS18], also [KKM00, KLL13, FKL+15a, WWW+15]). Therefore, the study of homomorphism polynomials is a crucial area of study within graph pattern detection and counting. Homomorphism polynomials also turned out to be extremely useful in algebraic complexity theory in the quest for finding natural complete polynomial families for the complexity class (the algebraic complexity analog of . See [SAP15]). Homomorphism polynomials yield polynomial families that are complete for important algebraic complexity classes such as , , and through a single framework, simply by considering different pattern graphs [DMM+16, MS18, CLV19], making it important not only from the perspective of algorithm design, but also from the perspective of complexity theory. Homomorphism polynomials are thus the central focus of this work too.
In our third theme, that is of graph parameters, the parameters relevant to this work are treewidth, pathwidth, and treedepth of graphs. Treewidth, loosely speaking, is a measure of how far a graph is from being a tree; similarly the pathwidth measures how far a graph is from being a path; and treedepth measures how far a graph is from being a star (see Section 2 for definitions). The connection between the parameters treewidth and pathwidth and counting homomorphisms was first explored in [DST02] (also see [BKS18, MS18]), where it is shown that when has bounded treewidth, then there are small-sized arithmetic circuits for homomorphism polynomials, whereas when has small pathwidth, then the corresponding homomorphism polynomials have small-sized algebraic branching programs (ABPs, defined in Section 2). These improved constructions for circuits and ABPs are one of the main source of advancement in finding improved algorithms for these pattern detection and counting problems [BKS18, KKM00, KLL13, FKL+15a, WWW+15]. The connection between the subgraph isomorphism problem and treedepth has also been explored in the context of Boolean computational models in [LRR17] and [KR20], where they discuss treewidth and treedepth based upper bounds and lower bounds for counting subgraph isomorphisms for Boolean circuits and formulas. In the context of parameterized counting complexity of these problems, a stronger connection between treewidth and the complexity of counting homomorphisms was established by Dalmau and Jonsson [DJ04] who showed a dichotomy theorem stating that when the pattern graph has bounded treewidth, then we can count homomorphisms in polynomial time, otherwise, we can show #W-hardness. Now we turn our attention to the other major application of homomorphism polynomials. It turns out that the the parameters treewidth and pathwidth played a crucial role in the construction of natural complete polynomials for and too. More specifically, the complete polynomials for and were homomorphism polynomials corresponding to specific pattern graphs of bounded treewidth and bounded pathwidth respectively. Thus, one sees that in the context of these pattern detection and counting problems, and in the homomorphism polynomials of interest, these graph parameters of the pattern graph ubiquitously pop up over and over again as the crucial complexity parameters. This made us wonder, to what extent do these parameters dictate the complexity of these problems and, in particular, the homomorphism polynomials.
Towards this, the starting point of our work is the observation that all the improved arithmetic circuit constructions of homomorphism polynomials based on treewidth and pathwidth, do not use any negative constants in the circuit. This brings us to our final theme, that is, of monotone computation.
In the Boolean setting, monotone computations refer to computations that do not involve negation operation, the NOT gate. Similarly, in the algebraic setting for computing polynomials, monotone arithmetic circuits correspond to circuits that do not use negative constants or subtraction gate, that is, there is no cancellation involved in the circuit. Monotone computations are interesting for three main reasons. First reason is that monotone operations have favorable stability properties with respect to rounding errors [SCH76]. Secondly, an improved monotone circuit, since it does not use any cancellations and hence algebraic identities, requires combinatorial insights, and often leads to interesting combinatorial algorithms for the problem at hand. Such constructions often reveal interesting combinatorial insights about the problem. For instance, Grenet’s monotone algebraic branching program construction of the permanent polynomial [GRE12]. Finally, the weakness of monotone models resulting from the lack of cancellations, makes them significantly easier to understand. As a consequence, monotone computations are much better understood, both in the Boolean and the algebraic setting, and hence have been used as a starting point towards understanding the general model. Indeed, we know exponential lower bounds as well as separations between important complexity classes when we restrict ourselves to the monotone setting, in contrast to the embarrassingly poor understanding that we have in the general setting. In particular, Schnorr [SCH76] showed an exponential lower bound for the clique polynomial, which happens to be a special case of homomorphism polynomial, where the pattern graph is a clique. Moreover, we know superpolynomial separations between complexity classes222 and refer to the class of polynomial families computable by poly-sized monotone arithmetic formulas, monotone algebraic branching programs, and monotone arithmetic circuits, respectively. refers to the monotone analog of the complexity class . and [SNI80], and [HY16], and finally, very recently, between and [YEH19]. None of these separations are settled in the non-monotone setting. Moreover, the best known circuit lower bound in the non-monotone setting is just [BS83]. Thus, apart from the special interests in algorithms based on improved monotone circuits, from the perspective of lower bounds too, it makes sense to first study monotone models, as a first step towards getting lower bounds for the general model. Many times, the best upper bounds also first come in the monotone setting. For instance, the best known upper bound for the permanent polynomial for ABPs is a monotone construction [GRE12]. In fact, for our central problem of interest, that is, computing homomorphism polynomial, in a lot of settings, the best known upper bounds are still those via monotone constructions333 We can get the upper bound corresponding to the pattern graphs with treewidth [CDM17], and for all -vertex graphs [NP85], where is the exponent of matrix multiplication For large pattern graphs with treewidth , the monotone constructions are the best known..
This motivated us to pursue the concrete question of whether these treewidth and pathwidth based improved monotone arithmetic circuits for homomorphisms polynomials can further be improved, and to what extent would these graph parameters dictate it. The answer that we discovered turns out to be conceptually quite satisfying, and settles the problem completely.
1.1 Our contributions
In this work, we fully solve the question of monotone complexity of homomorphism polynomials by showing that they are completely determined by the aforementioned graph parameters.
For arithmetic circuits, we discover that the treewidth of the pattern graph exactly determines the monotone complexity of its homomorphism polynomial, by establishing that the treewidth based upper bound in [DST02, MS18, BKS18] is also a lower bound.
The monotone arithmetic circuit complexity of homomorphism polynomial for a pattern graph is , where is the treewidth of .
In the case of algebraic branching programs, we find that the pathwidth of the pattern graph is the parameter controlling the monotone complexity of its homomorphism polynomial, again by proving a lower bound that exactly matches the pathwidth based upper bound in [DST02, MS18, BKS18].
The monotone ABP complexity of homomorphism polynomial for a pattern graph is , where is the pathwidth of .
Finally, for monotone formulas, it is the treedepth of the pattern graph which governs the complexity of its homomorphism polynomial.
The monotone formula complexity of homomorphism polynomial for a pattern graph is , where is the treedepth of .
Hence, we resolve the question of monotone complexity of homomorphism polynomials completely by showing that treewidth, pathwidth and treedepth exactly characterize the complexity of homomorphism polynomials for arithmetic circuits, ABPs, and arithmetic formulas respectively. This also answers the conceptual question raised earlier asking to what extent do these graph parameters dictate the complexity of these homomorphism polynomials.
It is worth noting that in the Boolean setting, while there are known upper bounds and lower bounds based on these graph parameters for circuits and formulas for (colored) subgraph isomorphism problem, there is still an asymptotic gap between the upper bound and the corresponding lower bounds in these Boolean models (see [LRR17, KR20]). Moreover, our lower bound techniques are very different from those in the Boolean models.
The characterization, in addition to giving several new lower bounds, in particular, also allows us to collect, through a unified framework, several classical and recent results for the monotone complexity of polynomials, obtained independently using different methods, over several decades. This is simply because the above theorems imply that for every family of pattern graph with high treewidth, pathwidth, or treedepth, the corresponding homomorphism polynomial family will have high circuit complexity, ABP complexity, or formula complexity, respectively. From the algorithmic perspective, the formula upper bounds on homomorphism polynomials allows us to discover efficient space-time algorithms for several variants of pattern detection and counting.
Our characterization, in particular, also rediscovers the fine-grained separations between all these models for constant-degree polynomials. That is, for every constant , we get a polynomial family such that it is computable by linear-sized monotone arithmetic circuits, but any monotone ABP computing it must be of size at least . Analogously, for every constant , we get a polynomial family computable by linear-sized monotone ABP but any monotone arithmetic formula computing it must be of size at least . Earlier, such fine-grained separations could be obtained by applying the results of [SNI80] and [HY16] together.
The formula upper bound for homomorphism polynomial yields algorithms for counting homomorphisms that run in time and space for all patterns except cliques. This also implies better algorithms for counting subgraph isomorphisms and detecting induced subgraph isomorphisms using some observations made in [BKS18]. Prior to this, an algorithm that runs in time for counting subgraph isomorphism was known [CDM17]. This, however, uses polynomial space in its execution. For a related problem, that is, detecting colored subgraph isomorphisms, such efficient space-time algorithms followed as a consequence of small-sized treedepth based Boolean formulas (see [KR20]).
1.2 Proof ideas
For our lower bound techniques used in proving Theorem 1, 2 and 3, it turns out that it is easier to work with the so-called colored subgraph isomorphism polynomials instead of the homomorphism polynomials. So, we first show that for proving lower bounds for homomorphism polynomials, it is sufficient to consider the colored subgraph isomorphism polynomial. We establish this by proving that for fixed-size pattern graphs (say, the number of vertices is ), their complexity is the same in all the three models that we consider, arithmetic circuits, ABPs, and formulas (see Lemma 1).
Now, for the lower bound in Theorem 1, we successfully answer the question – in how many monomial computations can a single gate participate? Our main technical contribution is to establish that the answer to this question is dictated by the treewidth of the pattern graph (proof of Theorem 4). For this we start with an arbitrary monomial computation (more precisely, parse trees, discussed in Section 2) in an arbitrary circuit computing the polynomial and use it carefully to construct the so-called tree decomposition (Definition 9) of the pattern graph . Then, if the number of vertices in is , and its treewidth is , we argue that a gate can participate in the computation of at most monomials. We show this by using a weakness of monotone computation that, due to the absence of cancellations, any circuit computing a polynomial cannot compute an invalid submonomial444an invalid submonomial is a monomial which does not divide any of the monomial of the target polynomial at any intermediate gate along the way. This weakness is exploited in almost all known monotone lower bounds, and dates back to Jerrum and Snir [JS82].
For proving the lower bounds in Theorem 2 and 3 for formulas and ABPs, we are able to use the same framework as above. Instead of constructing a tree decomposition using the parse trees, we construct a path decomposition (Definition 9) in case of ABPs, and an elimination tree (Definition 10) in case of formulas. Using the similar weakness of monotone computation, we conclude that the number of monomials whose computation a gate can participate in is upper bounded by in case of ABPs, and by in case of formulas, where and denote the pathwidth and the treedepth of respectively.
To obtain the upper bounds claimed in Theorem 1, 2 and 3, we note that the upper bounds for circuits and ABPs that were already known are both monotone constructions, and they go via the tree decomposition and the path decomposition of the pattern graph in case of circuits and ABPs respectively [DST02, BKS18, MS18]. We give the formula upper bound using the elimination tree of the pattern graph. A treedepth based monotone formula upper bound is folklore in the Boolean setting. We believe that our formula construction in the arithmetic formula uses similar ideas.
To prove the separation between monotone complexity classes, we observe that pattern graphs with high pathwidth but low treewidth yield superpolynomial separation between circuits and ABPs (discussed in Theorem 7), whereas pattern graphs with high treedepth but low pathwidth give superpolynomial separation between ABPs and formulas (described in Theorem 8). For the first separation, we use a tree as the pattern graph, whereas for the second separation, we use path as the pattern graph. For an exponential lower bound on the clique polynomial, we simply apply Theorem 1 in combination with the fact that the treewidth of a clique on vertices is .
To get improved efficient space-time algorithms, we notice that our formula construction in the proof of Theorem 3 is a constant-depth formula and hence can be evaluated in polylog-space and time (see Theorems 10, 11 and 12).
Comparison with previous techniques:
As mentioned above, a lot of monotone lower bounds (eg. [JS82, HY16]) at their core, use that due to the lack of cancellation, any circuit (resp. ABP or formula) computing a polynomial cannot compute an invalid submonomial at any intermediate gate along the way. The central idea behind all the lower bounds that use this weakness is to argue, depending on the polynomials they are working with, that certain gates cannot participate in the computation of too many monomials. It is here that we differ from the known lower bound proofs. Since we are working with homomorphism polynomials, we needed something about homomorphism polynomials that help us argue about it. Here, our main conceptual contribution to the proof technique is a method to construct a tree decomposition (resp. path decomposition and elimination forest) for the pattern graph from a parse tree associated with a monomial in the corresponding homomorphism polynomial. From the perspective of proving superpolynomial lower bounds, comparing it with [HY16, SNI80, SCH76], the key difference between the previous techniques and ours is that all our hard polynomials come from a single framework, that is, from homomorphism polynomials corresponding to various classes of pattern graphs. We find it conceptually satisfying.
For ABPs, Fournier, Malod, Szusterman, and Tavenas [FMS+19] gave a rank-based lower bound method for the monotone setting, inspired by [NIS91] given in the non-commutative setting. However, in their models, the edge labels are homogeneous linear forms, which makes their method unsuitable for the tight lower bounds that we were looking for.
Finally, an approach that seems different from all these aforementioned approaches, including ours, is the one given by Schnorr [SCH76]. which also gave an exponential lower bound on the clique polynomial [SCH76, Theorem 4.4]. We show in Section 3 that his approach also falls short of proving the lower bound that matches the upper bound. In fact, unlike Schnorr’s lower bound techniques, our proofs at a very high level, follow an abstract argument that can be shown to always give the optimal lower bound on the number of addition gates (see Theorem 9).
It is worth mentioning that our lower bounds, like many other previous lower bounds, depend only on the monomials present in the polynomials, and not on the corresponding coefficients. On the other hand, the proof of separation between monotone and by Yehudayoff [YEH19] was sensitive to coefficients too, which was crucial for the separation.
Organization of the paper:
To simplify the presentation, we assume that the pattern graph is connected. The complexity for a disconnected pattern is the maximum of the complexity of its connected components.
A polynomial over is called monotone if all its coefficients are non-negative.
Compact representations of polynomials such as the following are usually used by algorithms.
An arithmetic circuit over the variables is a rooted DAG where each source node (also called an input gate) is labeled by one of the variables or a constant . All other nodes (called gates) are labeled with either (addition) or (multiplication). The circuit computes a polynomial over in the usual fashion. The circuit is called monotone if all constants are non-negative. The circuit is a skew circuit if for all gates, at least one of the inputs is a variable or a constant. The circuit is a formula if all gates have out-degree at most one. The size
of a circuit or skew circuit or formula is the number of edges in the circuit. Thedepth of a circuit is the number of gates in the longest path from the root to an input gate.
Instead of skew circuits, a model that is equivalent in terms of power is usually studied in algebraic complexity.
An Algebraic Branching Program (ABP) is a DAG with a unique source node and a unique sink node . Each edge is labeled with a variable from or a constant . Each path in the DAG from to corresponds to a term obtained by multiplying all the edge labels on that path. The polynomial computed by the ABP is the sum of all terms over all paths from to . The ABP is called monotone if all constants are non-negative. The size of the ABP is the number of edges.
It is well-known that for any (monotone) polynomial, the size of the smallest (monotone) ABP and the size of the smallest (monotone) skew circuit are within constant factors of each other. In this paper, we will use the skew circuit definition in our proofs.
In this paper, we look at families of polynomials and the optimal size and depth of the models computing them. In this case, the size and depth are functions of and we are only interested in the asymptotic growth rate of these functions.
For simplicity, when proving lower bounds, we assume that all non-input gates have exactly two incoming edges (both may be from the same gate). This assumption doesn’t increase the size of the circuit and may increase the depth by at most a logarithmic factor.
The families of polynomials that we look at in this paper enumerate graph homomorphisms or colored isomorphisms. We first define these notions.
For graphs and , a homomorphism from to is a function such that implies . For an edge in , we use to denote .
Let be a -vertex graph where its vertices are labeled and let be a graph where each vertex has a color in . Then, a colored isomorphism of in is a subgraph of isomorphic to such that all vertices in the subgraph have different colors and for each edge in , there is an edge in the subgraph between vertices colored and .
Now, we are ready to define our main object of computation, the homomorphism polynomial.
For a pattern graph on vertices, the homomorphism polynomial for is a polynomial on variables where for .
where ranges over all homomorphisms from to and ranges over all edges in .
Next, we define the colored isomorphism polynomial which would be crucial in our proofs. This polynomial enumerates all colored isomorphisms from a pattern to a host graph where there are vertices of each color. This polynomial can be used to count colored isomorphisms in -vertex host graphs by setting the variables corresponding to edges not in the host graph to .
For a pattern graph on vertices, the colored isomorphism polynomial for is a polynomial on variables where for and .
where and .
We notice that the labeling of does not affect the complexity of . Given the polynomial for some labeling of and if is a relabeling of , then the polynomial for the new labeling can be obtained by the substitution .
For our main proofs, we need a way to analyze how a monomial is being computed in a circuit, an ABP, or a formula. For this, we use the notion of parse trees.
Let be a gate in a circuit . A parse tree rooted at is any rooted tree which can be obtained by the following procedure, duplicating gates in as necessary to preserve the tree structure.
The gate is the root of the tree.
If there is a multiplication gate in the tree, include all its children in the circuit as its children in the tree.
If there is an addition gate in the tree, pick an arbitrary child of in the circuit and include it in the tree.
If the root gate of a parse tree is not mentioned, then it is assumed to be the output gate of the circuit. A parse tree witnesses the computation of some term. We note that if is a formula, then any gate can occur at most once in any parse tree in .
Given a parse tree that contains a gate , we use to denote the subtree of rooted at . The tree obtained by removing from is called the tree outside in . Note that we can replace in with any parse tree rooted at to obtain another parse tree. Similarly, if we have two parse trees and that both contain the same multiplication gate from the circuit, then we can replace the left or right subtree of with the left or right subtree of to obtain another parse tree. This is because both the left and right child of in both parse trees are the same and therefore we can apply the aforementioned replacement.
Now, we define the graph parameters most crucial to our work. They are the parameters that turn out to exactly characterize the complexity of the above polynomial families in the models of computations defined above.
A tree decomposition of is a tree where each vertex (called a bag) in the tree is a subset of vertices of . This tree must satisfy two properties.
For every edge in , there must be at least one bag in the tree that contains both and .
For any vertex in , the subgraph of the tree decomposition induced by all bags containing must be a subtree. This subtree is called the subtree induced by .
The size of a tree decomposition is the size of the largest bag minus one. The treewidth of is the size of a smallest tree decomposition of .
A tree decomposition is called a path decomposition if it is a path. The pathwidth of is the size of a smallest path decomposition.
For a connected graph , an elimination tree of is a rooted, directed tree that can be constructed by arbitrarily picking a vertex in and adding edges from the roots of elimination trees of connected components of to the root vertex labeled . In particular, if is a single vertex, then the elimination tree of is the same single vertex graph.
The depth of an elimination tree is the number of vertices in the longest path from a leaf to the root. The treedepth of is the depth of the smallest depth elimination tree of .
We note that for any graph , its elimination tree contains exactly vertices. All edges in the tree are directed towards the root and the vertices of the tree are uniquely labeled with the vertices of . If is an elimination tree for the connected graph , then all edges in are between vertices that are in an ancestor-descendant relationship in .
We now state some basic facts about treewidth, pathwidth, and treedepth. We combine these facts with the lower bounds in Section 3 to obtain, for any constant , constant-degree polynomial families having linear size circuits (ABPs resp.) but requiring size ABPs (formulas resp.), thus giving us a fine-grained separation between these models. Note that, for constant-degree polynomials, such polynomial factor separations are the best one could ask for between formulas, ABPs, and circuits, since all constant-degree polynomials are computable by polynomial-sized formulas. Moreover, we use these facts to obtain superpolynomial separations between these models for high degree polynomials.
For all graphs , we have .
For any , there is a tree on vertices that have pathwidth .
All paths have pathwidth 1 and the -vertex path has treedepth .
3 Algebraic complexity of homomorphism polynomials
We first briefly show the limitation of Schnorr’s approach [SCH76] which also serves as a warm up to better familiarize the reader with the homomorphism polynomials before we go into our main proofs.
Schnorr [SCH76] introduced a technique to prove monotone arithmetic circuit lower bounds for polynomials. A separating set for a polynomial is a set of monomials in such that for any two monomials and in the separating set, there does not exist a monomial of such that divides the product . Schnorr showed that the size of a separating set lower bounds the size of the monotone arithmetic circuit computing the polynomial. Using this, he showed that requires monotone arithmetic circuits of size . We now show that there are pattern graphs for which we cannot prove optimal lower bounds using Schnorr’s approach.
Any separating set for has size at most for sufficiently large .
First note that a homomorphic image of a will either be another or an edge (), and consequently, the monomials of will correspond to either a or an edge. Thus, any separating set for contains monomials that correspond to either or edges. Partition into (set of ’s) and (set of edges). If two ’s intersect, then their union must contain a different . If two edges intersect, then their union must contain a . The product of two monomials that correspond to these intersecting ’s or edges would be divisible by the monomial that corresponds to the new . This shows that and contain at most and monomials respectively. ∎
Obviously, any circuit (even non-monotone) that computes must have size because all variables are present in the polynomial. But, this lower bound is not very interesting. Below, we show that there are patterns with non-trivial monotone lower bounds where Schnorr’s approach fails.
Any separating set for has size at most for sufficiently large .
Since the homomorphic image of a can either be a , a , or a , the monomials in , and subsequently in any separating set, can only contain monomials that correspond to , , or . Now, by the argument in Proposition 1, it remains only to consider monomials that correspond to . We claim that any separating set can contain at most such monomials. Observe that for any , the set can contain at most one where and appear as diagonally opposite vertices. If there are two of them, then there is another in the graph obtained by taking the union of those two ’s. The product of two such monomials would be divisible by the monomial corresponding to this new . ∎
In the rest of this section, we establish optimal lower bounds on the monotone circuit complexity of all homomorphism polynomials.
For any pattern , both the homomorphism polynomial for and the colored isomorphism polynomial for have the same monotone arithmetic circuit complexity, monotone ABP complexity, and monotone formula complexity.
First, we show how to obtain a circuit that computes from one that computes . We introduce new variables for each . Let be a circuit that computes over the vertex set . We substitute with for all if . Otherwise, we set the variable to . Let be the resulting circuit. We then compute using the sum and product rule for partial derivatives. Then, we set for all . The partial differentiation ensures that all monomials must have at least one edge of each color. Setting ensures that all monomials can only have at most one edge of each color. Therefore, the remaining monomials contain each edge in exactly once. These are exactly those homomorphisms that correspond to colored isomorphisms. For each colored isomorphism, there are ways to relabel the vertices of to obtain the same edge set. So we divide by to obtain exactly. Each partial differentiation increases the size of the circuit at most by a factor of . Therefore, if has size , the final circuit has size at most for some constant .
For the other direction, given a circuit that computes , we can replace each with if and otherwise. The circuit now computes because the monomial corresponding to the homomorphism is generated by the corresponding colored isomorphism . Also, every colored isomorphism on vertices for corresponds to a homomorphism to as long as for .
Notice that both constructions preserve monotonicity and yield a monotone ABP when the original circuit is a monotone ABP.
A straightforward application of the sum and product rule to compute the partial derivative does not necessarily yield a formula from a formula. While computing the partial derivative, we have to compute both and for every sub-formula . If for some formulas and , then we can simply compute without using any sub-formula more than once. When the formula for some formulas and , we have to compute . Therefore, we are using and twice, once for computing and once for computing . We can convert the resulting circuit into a formula by duplicating the sub-formulas and . For general formulas, this leads to a quadratic blowup in size. But, for monotone formulas computing constant-degree polynomials, we show that the size increases only by a constant factor when duplicating sub-formulas in this fashion.
First, we eliminate all gates in the formula that computes and replace all gates that compute a constant by an input gate labeled with that constant. We call a multiplication gate trivial if for some constant and sub-formula . In this case, we have . Therefore, we do not have to make a copy of the non-constant sub-formula . We make a copy of the input gate here. But, we do not have to make additional copies of this input gate later for any trivial gate encountered on the path from to root. This is because is not a constant and therefore it must be the other input to the trivial gate that is constant. We claim that if the monotone formula computes a polynomial of degree at most , for any gate , there are at most non-trivial multiplication gates on the path from to the root gate. This is because each non-trivial gate increases the degree by at least one and no cancellations can occur in a monotone formula. Therefore, we can compute the partial derivative using at most copies of each gate in the original formula. Since the degree of the polynomials we are differentiating is at most and we perform differentiations, the final formula has size if the original formula has size . ∎
From now on, we can use either or to prove our results. For a pattern graph , we say that an edge or a vertex in is present in a monomial over the variables of the colored isomorphism polynomial if there is a variable for some and in that monomial.
In our proofs, we restrict our attention to the multiplication gates and the input gates in parse trees. This is because our proofs consider the computation of individual monomials separately and in this case, the addition gates play no role in the computation as all of them have exactly one child in the parse tree.
Theorem 4 (Theorem 1 restated).
The monotone circuit complexity of is .
Let be of treewidth . For proving the lower bound, we consider the colored isomorphism polynomial for (See Definition 7). Consider any monomial on the vertices for and its associated parse tree. We assume without loss of generality that both sides of any multiplication gate computes a non-constant term (If they compute a constant, it has to be and we can simply ignore this subtree). We build a tree decomposition of H from this tree in a bottom-up fashion. In this tree decomposition, each gate is associated with one or two bags in the decomposition. Exactly one of these bags is designated as the root bag of that gate.
An example of this construction is shown in Figure 1 where the -vertex cycle is the pattern.
For an input gate . Add the bag as a leaf of the tree decomposition. For example, in Figure 1, the input gate labeled is associated with the bag .
For a multiplication gate . Let and be the contents of the root bags of its left and right subtrees. Add a bag containing as the parent of those roots. For example, in Figure 1, the gate is associated with a bag containing .
If at any gate, there are vertices such that the monomial computed at that gate includes all edges incident on . Then add a new bag that excludes exactly all such vertices from the current root bag and add it as a parent of the current root bag. This new bag is now considered the root bag associated with the gate . For example, in Figure 1, we observe that at gate , all edges incident on the vertex are included and therefore we add a new bag that removes and make it the root bag associated with .
The result is a tree decomposition of . All edges of are covered because all edges of must be present in the monomial. Since a vertex is forgotten only after all edges incident on it have been multiplied, the subgraph of the tree decomposition induced by any vertex in is a subtree.
We consider some gate in the parse tree that is associated with a bag that contains at least vertices. In the following proof, we only consider the case where the bag contains exactly vertices. If there are more than vertices, then we get a better lower bound. We assume without loss of generality that these vertices are . We now claim that the gate can only be present in parse trees of monomials such that contains vertices for . Suppose for contradiction there is a monomial with a parse tree that contains and has vertex where for some such . Let be the parse tree for . There are two cases:
The vertex is forgotten at a bag associated with : This means that both left and right subtrees of compute monomials that contain . Now if contains on the left subtree of , then replace right subtree of with right subtree of . Else, the tree contains on the right subtree of or outside . In both cases we replace the left subtree of with the left subtree of .
Vertex is not forgotten at a bag associated with : This means that appears in at least one of the subtrees of and outside in . In , if appears in , then replace the tree with in . Otherwise, the vertex must appear outside in . In this case, replace with in .
All these new parse trees yield monomials that contain both and . A contradiction. Therefore, at most monomials of the polynomial can contain in its parse tree. Since there are monomials, this gives the required lower bound. ∎
Theorem 5 (Theorem 2 restated).
The monotone ABP complexity of is .
For the lower bound, we modify the proof of Theorem 4 to obtain a path decomposition instead. We consider the parse tree and start building the path decomposition from a deepest input gate. An example of this construction is shown in Figure 2 where the -vertex cycle is the pattern.
For the chosen deepest input gate with label , add as a leaf bag. For example, in Figure 2, we choose the input gate labeled as the deepest input gate. A bag containing is added corresponding to this gate.
For a gate that multiplies . Add and to the root bag of the other sub-tree and make it the new root. For example, in Figure 2, the gate multiplies and we add to the root bag of the gate to obtain a bag containing .
If there are vertices in such that all edges incident of have been multiplied into the monomial, add a new parent bag that forgets all such vertices. This is the new root bag corresponding to the gate. For example, in Figure 2, we observe that at gate , all edges incident on have been multiplied into the monomial and therefore we add a new parent bag that removes and make this new bag the root bag of .
It is easy to see that the resulting tree is a path. The same proof as for Theorem 4 shows that this is a path decomposition and that we can find for any parse tree for any monomial , a gate in the parse tree for such that at most monomials contain in its parse tree where is the pathwidth of the pattern. The lower bound follows. ∎
Theorem 6 (Theorem 3 restated).
The monotone formula complexity of is .
We first prove the upper bound555We believe this construction is already known as folklore. But we present it here since we use it in our algorithms.. Let be an elimination tree of depth for . We show how to construct a formula of size for in a bottom-up fashion where is the graph obtained from by adding all possible edges where is an ancestor of in . The polynomial can be obtained by setting extra variables in this polynomial to .
Let be the label of a node in such that the path from root to is labeled and the children of are labeled . We use the notation where to denote the pairs . We construct the formula:
where and .
We use induction on the height of the node in the elimination tree to prove the size upper bound. We claim that the formula that corresponds to such a node has size (constants hidden by the notation depend only on ). For the base case, if is a leaf node, this formula has size . If has depth in , then this formula has size by the induction hypothesis.
If is not an edge in , then we set all to in the formula. The formula corresponding to the root node in is the required polynomial. To prove this, consider the colored subgraph isomorphism containing the vertices for . This monomial has the parse tree obtained by setting the variable in the outermost summation for each to . For the other direction, the parse tree obtained by setting to in the outermost summation of each generates the monomial that corresponds to the colored subgraph isomorphism on vertices .
We now prove the lower bound. Let be the treedepth of . We consider a parse tree for a monomial in a formula computing and build an elimination tree for from it. An example of this construction is shown in Figure 3 where the -vertex path is the pattern. We associate a set of rooted trees with each gate as follows: If the gate is the lowest gate in the parse tree such that all edges incident on vertices are present in the monomial computed at , then make the parent of all roots of trees from the children of . Now, make the parent of for . We call the vertices to be associated with . If there are no such vertices for a gate , then the forest associated with is simply the union of the forests of its children. We start with empty forests initially. For any edge , the gates that corresponds to and in this tree must belong to the path from the input gate for this edge to the root. This shows that this tree is an elimination tree for .
In Figure 3, the input gate labeled is such that the only edge incident on is already multiplied in at . Therefore, we associate the vertex with and the set of trees associated with is just the one-vertex tree . Also, at gate , we have multiplied in all edges incident on and therefore, we associate with . Also, note that this vertex is the parent of the roots of elimination trees from and .
For proving the lower bound, we consider some gate in the parse tree of such that is associated with a leaf at a depth of at least in the elimination tree. We can assume that the depth is exactly . If it is more, then we obtain a better lower bound. Let this vertex be . Assume without loss of generality that are the vertices on the path from the root to in the elimination tree. Let be the corresponding vertices in . We claim that any monomial for which appears in its parse tree must also have vertices of color for .
Suppose for contradiction that there is a monomial with in its parse tree and has vertex where for some . Let be the gate in such that is associated with . Notice that must be an ancestor of ( could be the same as ). Let be the parse tree for . Then, the tree must contain as well because it contains and in a formula there is a unique path from any gate to the root. There are two cases:
The gate is an input gate: In this case, because a monomial cannot have two different vertices of the same color and is present in .
The gate is a multiplication gate: In this case, the vertex must appear in both subtrees of . If the vertex appears in the right (left) subtree of , then we replace the left (right) subtree of with the left (right) subtree of . Otherwise, the vertex appears outside in . In this case, we replace the subtree with the subtree .
In all cases, we obtain a monomial that contains both vertices and . A contradiction. Therefore, at most monomials of the polynomial can contain the gate in their parse tree. Since there are a total of monomials, the lower bound follows.
In Figure 3, we can infer using the above argument that the input gate can be a part of parse trees of at most different monomials. ∎
We show how to use our characterizations to prove superpolynomial separations between various monotone models. The polynomials are not based on fixed pattern graphs but a natural extension of our polynomials to patterns that grow in size with the host graph.
(Compare [HY16, Theorem 1, Proposition 13]) For any and , there is a polynomial family of degree on variables such that the family has linear size monotone circuits but require size monotone ABPs.
The polynomial in the family is simply . The upper bound follows from the fact that (See Fact 2) is a tree and the construction in [DST02] (See also [BKS18]). The lower bound follows from the fact that . This is slightly better than the separation shown by Hrubes and Yehudayoff [HY16] because for the polynomial family they use to obtain this separation, they only show super-linear circuit upper bounds and the constant factor in the exponent in the lower bound is worse. ∎
(See [SNI80, Theorem 3.2]) For , there is a polynomial family of degree on variables such that the family has linear size monotone ABPs but require size monotone formulas.
The polynomial in the family is simply . The upper bound follows from the fact that has pathwidth and the construction in [DST02] (See also [BKS18]). The lower bound follows from the fact that . We note that Snir [SNI80] used the same polynomial by looking at although he only considered one entry of . The polynomial is the entry of the matrix obtained by multiplying matrices of order where each entry of each matrix is a fresh variable. The polynomial is the sum of all entries. ∎
We now do an analysis of lower bound techniques that work by showing that a “large” number of monomials have to be distributed across a “large” number of addition gates. We also show that unlike Schnorr’s method, we can always lower bound the number of addition gates in a monotone circuit using such an approach. The following proof is an adaptation of the corresponding proof for Boolean circuits .
Let be a polynomial such that any monotone circuit computing it must have addition gates. Then, we prove that given , we can construct a bijection , where is a set of monomials in and is the set of all addition gates in and each monomial is mapped to an addition gate in some parse tree for the monomial.
Suppose that is optimal, i.e., has exactly addition gates. Construct a bipartite graph where one side is the set of all addition gates in and the other side is the set of all monomials in . Add edge if and only if appears in some parse tree for . Now, a bijection can be constructed from a matching of size in this graph. By Hall’s theorem, the only way this can fail to exist is if there are addition gates such that only or fewer monomials have parse trees that contain these gates (say ). If , then this means there is an unused addition gate in the circuit. This contradicts the assumption that is optimal. Otherwise, remove these gates from . The polynomial computed by this new circuit is for some constants . But can be computed using addition gates. We will need one more addition gate to add this back to get the original polynomial . This new circuit has only addition gates, a contradiction to the optimality of . ∎
Therefore, one can always build a lower bound proof by constructing the set of monomials and an appropriate function from an arbitrary optimal circuit for the given polynomial. However, unlike Schnorr’s method, this approach is not very concrete. The method used to come up with and may vary considerably depending on the polynomial.
In this section, we obtain algorithms for subgraph isomorphism problems that are simultaneously time and space-efficient. All algorithms follow from theorems in Bläser, Komarath, and Sreenivasaiah [BKS18] and the observation that all constructions in the previous section can be performed in logarithmic space. Evaluating the formulas for homomorphism polynomials require only space because they are logarithmic depth and all values are polynomially bounded. We note that fast matrix multiplication based algorithms yield better running times for all problems considered in this section. However, such algorithms use polynomial space. Algorithms that do not use fast matrix multiplication, called combinatorial algorithms, are also widely studied (See [VW09, FLR+12, CDM17, BKS18]). We use the following well-known fact.
All graphs other than on or fewer vertices has treedepth at most .
For any -vertex pattern graph other than , there is a combinatorial algorithm that runs in time and space that computes the number of subgraphs isomorphic to the pattern graph in a given -vertex host graph.
The key idea is that the number of subgraphs isomorphic to can be expressed as a linear combination of the number of homomorphisms of and patterns on fewer than vertices. More details can be found in Theorem 7.3 of [BKS18]. ∎
For any -vertex pattern graph other than , there is a combinatorial algorithm that runs in time and space that decides whether the pattern graph appears as an induced subgraph in a given -vertex host graph.
The key idea is that the number of induced subgraphs isomorphic to can be expressed as a linear combination of the number of subgraphs isomorphisms from -vertex supergraphs of . We can compute all of these numbers except for in the given time and space. The coefficient of the number of subgraphs isomorphisms of in this linear combination is always a number greater than . Therefore, by choosing a suitable prime , we can count the number of induced subgraphs isomorphic to modulo in the given time and space. The induced subgraph isomorphism problem randomly reduces to this problem using a simple reduction that only takes linear time and logarithmic space. More details can be found in Corollary 7.6 of [BKS18]. ∎
We prove a theorem that connects algorithms that count induced subgraph isomorphisms for any -vertex pattern to algorithms that count -cliques. The motivation behind this theorem is the question posed by [FKL+15b] asking whether some induced patterns are easier than others.
If there is a vertex pattern graph such that we can count the number of induced subgraph isomorphisms from the pattern to a given vertex host graph in time and space , then we can count the number of -cliques in a given vertex host graph in time and space .
The number of induced subgraph isomorphisms for any -vertex pattern can be expressed as a linear combination of the number of subgraph isomorphisms of -vertex supergraphs of . We can compute every number in the linear combination except the number of subgraph isomorphisms of in time and space. Given that we can also count the number of induced subgraph isomorphisms of in time and space, the result follows. More details can be found in Theorem 7.5 of [BKS18]. ∎
- [ADH+08] (2008) Biomolecular network motif counting and discovery by color coding. In Proceedings 16th International Conference on Intelligent Systems for Molecular Biology (ISMB), Toronto, Canada, July 19-23, 2008, pp. 241–249. External Links: Cited by: §1.
- [BS83] (1983) The complexity of partial derivatives. Theor. Comput. Sci. 22, pp. 317–330. External Links: Cited by: §1.
- [BKS18] (2018) Graph pattern polynomials. See 38th IARCS annual conference on foundations of software technology and theoretical computer science, FSTTCS 2018, december 11-13, 2018, ahmedabad, india, Ganguly and Pandya, pp. 18:1–18:13. External Links: Cited by: 5th item, §1.1, §1.1, §1.2, §1, §1, §1, §3, §3, §3, §3, §4, §4, §4, §4.
- [BB02] (2002) Mining molecular fragments: finding relevant substructures of molecules. In 2002 IEEE International Conference on Data Mining, 2002. Proceedings., Vol. , pp. 51–58. Cited by: §1.
- [BCL+06] (2006) Counting graph homomorphisms. In Topics in discrete mathematics, pp. 315–371. Cited by: §1.
- [CLV19] (2019) Variants of homomorphism polynomials complete for algebraic complexity classes. In Computing and Combinatorics - 25th International Conference, COCOON 2019, Xi’an, China, July 29-31, 2019, Proceedings, Lecture Notes in Computer Science, Vol. 11653, pp. 90–102. External Links: Cited by: §1.
- [CGW89] (1989) Quasi-random graphs. Combinatorica 9 (4), pp. 345–362. External Links: Cited by: §1.
- [CDM17] (2017) Homomorphisms are a good basis for counting small subgraphs. See Proceedings of the 49th annual ACM SIGACT symposium on theory of computing, STOC 2017, montreal, qc, canada, june 19-23, 2017, Hatami et al., pp. 210–223. External Links: Cited by: 5th item, §1, §4, footnote 3.
- [DJ04] (2004) The complexity of counting homomorphisms seen from the other side. Theoret. Comput. Sci. 329 (1-3), pp. 315–323. External Links: Cited by: §1.
- [DST02] (2002) Counting h-colorings of partial k-trees. Theor. Comput. Sci. 281 (1-2), pp. 291–309. External Links: Cited by: §1.1, §1.1, §1.2, §1, §1, §3, §3, §3, §3.
- [DIE06] (2006) Graph theory. Electronic library of mathematics, Springer. External Links: Cited by: §2.
- [DMM+16] (2016) Homomorphism polynomials complete for VP. Chic. J. Theor. Comput. Sci. 2016. External Links: Cited by: §1.
- [FKL+15a] (2015) Detecting and counting small pattern graphs. SIAM J. Discrete Math. 29 (3), pp. 1322–1339. External Links: Cited by: §1, §1, §1.
- [FKL+15b] (2015) Induced subgraph isomorphism: are some patterns substantially easier than others?. Theor. Comput. Sci. 605, pp. 119–128. External Links: Cited by: §4.
- [FLR+12] (2012) Faster algorithms for finding and counting subgraphs. J. Comput. Syst. Sci. 78 (3), pp. 698–706. External Links: Cited by: §4.
- [FMS+19] (2019) Nonnegative Rank Measures and Monotone Algebraic Branching Programs. In 39th IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS 2019), A. Chattopadhyay and P. Gastin (Eds.), Leibniz International Proceedings in Informatics (LIPIcs), Vol. 150, Dagstuhl, Germany, pp. 15:1–15:14. Note: Keywords: Elementary symmetric polynomials, lower bounds External Links: Cited by: §1.2.
- [GP18] S. Ganguly and P. K. Pandya (Eds.) (2018) 38th IARCS annual conference on foundations of software technology and theoretical computer science, FSTTCS 2018, december 11-13, 2018, ahmedabad, india. LIPIcs, Vol. 122, Schloss Dagstuhl - Leibniz-Zentrum für Informatik. External Links: Cited by: BKS18.
- [GRE12] (2012) An upper bound for the permanent versus determinant problem. Cited by: §1.
H. Hatami, P. McKenzie, and V. King (Eds.) (2017)
Proceedings of the 49th annual ACM SIGACT symposium on theory of computing, STOC 2017, montreal, qc, canada, june 19-23, 2017. ACM. External Links: Cited by: CDM17.
- [HY16] (2016) On isoperimetric profiles and computational complexity. In 43rd International Colloquium on Automata, Languages, and Programming, ICALP 2016, July 11-15, 2016, Rome, Italy, pp. 89:1–89:12. External Links: Cited by: 1st item, 3rd item, §1.2, §1, §3, Theorem 7.
- [IND15] P. Indyk (Ed.) (2015) Proceedings of the twenty-sixth annual ACM-SIAM symposium on discrete algorithms, SODA 2015, san diego, ca, usa, january 4-6, 2015. SIAM. External Links: Cited by: WWW+15.
- [JS82] (1982-07) Some exact complexity results for straight-line computations over semirings. J. ACM 29 (3), pp. 874–897. External Links: Cited by: §1.2, §1.2.
- [KKM00] (2000) Finding and counting small induced subgraphs efficiently. Inf. Process. Lett. 74 (3-4), pp. 115–121. External Links: Cited by: §1, §1, §1.
- [KZY13] (2013) Inferring anchor links across multiple heterogeneous social networks. In Proceedings of the 22nd ACM International Conference on Information & Knowledge Management, CIKM ’13, New York, NY, USA, pp. 179–188. External Links: Cited by: §1.
- [KLL13] (2013) Counting and detecting small subgraphs via equations. SIAM J. Discrete Math. 27 (2), pp. 892–909. External Links: Cited by: §1, §1, §1.
- [KR20] (2020) Tree-depth and the formula complexity of subgraph isomorphism. CoRR abs/2004.13302. External Links: Cited by: 5th item, §1, §1, Remark 1.
- [LRR17] (2017) On the ac complexity of subgraph isomorphism. SIAM J. Comput. 46 (3), pp. 936–971. External Links: Cited by: §1, §1, Remark 1.
- [LPH+20] (2020) Neural subgraph isomorphism counting. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD ’20, New York, NY, USA, pp. 1959–1969. External Links: Cited by: §1.
- [LS08] (2008) Generalized quasirandom graphs. J. Combin. Theory Ser. B 98 (1), pp. 146–163. External Links: Cited by: §1.
- [LOV12] (2012) Large networks and graph limits. American Mathematical Society Colloquium Publications, Vol. 60, American Mathematical Society, Providence, RI. External Links: Cited by: §1.
- [MS18] (2018) Some complete and intermediate polynomials in algebraic complexity theory. Theory Comput. Syst. 62 (3), pp. 622–652. External Links: Cited by: §1.1, §1.1, §1.2, §1, §1.
- [MP14] (2014) Everything you always wanted to know about the parameterized complexity of subgraph isomorphism (but were afraid to ask). In 31st International Symposium on Theoretical Aspects of Computer Science (STACS 2014), STACS 2014, March 5-8, 2014, Lyon, France, E. W. Mayr and N. Portier (Eds.), LIPIcs, Vol. 25, pp. 542–553. External Links: Cited by: §1.
- [MAR10] (2010) Can you beat treewidth?. Theory Comput. 6, pp. 85–112. External Links: Cited by: §1.
- [MSI+02] (2002) Network motifs: simple building blocks of complex networks. Science 298 (5594), pp. 824–827. External Links: Cited by: §1.
- [NP85] (1985) On the complexity of the subgraph problem. Commentationes Mathematicae Universitatis Carolinae 026 (2), pp. 415–419 (eng). External Links: Cited by: footnote 3.
- [NIS91] (1991) Lower bounds for non-commutative computation. In Proceedings of the Twenty-Third Annual ACM Symposium on Theory of Computing, STOC ’91, New York, NY, USA, pp. 410–418. External Links: Cited by: §1.2.
- [ROS18] (2018) Lower bounds for subgraph isomorphism. In Proceedings of the International Congress of Mathematicians—Rio de Janeiro 2018. Vol. IV. Invited lectures, pp. 3425–3446. External Links: Cited by: §1.
- [SAP15] (2015) A survey of lower bounds in arithmetic circuit complexity. Github survey. Cited by: §1.
-  Personal communication. Cited by: §3.
- [SCH76] (1976) A lower bound on the number of additions in monotone computations. Theoretical Computer Science 2 (3), pp. 305 – 315. External Links: Cited by: 4th item, §1.2, §1.2, §1, §3, §3.
- [SNI80] (1980) On the size complexity of monotone formulas. In Automata, Languages and Programming, J. de Bakker and J. van Leeuwen (Eds.), Berlin, Heidelberg, pp. 621–631. External Links: Cited by: 2nd item, 3rd item, §1.2, §1, §3, Theorem 8.
- [VW09] (2009) Finding, minimizing, and counting weighted subgraphs. In Proceedings of the Forty-First Annual ACM Symposium on Theory of Computing, STOC ’09, New York, NY, USA, pp. 455–464. External Links: Cited by: §4.
- [WES00] (2000-09) Introduction to graph theory. 2 edition, Prentice Hall. External Links: Cited by: §2.
- [WWW+15] (2015) Finding four-node subgraphs in triangle time. See Proceedings of the twenty-sixth annual ACM-SIAM symposium on discrete algorithms, SODA 2015, san diego, ca, usa, january 4-6, 2015, Indyk, pp. 1671–1680. External Links: Cited by: §1, §1, §1.
- [YEH19] (2019) Separating monotone vp and vnp. In Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing, STOC 2019, New York, NY, USA, pp. 425–429. External Links: Cited by: §1.2, §1.
- [ZWc.] (Dec. 15 2010. US Patent App. 12/968,786) Targeting social advertising to friends of users who have interacted with an object associated with the advertising. Cited by: §1.
- [ZYL+17] (2017) Meta-graph based recommendation fusion over heterogeneous information networks. In KDD, pp. 635–644. External Links: Cited by: §1.