Conditional Complexity Hardness: Monotone Circuit Size, Matrix Rigidity, and Tensor Rank
Abstract
Proving complexity lower bounds remains a challenging task: currently, we only know how to prove conditional uniform (algorithm) lower bounds and nonuniform (circuit) lower bounds in restricted circuit models. About a decade ago, Williams (STOC 2010) showed how to derive nonuniform lower bounds from uniform upper bounds: roughly, by designing a fast algorithm for checking satisfiability of circuits, one gets a lower bound for this circuit class. Since then, a number of results of this kind have been proved. For example, Jahanjou et al. (ICALP 2015) and Carmosino et al. (ITCS 2016) proved that if fails, then has series-parallel circuit size .
One can also derive nonuniform lower bounds from nondeterministic uniform lower bounds. Perhaps the most well-known example is the Karp–Lipton theorem (STOC 1980): if , then . Some recent examples include the following. Nederlof (STOC 2020) proved a lower bound on the matrix multiplication tensor rank under an assumption that cannot be solved faster than in time. Belova et al. (SODA 2024) proved that there exists an explicit polynomial family of arithmetic circuit size , for any , assuming that -3- cannot be solved faster than in nondeterministic time. Williams (FOCS 2024) proved an exponential lower bound for circuits under the Orthogonal Vectors conjecture. Whereas all the lower bounds above are proved under strong assumptions that might eventually be refuted, the revealed connections are of great interest and may still give further insights: one may be able to weaken the used assumptions or to construct generators from other fine-grained reductions.
In this paper, we continue developing this line of research and show how uniform nondeterministic lower bounds can be used to construct generators of various types of combinatorial objects that are notoriously hard to analyze: Boolean functions of high circuit size, matrices of high rigidity, and tensors of high rank. Specifically, we prove the following.
-
If, for some and , - cannot be solved in input-oblivious co-nondeterministic time , then there exists a monotone Boolean function family in of monotone circuit size . Combining this with the result above, we get win-win circuit lower bounds: either requires series-parallel circuits of size or requires monotone circuits of size .
-
If, for all , -3- cannot be solved in co-nondeterministic time , then there exist small families of matrices with rigidity exceeding the best known constructions as well as small families of three-dimensional tensors of rank , for some .
Keywords and phrases:
computational complexity, circuit complexity, lower bounds, conditional lower bounds, monotone circuits, matrix rigidity, tensor rank, arithmetic circuits, fine-grained complexityCopyright and License:
2012 ACM Subject Classification:
Theory of computation Problems, reductions and completenessAcknowledgements:
We are grateful to the anonymous reviewers for their many helpful comments and additional references, which helped us not only improve the writing and correct errors, but also prove stronger versions of some of our results.Editors:
Meena Mahajan, Florin Manea, Annabelle McIver, and Nguyễn Kim ThắngSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Complexity Lower Bounds
Finding the minimum time required to solve a given computational problem is a central question in computational complexity. Answering such a question for a particular problem involves proving a complexity lower bound, that is, showing that no fast algorithm can solve this problem. While the Time Hierarchy Theorem [50, 53] guarantees that there are problems in that cannot be solved in time , for any , we have no superlinear lower bounds for specific problems. For example, for , one of the most important -complete problems, we have no algorithms working significantly faster than a brute force approach and at the same time have no methods of excluding a possibility that it can be solved in linear time.
Conditional Lower Bounds
As unconditional complexity lower bounds remain elusive, the classical complexity theory allows one to prove conditional lower bounds of the following form: if a problem cannot be solved in polynomial-time, then also cannot be solved in polynomial-time. Such results are proved via reductions that are essentially algorithms: one shows how to transform an instance of into an instance of . Nowadays, hundreds of such reductions between various -hard problems are known. For instance, if cannot be solved in polynomial-time, then the Hamiltonian Cycle problem also cannot be solved in polynomial-time.
In a recently emerged area of fine-grained complexity, one aims to construct tighter reductions between problems showing that even a tiny improvement of an algorithm for one of them automatically leads to improved algorithms for the other one. For example, as proved by Williams [100], if cannot be solved in time , for any , then the Orthogonal Vectors problem cannot be solved in time , for any . Again, many reductions of this form have been developed in recent years. We refer the reader to a recent survey by Vassilevska Williams [97].
Circuit Lower Bounds
One of the reasons why proving complexity lower bounds is challenging is that an algorithm (viewed as a Turing machine or a RAM machine) is a relatively complex object: it has a memory, may contain loops, function calls (that may in turn be recursive). A related computational model of Boolean circuits has a much simpler structure (a straight-line program) and at the same time is powerful enough to model algorithms: if a problem can be solved by algorithms in time , then it can also be solved by circuits of size [76]. It turns out that proving circuit lower bounds is also challenging: while it is not difficult to show that almost all Boolean functions can be computed by circuits of exponential size only (this was proved by Shannon [88] back in 1949), for no function from , we can currently exclude the possibility that it can be computed by circuits of linear size [66, 34]. Strong lower bounds are only known for restricted models such as monotone circuits, constant-depth circuits, and formulas. Various such unconditional lower bounds can be found in the book by Jukna [61].
An important difference between algorithms and circuits is that algorithms represent a uniform model of computation (an algorithm is a program that needs to process instances of all possible lengths), whereas circuits are nonuniform: when saying that a problem can be solved by circuits, one usually means that there is an infinite collection of circuits, one circuit for every possible input length, and different circuits in this collection can, in principle, implement different programs. This makes the circuit model strictly more powerful than algorithms: on the one hand, every problem solved by algorithms can be solved by circuits of roughly the same size; on the other hand, it is not difficult to come up with a problem of small circuit size that cannot be solved by algorithms.
Connections Between Lower and Upper Bounds
Intuitively, it seems that proving complexity upper bounds should be easier than proving lower bounds. This intuition is well supported by a much higher number of results on algorithms compared to the number of results on lower bounds. Indeed, to prove an upper bound on the complexity of a problem, one designs an algorithm for the problem and analyzes it. Whereas to prove a complexity lower bound, one needs to reason about a wide range of fast algorithms (or small circuits) and to argue that none of them is able to solve the problem at hand. Perhaps surprisingly, the tasks of proving lower and upper complexity bounds are connected to each other. A classical example is Karp–Lipton theorem [62] stating that if = , then requires circuits of size . More recently, Williams [102] established a deep connection between an upper bound for Circuit SAT and circuit lower bounds. Extending his results, Jahanjou, Miles and Viola [59] proved that if is false (meaning that can be solved fast with nondeterminism), then requires series-parallel Boolean circuits of size . Such results show how to derive nonuniform lower bounds (that is, circuit lower bounds) from uniform upper bounds (algorithm upper bounds).
Even though one can simulate an algorithm using circuits with slight overhead, the converse is not true as there are undecidable languages of low circuit complexity. Recently, [12] showed results analogous to those presented herein, particularly on deriving a nonuniform lower bound from a non-randomized uniform lower bound. Specifically, they proved that if -- cannot be solved in co-nondeterministic time , for any , then, for any , there exists an explicit polynomial family that cannot be computed by arithmetic circuits of size . Also, Williams [103] proved that if the Orthogonal Vectors conjecture () holds, then Boolean Inner Product on -bit vectors cannot be computed by circuits of size , for some . Combined with the result above (since is weaker than ), it immediately leads to win-win circuit lower bounds: if fails, we have a lower bound for series-parallel circuits, otherwise we have a strong lower bound for circuits.
1.1 Our Contribution
In this paper, we derive a number of nonuniform lower bounds from uniform nondeterministic lower bounds. Our lower bounds apply to various objects that are notoriously hard to analyze: Boolean functions of high monotone circuit size, high rigidity matrices, and high rank tensors. For circuits, we get a win-win situation similar to the one by Williams.
Our first result shows how to get monotone circuit lower bounds (improving best known bounds of the form ) under an assumption that requires co-nondeterministic time if the verifier is given a proof that depends only on the length of the input.
Theorem 1.
If, for some and , - cannot be solved in input-oblivious co-nondeterministic time , then there exists a monotone Boolean function family in of monotone circuit size .
As the previous theorem uses a weaker assumption than , we get the following corollary.
Corollary 2.
If holds, then there exists a monotone Boolean function family in with monotone circuit size .
Combining this with circuit lower bounds that follow from the negation of due to [59, 22] (see Theorem 11), leads to win-win circuit lower bounds.
Corollary 3.
At least one of the following two circuit lower bounds holds:
-
1.
requires series-parallel circuits of size ;
-
2.
There exists a monotone Boolean function family in of monotone circuit size .
Each of these lower bounds is far from what is currently known: the best known circuit lower bound for is [66], whereas the best known monotone circuit lower bound for is (see Section 1.2).
Another result in this direction demonstrates how to derive circuit lower bounds from (which asserts that - cannot be solved in co-nondeterministic time ). Specifically, we establish lower bounds for the classes .
Definition 4.
Let denote the set of all Boolean functions over variables such that for any , there exists an for which .
These sets have been studied in secure multiparty computation [54, 35, 55] and from a complexity-theoretic perspective [29, 64]. It turns out that the class coincides precisely with the set of functions for which there exists a circuit , composed solely of gates for arbitrary , such that [29, 64]111By , we mean that for all inputs ..
Our result indicates that contains functions that are exponentially hard to represent using gates only while being easy to compute by regular circuits.
Corollary 5.
At least one of the following two circuit lower bounds must hold:
-
1.
requires circuits of size ;
-
2.
For any , there exists a function such that any circuit , composed only of gates for arbitrary over variables, has size . Moreover, can be computed in linear time.
Our second result shows how to construct small families of matrices with rigidity exceeding the best known constructions under an assumption that -3- requires co-nondeterministic time nearly .
Theorem 6.
If, for every , -3- cannot be solved in co-nondeterministic time , then, for all , there is a generator computable in time polynomial in such that, for infinitely many , there exist a seed for which has -rigidity .
Our third result extends the second result by including high-rank tensors.
Theorem 7.
If, for any , -3- cannot be solved in co-nondeterministic time , then, for all and some , there are two generators and computable in time polynomial in such that, for infinitely many , at least one of the following is satisfied:
-
has -rigidity , for some ;
-
is at least , for some .
It is worth noting that [12] showed circuit lower bounds under the same assumption: if -- cannot be solved in co-nondeterministic time for any , then for any , there exists an explicit polynomial family that cannot be computed by arithmetic circuits of size .
The best known lower bound for the size of depth-three circuits computing an explicit Boolean function is [51, 75]. Proving a lower bound for this restricted circuit model remains a challenging open problem and it is known that a lower bound as strong as would give an lower bound for unrestricted circuits via Valiant’s reduction [96]. One way of proving better depth-three circuit lower bounds is via canonical circuits introduced by Goldreich and Wigderson [42]. They are closely related to rigid matrices: if is an matrix of -rigidity , then the corresponding bilinear function requires canonical circuits of size [42]. Goldreich and Tal [41] showed that a random Toeplitz matrix has -rigidity , which implies a lower bound on canonical depth-three circuits for an explicit function. By substituting -rigidity for some in Theorem 7, one gets the following result.
Corollary 8.
If, for every , -3- cannot be solved in co-nondeterministic time , then, for any , one can construct an explicit family of functions such that, for infinitely many , at least one of them is either bilinear and requires canonical circuits of size or trilinear and requires arithmetic circuits of size .
This conditionally improves the recent result of Goldreich [40], who presented an -linear function that requires canonical depth-two circuits of size , for every . Moreover, every bilinear function can be computed by canonical circuits of size , so the lower bound is almost optimal and conditionally addresses Open Problem 6.5 from [41].
1.2 Known Explicit Constructions
In this section, we review known constructions of combinatorial objects (functions of high monotone circuit size, matrices of high rigidity, and tensors of high rank).
Monotone Functions
For monotone -problems (like Clique, Matching, Hamiltonian Cycle), it is natural to ask what is their monotone circuit size. A celebrated result by Razborov [84] is a lower bound of on monotone circuit size obtained by the approximation method (which was recently improved to [23]). Subsequently, Andreev [9] proved a lower bound for another explicit monotone function. Following the work of [7, 10, 60, 49], in 2020, Cavalar, Kumar, and Rossman [24] achieved the best-known lower bound of . Recently, another approach for proving monotone circuit lower bounds was developed using lower bounds from Resolution proofs and lifting theorem [39]. Specifically, if an unsatisfiable formula is hard to refute in the resolution proof system, then a monotone function associated with has large monotone circuit complexity. In this manner, following the work of [39, 44, 71], the lower bound of was also achieved. Just recently, Blasiok and Meierhöfer [20] established the lower bound for the Clique problem.
Proving a lower bound remains a challenging open problem (whereas a lower bound was recently proved by Pitassi and Robere [77] for monotone formulas). Our Corollary 2 establishes a stronger lower bound under an assumption that holds.
Matrix Rigidity
A matrix over a field has r-rigidity s if for any matrices over a field such that and , has at least nonzero entries. That is, one needs to change at least elements in to change its rank down to at most . The concept of rigidity was introduced by Valiant [96] and Grigoriev [45]. It has striking connections to areas such as computational complexity [70, 6, 2, 43], communication complexity [104], data structure lower bounds [32, 80], and error-correcting codes [30].
Valiant [96] proved that if a matrix has -rigidity for some , then the bilinear form of cannot be computed by arithmetic circuits of size and depth . Following Razborov [86], Wunderlich [104] proved that the existence of strongly-explicit matrices with -rigidity , for some , implies the existence of a language that does not belong to the communication complexity analog of . Although it is known [96] that for any almost every matrix has -rigidity over algebraically closed fields, obtaining explicit constructions of rigid matrices remains a long-standing open question. Many works have aimed at finding explicit or semi-explicit rigid matrices [37, 79, 89, 6, 31, 2, 33, 99, 15, 13]. Also, a recent line of work establishes a connection between the Range Avoidance problem and the construction of matrices with high rigidity [63, 48, 38, 25, 67].
Small explicit222A matrix or family of matrices is called explicit if it is polynomial-time constructible. families of rigid matrices can be used to prove arithmetic circuit lower bounds [96]. The best known polynomial-time constructible matrices have -rigidity for any , which was proved by Shokrollahi, Spielman and Stemann [89]. Goldreich and Tal [41] proved that a random Toeplitz matrix over (i.e., a matrix of the form for random bits ) has -rigidity for . However, the size of that family is exponential in . Our Theorem 6 demonstrates that, under the assumption that -- is hard, for any , for infinitely many one can construct a -sized family of matrices with at least one having -rigidity .
This result is still far from the regime where circuit lower bounds can be derived via Valiant’s result, but it strictly improves the polynomial-time construction [89] for any and improves the result of Goldreich and Tal [41] by substantially reducing the family size while maintaining the same rigidity for . An open question remains as to whether explicit constructions of rigid matrices exist in the class [81]. The construction provided by Goldreich and Tal [41] lies in . Following the work of Alman and Chen [2], [13] established that there exists a constant such that one can construct matrices with -rigidity in . Subsequently, Chen and Lyu [26] demonstrated a method for constructing highly rigid matrices, proving that there exists a constant such that one can construct matrices with -rigidity in . More recently, Alman and Liang [4] showed that the Walsh-Hadamard matrix has -rigidity for some constants . Our construction, in the class , produces matrices with -rigidity for any , under the condition that -3- is hard.
Tensor Rank and Arithmetic Circuits
Proving arithmetic circuit lower bounds is another important challenge in complexity theory. An arithmetic circuit over a field uses as inputs formal variables and field elements and computes in every gate either a sum or a product. As proved by Strassen [93, 94] and Baur and Strassen [11], computing requires arithmetic circuits of size , provided does not divide the characteristic of . Raz [82] further established that arithmetic circuits with bounded coefficients require gates to perform matrix multiplication over or , following the work in [83]. However, no superlinear lower bounds are known for polynomials of constant degree. For constant-depth arithmetic circuits over fields of characteristic , exponential lower bounds are known [85, 91]. For other finite characteristics, exponential lower bounds are known only for depth [46, 47]. For characteristic , Limaye, Srinivasan, and Tavenas [68] proved the first superpolynomial lower bounds for constant-depth circuits. We refer to [68, 8, 14, 36] and the references therein for recent advances in lower bounds for small-depth algebraic circuits.
Matrix multiplication is one of the fundamental problems whose arithmetic circuit size is of great interest. While many highly nontrivial algorithms for it are known (starting from Strassen [92]), we still do not have superlinear lower bounds on its arithmetic circuit complexity. Proving such lower bounds is closely related to the problem of determining the rank of tensors. A -dimensional tensor is said to have rank if it can be expressed as a sum of rank-one tensors. Here, a rank-one -dimensional tensor is a tensor of the form , where stands for a tensor product. By a multiplication tensor, we mean a tensor of size (formally defined in Section 3.2). Establishing an upper bound for the rank of the multiplication tensor provides a means of proving upper bounds for matrix multiplication via the laser method [95]. Moreover, proving a lower bound for the tensor rank would yield superlinear lower bounds for arithmetic circuits computing the polynomial defined by that tensor.
Therefore, proving lower bounds on the tensor rank provides a path to proving lower bounds for arithmetic circuits. For the rank of the matrix multiplication tensor, Bshouty [21] and Bläser [18] proved a lower bound . Subsequently, Shpilka [90] improved the bound to over . The bound was later achieved by Landsberg [65] over arbitrary fields and further slightly improved by Massarenti and Raviolo [72, 73]. Alexeev, Forbes and Tsimerman [1] constructed explicit -dimensional tensors with rank , thus improving the lower bounds on high-dimensional tensors. Nevertheless, superlinear size lower bounds for constant-degree polynomials remain unknown. Additionally, Håstad [52] established that determining the rank of a -dimensional tensor is -hard for any . Consequently, a major open problem is to construct an explicit family of -dimensional tensors with rank at least for some and .
Our Theorem 7 shows that, under an assumption that -3- cannot be solved fast co-nondeterministically, one gets an explicit -size family of -matrices and -tensors, such that, for any and some , at least one of the matrices has -rigidity or one of the tensors has rank . Furthermore, we establish a trade-off between matrix rigidity and tensor rank, see Theorem 21. Other results for proving lower bounds on tensor rank under certain assumptions are known. Nederlof [74] proved that, if for any , the bipartite Traveling Salesman problem cannot be solved in time , then the matrix multiplication tensor has superlinear rank. Additionally, Björklund and Kaski [17] recently proved that if, for any , there exists a such that the -Set Cover problem cannot be solved in time , then there is an explicit tensor with superlinear rank, where is a family of subsets of , each of size at most . Pratt [78] improved this result, showing that under the same conjecture there exists an explicit tensor of shape and rank at least . [16] showed that if for every Chromatic Number problem cannot be solved in time , then there exists an explicit tensor of superlinear rank.
1.3 Discussion and Open Problems
Many of the lower bounds mentioned above are proved under various strong assumptions (on the complexity of , -, Set Cover, Chromatic Number, Traveling Salesman). They seem much stronger than merely and might eventually be refuted. Still, the revealed reductions between problems are of great interest and may still yield further insights: one may be able to weaken the used assumptions or to construct generators from other fine-grained reductions. Moreover, as with the case of assumption, one may be able to derive interesting consequences from both an assumption and its negation leading to a win-win situation. Below, we state a few open problems in this direction.
If one were to partition - in Theorem 12 into parts, where , then creating an explicit function equivalent to - would imply lower bounds for that function under . This approach would yield a more advantageous win-win situation, as the assumption that is false gives stronger lower bounds [27].
Open Problem 1.
Prove that if is true, then there exists an explicit function of monotone complexity .
Moreover, the existence of small monotone circuits not only refutes but also establishes that has input-oblivious proof size that can be verified in time . Therefore, we believe that it may be possible to derive even stronger implications beyond merely refuting .
Another question arises regarding tensor rank. Is it possible to construct a small family of tensors with superlinear rank, assuming that -3- cannot be solved efficiently in co-nondeterministic time (this way, eliminating the dependence on rigidity from our results)?
Open Problem 2.
Prove that, if, for any , -3- cannot be solved in co-nondeterministic time , then, for all there exists a small family of tensors of size such that, for infinitely many , at least one of them has rank at least .
However, we do not know of any consequences of solving -3- faster in the co-nondeterministic setting. This makes our assumption weak and raises the question of whether it can be refuted.
Open Problem 3.
Prove that, for some , -3- can be solved in co-nondeterministic time .
On the other hand, to get a win-win situation, it would be interesting to find nontrivial consequences of the existence of such an algorithm.
Open Problem 4.
Derive new circuit lower bounds from the existence of an algorithm solving -3- in co-nondeterministic time , for some .
Structure of the Paper
The paper is organized as follows. In Section 2, we give an overview of the main proof ideas. In Section 3, we introduce the notation used throughout the paper and provide the necessary background. In Section 4, we establish the win-win circuit lower bound. In Section 5, we construct rigid matrices under an assumption that -3- cannot be solved fast co-nondeterministically. In Section 6, we construct either three-dimensional tensors with high rank or matrices with high rigidity under the same assumption. The proofs of certain statements are omitted due to the page limit. They can be found in the full version [28].
2 Proof Ideas
In this section, we give high-level ideas of the main results.
2.1 Monotone Circuit Lower Bound
To prove a lower bound for monotone circuit size of under , we assume that all monotone functions from have monotone circuit size and show how this can be used to solve nondeterministically in less than steps.
Given a -CNF , we construct an instance of of size using Theorem 12. We show (see Lemma 15) that is a yes-instance if and only if there exists a monotone Boolean function separating . Hence, one can guess a small monotone circuit separating and verify that it is correct. Overall, the resulting nondeterministic algorithm proceeds as follows.
- 1.
In time , generate the sets and .
- 2.
Guess a monotone circuit of size .
- 3.
Verify that separates . To do this, check that , for every . Then, check that , for every . The running time of this step is
- 4.
If separates , then .
This already shows how small monotone circuits could help to break , though it does not provide a single explicit function with this property. In the full proof in Section 4, we introduce such a function. We also use a weaker assumption (than ).
2.2 Rigid Matrices and High Rank Tensors
To construct matrices of high rigidity under the assumption that -- cannot be solved fast co-nondeterministically, we proceed as follows. Take a -CNF formula over variables and an integer and transform it, using Theorem 14, into a -partite -uniform hypergraph with each part of size . The graph contains a -clique if and only if one can satisfy clauses of . We show that checking whether has a -clique is equivalent to evaluating a certain expression over three-dimensional tensors. We then show that if all slices of these tensors have low rigidity, then one can solve -Clique on in co-nondeterministic time : to achieve this, one guesses a decomposition of a matrix into a sum of a low rank matrix and a matrix with few nonzero entries. The idea is that a low rank matrix can be guessed quickly as a decomposition into rank-one matrices (which are just products of two vectors), whereas the second matrix can be guessed quickly as one needs to guess the nonzero entries only. In turn, this allows one to solve -- faster than co-nondeterministically. Thus, this reduction is a generator of rigid matrices: it takes a -CNF formula and outputs a matrix. The same idea can be used to generate either tensors with high rank or matrices with high rigidity.
3 Preliminaries
For a positive integer , , whereas for a predicate , if is true and otherwise (the Iverson bracket). For a set and an integer , by we denote the set of all subsets of of size .
The definitions of Boolean circuits and arithmetic circuits are omitted due to space restrictions. They can be found in the full version [28].
3.1 SAT, MAX-SAT, OV, and Clique
For a CNF formula , by and we denote the number of variables and clauses of , respectively. We write just and , if the corresponding CNF formula is clear from the context. In (), one is given a CNF formula and the goal is to check whether it is satisfiable (unsatisfiable, respectively). In -, the given formula is in -CNF (that is, all clauses have at most literals). In --, one is given a -CNF and an integer and is asked to check whether it is possible to satisfy exactly clauses.
When designing an algorithm for , one can assume that the input formula has a linear (in the number of variables) number of clauses. This is ensured by the following Sparsification Lemma. By -, we denote a special case of - where the input -CNF formula has at most clauses.
Theorem 9 (Sparsification Lemma, [58]).
For any and , there exists and an algorithm that, given a -CNF formula over variables, outputs formulas in -CNF such that and , for all , and if and only if . The running time of the algorithm is .
Corollary 10.
There exists a function such that, if there exists for which - can be solved in time for any , then - can be solved in time .
The proof of Corollary 10 can be found in the full version [28].
The Strong Exponential Time Hypothesis (), introduced in [58, 57], asserts that, for any , there is such that - cannot be solved in time . The Nondeterministic (), introduced in [22], extends by asserting that is difficult even for co-nondeterministic algorithms: for any , there is such that - cannot be solved in co-nondeterministic time . Though both these statements are stronger than , they are known to be hard to refute: as proved by Jahanjou, Miles and Viola [59], if is false, then there exists a Boolean function family in of series-parallel circuit size . [22] noted that it suffices to refute to get the same circuit lower bound.
Theorem 11 ([59, 22]).
If is false, then there exists a Boolean function family in of series-parallel circuit size .
-based conditional lower bounds are known for a wide range of problems and input parameters. One of such problems is Orthogonal Vectors (): given two sets of size , check whether there exists and such that . It is straightforward to see that can be solved in time . Williams [100] proved that under , there is no algorithm solving in time , for any . This follows from the following reduction.
Theorem 12 ([100]).
There exists an algorithm that, given a CNF formula with variables and clauses, outputs two sets such that and if and only if . The running time of the algorithm is .
In a similar manner, one can reduce a CNF formula to the - problem involving a greater number of sets. Consider the - problem, where one is given sets , each of size , and the objective is to determine whether there exist elements such that .
Lemma 13.
There exists an algorithm which, given a CNF formula with variables and clauses, along with an integer , constructs sets such that and if and only if -. The running time of the algorithm is .
The proof follows the approach presented in [100]. An instance - if and only if for all vectors , the vectors share a common coordinate with value one. This can equivalently be formulated by stating that the union possesses the property that for every , the vectors share a common one. Consequently, the instance - if and only if there exists a circuit , composed of gates and variables, such that for every .
A similar reduction allows to solve -3- by finding a -clique in a -uniform hypergraph. A subset of nodes in a -hypergraph is called an -clique, if any of them form an edge in the graph.
Theorem 14 ([101, 69]).
There exists an algorithm that, given a -CNF formula with variables and an integer , outputs a -partite -uniform hypergraph with parts of size such that has a -clique if and only if it is possible to satisfy exactly clauses of .
The proof is given in the full version [28].
3.2 Rigidity and Tensor Rank
For a field , by we denote the set of all matrices of size over . Similarly, by we denote the set of all three-dimensional tensors of shape over . For two tensors and (of arbitrary shape), by we denote a tensor product of and . For a matrix , by we denote the number of nonzero entries of .
For a matrix , we say that it has -rigidity if it is necessary to change at least entries of to reduce its rank to . That is, for each decomposition such that , it holds that .
The rank of a three-dimensional tensor is a natural extension of the matrix rank. For a tensor , we define its rank, , as the smallest integer such that there exist tuples of vectors for which
or equivalently,
for all .
We denote by the smallest real number such that any two matrices can be multiplied in time for any using only field operations333The value of may depend on the field over which the calculations are performed [87]..
Consider the three-dimensional tensor :
for all , with all other entries being zero. Using an approach based on the work of Strassen [92], for any positive integer , if , then one can construct an arithmetic circuit of size to perform multiplication of two matrices. Thus, satisfies the following equation:
In other words, for sufficiently large , we have that . Specifically, if , then , and . Therefore, if , this yields superlinear lower bounds on arithmetic circuits and on the rank of the multiplication tensor.
4 Circuit Lower Bounds
4.1 Boolean Functions of High Monotone Circuit Size
In this section, we prove Theorem 1.
Theorem 1. [Restated, see original statement.]
If, for some and , - cannot be solved in input-oblivious co-nondeterministic time , then there exists a monotone Boolean function family in of monotone circuit size .
Combining this with Corollary 2 and Theorem 11, we get win-win circuit lower bounds. Proving any of these two circuit lower bounds is a challenging open problem.
Corollary 3. [Restated, see original statement.]
At least one of the following two circuit lower bounds holds:
-
1.
requires series-parallel circuits of size ;
-
2.
There exists a monotone Boolean function family in of monotone circuit size .
For the proof of Theorem 1, we need two technical lemmas. Recall that the reduction from to (see Theorem 12), given a formula , produces two sets such that and if and only if .
Lemma 15.
Let be a CNF formula. Then, if and only if can be separated by a monotone function.
For a CNF formula , let be defined as follows:
| (1) |
It is immediate that is monotone and that .
Proof of Lemma 15.
Assume that . We show that the function separates . To do this, it suffices to show that . If this is not the case, then there is such that , that is, there exists such that . Hence, there is no such that and . In turn, this means that, for , there is no such that and , meaning that , contradicting .
For the reverse direction, assume that for some monotone function , it holds that and . By the monotonicity of , for every and every , . Hence, for every and every , there exists such that and . Switching from to , we get that, for every and every , there exists such that and , meaning that and . Note that the function can be viewed as a monotone unsatisfiability certificate for . Such functions have been studied in proof complexity; see Hrubeš–Pudlák [56].
By denote the set of -CNF formulas with variables and at most clauses. Any formula can be encoded in binary using at most bits (for some ): each variable is encoded using bits, all other symbols (parentheses as well as negations, disjunctions, and conjunctions require a constant number of bits). Hence,
Let us call the set of all binary strings of length and weight :
The following lemma can be established using standard techniques. The proof is provided in the full version [28].
Lemma 16.
There exists an injective encoding such that computing and inverting takes time linear in .
As a simple corollary, applying Lemma 16 to Boolean formulas, one can obtain the following result.
Lemma 17.
There exists a parameter and an injective encoding
such that computing and inverting takes time polynomial in .
Proof.
Given a formula , we can encode it in binary using at most bits (as stated above). Then, applying Lemma 16, we obtain the desired result.
Proof of Theorem 1.
Assuming that has small monotone circuits, we design a fast co-nondeterministic algorithm for . Assume that all monotone functions over variables in can be computed by monotone circuits of size .
Let be a -CNF over variables. Thanks to Corollary 10, we may assume that , where . Then, solving in co-nondeterministic time for will be sufficient for a contradiction.
Below, we define a universal function containing , for all , as subfunctions (recall the definition (1) of ). Let , where and is the function from Lemma 17 and (hence, ). We define as follows. Let , where and , be an input of . Then,
We now ensure three important properties of .
-
1.
The function is monotone. For the sake of contradiction, assume that , but . Since , . If , then , since . Hence, assume that . Since , we conclude that (implying that ). If , then . Hence , thus and , where , and is clearly monotone.
-
2.
The function is explicit: . Assume that . This can happen for one of the three following reasons.
-
. This is easily verifiable.
-
and . To verify this, one computes (in time , due to Lemma 17), guesses its satisfying assignment and verifies it.
-
, , and . Recall that if , then we can guess and verify its satisfying assignment, so in this case there is no need to verify the unsatisfiability of . Since , there exists such that . To verify this, one computes , guesses the corresponding assignment to the second half of the variables of , ensures that it produces the vector , and verifies that .
-
-
3.
Assume that can be computed by a monotone circuit of size . We show that, then, for any , - can be solved in input-oblivious co-nondeterministic time . Since , then .
Let be an unsatisfiable formula with variables and no more than clauses. The following algorithm verifies its unsatisfiability in input-oblivious nondeterministic time .
-
(a)
In time , generate the sets and .
-
(b)
Guess a monotone circuit . This can be done in time .
-
(c)
Compute and substitute the first variables of by . Call the resulting circuit .
-
(d)
Verify that separates . To do this, check that , for every . Then, check that , for every . The running time of this step is
-
(e)
If is monotone and separates , then we are certain that , thanks to Lemma 15.
-
(a)
5 Matrices of High Rigidity
In this section, we show that low rigidity matrices can be utilized to solve -3- more efficiently. Thus, assuming that -3- cannot be solved in co-nondeterministic time , for any , we obtain a generator of high rigidity matrices. Throughout this section, rigidity decompositions are considered over a finite field .
As a simple corollary, one might weaken the assumption and obtain weaker matrix rigidity, while still improving the known explicit construction by [89]. Recall that [89] constructed matrices with -rigidity .
Corollary 18.
If -3- cannot be solved in co-nondeterministic time , then there exists a generator computable in time polynomial in such that, for infinitely many , there exists a seed for which has -rigidity .
Proof.
6 Tensors of High Rank
In this section, we show how to generate high rank tensors under an assumption that -3- is hard. Throughout this section, we assume that is a finite field over which rigidity and tensor decompositions are considered.
We start with the lemma that shows how one can compute the value of a specific function for all inputs using fast matrix multiplication algorithms.
Lemma 19.
Let and . Let also be defined as follows:
One can compute , for all simultaneously, in time .
Theorem 20.
Let and , . There exist functions and computable in time such that, if, for any , has -rigidity and has rank at most , then, -3- for formulas with variables can be solved in co-nondeterministic time
The proof is given in the full version [28].
The following theorem establishes a trade-off between matrix rigidity and tensor rank by applying Theorem 20.
Theorem 21.
Let and be constants satisfying . If -3- cannot be solved in co-nondeterministic time , for any , then, for all , there exist functions and computable in time , such that, for infinitely many , at least one of the following is satisfied, for at least one :
-
has -rigidity ;
-
is at least .
The proof is provided in the full version [28].
One way to balance matrix rigidity and tensor rank is to ensure that a tensor has superlinear rank while maximizing matrix rigidity, as demonstrated in the next corollary.
Corollary 22.
If -3- cannot be solved in co-nondeterministic time for any , then for all there are two polynomial-time generators and such that for infinitely many at least one of the following is satisfied:
-
has -rigidity , for some .
-
is at least , for some .
One can also improve matrix rigidity in our trade-off by conditioning on the value of . See 7
Proof.
We modify the second generator in Corollary 22 by adding a new input on which the generator will output a tensor of matrix multiplication of size . If , then the statement follows from Corollary 22. If for some , then for infinitely many , we have .
If one wants to obtain improved matrix rigidity under weaker assumptions, then the following corollary holds, similar to Corollary 18.
Corollary 23.
If -3- cannot be solved in co-nondeterministic time , then, for some , there exist two generators and , computable in time polynomial in , such that, for infinitely many , at least one of the following conditions holds:
-
has -rigidity , for some ;
-
is at least , for some .
We are now ready to prove our conditional answer to the open problem from [41]. At first, recall the result of [42].
Theorem 24 (Theorem 4.4 in [42]).
If is an -by- matrix that has rigidity for rank , then the corresponding bilinear function requires canonical circuits of size .
Then, the following corollary holds. See 8
Proof.
It suffices to verify that and satisfy the inequalities in the statement of Theorem 21 for any possible value of . Then, Theorem 24 provides the desired bound on the canonical circuit size.
References
- [1] Boris Alexeev, Michael A. Forbes, and Jacob Tsimerman. Tensor rank: Some lower and upper bounds. In CCC, pages 283–291. IEEE Computer Society, 2011. doi:10.1109/CCC.2011.28.
- [2] Josh Alman and Lijie Chen. Efficient construction of rigid matrices using an NP oracle. In FOCS, pages 1034–1055. IEEE Computer Society, 2019. doi:10.1109/FOCS.2019.00067.
- [3] Josh Alman, Ran Duan, Virginia Vassilevska Williams, Yinzhan Xu, Zixuan Xu, and Renfei Zhou. More asymmetry yields faster matrix multiplication. In SODA, pages 2005–2039. SIAM, 2025. doi:10.1137/1.9781611978322.63.
- [4] Josh Alman and Jingxun Liang. Low rank matrix rigidity: Tight lower bounds and hardness amplification. In STOC, pages 1383–1394. ACM, 2025. doi:10.1145/3717823.3718287.
- [5] Josh Alman and Virginia Vassilevska Williams. A refined laser method and faster matrix multiplication. TheoretiCS, 3, 2024. doi:10.46298/THEORETICS.24.21.
- [6] Josh Alman and R. Ryan Williams. Probabilistic rank and matrix rigidity. In STOC, pages 641–652. ACM, 2017. doi:10.1145/3055399.3055484.
- [7] Noga Alon and Ravi B. Boppana. The monotone circuit complexity of Boolean functions. Comb., 7(1):1–22, 1987. doi:10.1007/BF02579196.
- [8] Prashanth Amireddy, Ankit Garg, Neeraj Kayal, Chandan Saha, and Bhargav Thankey. Low-depth arithmetic circuit lower bounds: Bypassing set-multilinearization. In ICALP, volume 261 of LIPIcs, pages 12:1–12:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPIcs.ICALP.2023.12.
- [9] Alexander E. Andreev. A method for obtaining lower bounds on the complexity of individual monotone functions. Doklady Akademii Nauk, 282(5):1033–1037, 1985.
- [10] Alexander E. Andreev. A method for obtaining efficient lower bounds for monotone complexity. Algebra and Logic, 26(1):1–18, 1987.
- [11] Walter Baur and Volker Strassen. The complexity of partial derivatives. Theor. Comput. Sci., 22:317–330, 1983. doi:10.1016/0304-3975(83)90110-X.
- [12] Tatiana Belova, Alexander S. Kulikov, Ivan Mihajlin, Olga Ratseeva, Grigory Reznikov, and Denil Sharipov. Computations with polynomial evaluation oracle: ruling out superlinear SETH-based lower bounds. In SODA, pages 1834–1853. SIAM, 2024. doi:10.1137/1.9781611977912.73.
- [13] Amey Bhangale, Prahladh Harsha, Orr Paradise, and Avishay Tal. Rigid matrices from rectangular PCPs. SIAM J. Comput., 53(2):480–523, 2024. doi:10.1137/22M1495597.
- [14] C. S. Bhargav, Sagnik Dutta, and Nitin Saxena. Improved lower bound, and proof barrier, for constant depth algebraic circuits. ACM Trans. Comput. Theory, 16(4):23:1–23:22, 2024. doi:10.1145/3689957.
- [15] Vishwas Bhargava, Sumanta Ghosh, Mrinal Kumar, and Chandra Kanta Mohapatra. Fast, algebraic multivariate multipoint evaluation in small characteristic and applications. J. ACM, 70(6):42:1–42:46, 2023. doi:10.1145/3625226.
- [16] Andreas Björklund, Radu Curticapean, Thore Husfeldt, Petteri Kaski, and Kevin Pratt. Fast deterministic chromatic number under the asymptotic rank conjecture. In SODA, pages 2804–2818. SIAM, 2025. doi:10.1137/1.9781611978322.91.
- [17] Andreas Björklund and Petteri Kaski. The asymptotic rank conjecture and the set cover conjecture are not both true. In STOC, pages 859–870. ACM, 2024. doi:10.1145/3618260.3649656.
- [18] Markus Bläser. A -lower bound for the rank of matrix multiplication over arbitrary fields. In FOCS, pages 45–50. IEEE Computer Society, 1999.
- [19] Markus Bläser. Fast matrix multiplication. Theory Comput., 5:1–60, 2013. doi:10.4086/TOC.GS.2013.005.
- [20] Jaroslaw Blasiok and Linus Meierhöfer. Hardness of clique approximation for monotone circuits. In CCC, volume 339 of LIPIcs, pages 4:1–4:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2025. doi:10.4230/LIPIcs.CCC.2025.4.
- [21] Nader H. Bshouty. A lower bound for matrix multiplication. SIAM J. Comput., 18(4):759–765, 1989. doi:10.1137/0218052.
- [22] Marco L. Carmosino, Jiawei Gao, Russell Impagliazzo, Ivan Mihajlin, Ramamohan Paturi, and Stefan Schneider. Nondeterministic extensions of the strong exponential time hypothesis and consequences for non-reducibility. In ITCS, pages 261–270. ACM, 2016. doi:10.1145/2840728.2840746.
- [23] Bruno Pasqualotto Cavalar, Mika Göös, Artur Riazanov, Anastasia Sofronova, and Dmitry Sokolov. Monotone circuit complexity of matching. Electron. Colloquium Comput. Complex., TR25-102, 2025. URL: https://eccc.weizmann.ac.il/report/2025/102.
- [24] Bruno Pasqualotto Cavalar, Mrinal Kumar, and Benjamin Rossman. Monotone circuit lower bounds from robust sunflowers. Algorithmica, 84(12):3655–3685, 2022. doi:10.1007/S00453-022-01000-3.
- [25] Lijie Chen, Shuichi Hirahara, and Hanlin Ren. Symmetric exponential time requires near-maximum circuit size. In STOC, pages 1990–1999. ACM, 2024. doi:10.1145/3618260.3649624.
- [26] Lijie Chen and Xin Lyu. Inverse-exponential correlation bounds and extremely rigid matrices from a new derandomized XOR lemma. In STOC, pages 761–771. ACM, 2021. doi:10.1145/3406325.3451132.
- [27] Lijie Chen, Ron D. Rothblum, Roei Tell, and Eylon Yogev. On exponential-time hypotheses, derandomization, and circuit lower bounds. J. ACM, 70(4):25:1–25:62, 2023. doi:10.1145/3593581.
- [28] Nikolai Chukhin, Alexander S. Kulikov, Ivan Mihajlin, and Arina Smirnova. Conditional complexity hardness: Monotone circuit size, matrix rigidity, and tensor rank under NSETH and beyond. Electron. Colloquium Comput. Complex., TR25-038, 2025. URL: https://eccc.weizmann.ac.il/report/2025/038.
- [29] Gil Cohen, Ivan Bjerre Damgård, Yuval Ishai, Jonas Kölker, Peter Bro Miltersen, Ran Raz, and Ron D. Rothblum. Efficient multiparty protocols via log-depth threshold formulae - (extended abstract). In CRYPTO (2), volume 8043 of Lecture Notes in Computer Science, pages 185–202. Springer, 2013. doi:10.1007/978-3-642-40084-1_11.
- [30] Zeev Dvir. On matrix rigidity and locally self-correctable codes. Comput. Complex., 20(2):367–388, 2011. doi:10.1007/S00037-011-0009-1.
- [31] Zeev Dvir and Benjamin L. Edelman. Matrix rigidity and the Croot-Lev-Pach Lemma. Theory Comput., 15:1–7, 2019. doi:10.4086/TOC.2019.V015A008.
- [32] Zeev Dvir, Alexander Golovnev, and Omri Weinstein. Static data structure lower bounds imply rigidity. In STOC, pages 967–978. ACM, 2019. doi:10.1145/3313276.3316348.
- [33] Zeev Dvir and Allen Liu. Fourier and circulant matrices are not rigid. Theory Comput., 16:1–48, 2020. doi:10.4086/TOC.2020.V016A020.
- [34] Magnus Gausdal Find, Alexander Golovnev, Edward A. Hirsch, and Alexander S. Kulikov. A better-than- lower bound for the circuit complexity of an explicit function. In FOCS, pages 89–98. IEEE Computer Society, 2016. doi:10.1109/FOCS.2016.19.
- [35] Matthias Fitzi and Ueli M. Maurer. Efficient byzantine agreement secure against general adversaries. In DISC, volume 1499 of Lecture Notes in Computer Science, pages 134–148. Springer, 1998. doi:10.1007/BFB0056479.
- [36] Michael A. Forbes. Low-depth algebraic circuit lower bounds over any field. In CCC, volume 300 of LIPIcs, pages 31:1–31:16. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPIcs.CCC.2024.31.
- [37] Joel Friedman. A note on matrix rigidity. Comb., 13(2):235–239, 1993. doi:10.1007/BF01303207.
- [38] Karthik Gajulapalli, Alexander Golovnev, Satyajeet Nagargoje, and Sidhant Saraogi. Range avoidance for constant depth circuits: Hardness and algorithms. In APPROX/RANDOM, volume 275 of LIPIcs, pages 65:1–65:18. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPIcs.APPROX/RANDOM.2023.65.
- [39] Ankit Garg, Mika Göös, Pritish Kamath, and Dmitry Sokolov. Monotone circuit lower bounds from resolution. Theory Comput., 16:1–30, 2020. doi:10.4086/TOC.2020.V016A013.
- [40] Oded Goldreich. Improved bounds on the AN-complexity of -linear functions. Comput. Complex., 31(2):7, 2022. doi:10.1007/S00037-022-00224-7.
- [41] Oded Goldreich and Avishay Tal. Matrix rigidity of random Toeplitz matrices. Comput. Complex., 27(2):305–350, 2018. doi:10.1007/S00037-016-0144-9.
- [42] Oded Goldreich and Avi Wigderson. On the size of depth-three Boolean circuits for computing multilinear functions. In Computational Complexity and Property Testing, volume 12050 of Lecture Notes in Computer Science, pages 41–86. Springer, 2020. doi:10.1007/978-3-030-43662-9_6.
- [43] Alexander Golovnev, Alexander S. Kulikov, and R. Ryan Williams. Circuit depth reductions. In ITCS, volume 185 of LIPIcs, pages 24:1–24:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPIcs.ITCS.2021.24.
- [44] Mika Göös, Pritish Kamath, Robert Robere, and Dmitry Sokolov. Adventures in monotone complexity and TFNP. In ITCS, volume 124 of LIPIcs, pages 38:1–38:19. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2019. doi:10.4230/LIPIcs.ITCS.2019.38.
- [45] Dima Grigoriev. Application of separability and independence notions for proving lower bounds of circuit complexity. Journal of Soviet Mathematics, 14:1450–1457, 1980.
- [46] Dima Grigoriev and Marek Karpinski. An exponential lower bound for depth 3 arithmetic circuits. In STOC, pages 577–582. ACM, 1998. doi:10.1145/276698.276872.
- [47] Dima Grigoriev and Alexander Razborov. Exponential complexity lower bounds for depth 3 arithmetic circuits in algebras of functions over finite fields. In FOCS, pages 269–278. IEEE Computer Society, 1998. doi:10.1109/SFCS.1998.743456.
- [48] Venkatesan Guruswami, Xin Lyu, and Xiuhan Wang. Range avoidance for low-depth circuits and connections to pseudorandomness. In APPROX/RANDOM, volume 245 of LIPIcs, pages 20:1–20:21. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPIcs.APPROX/RANDOM.2022.20.
- [49] Danny Harnik and Ran Raz. Higher lower bounds on monotone size. In STOC, pages 378–387. ACM, 2000. doi:10.1145/335305.335349.
- [50] Juris Hartmanis and Richard E Stearns. On the computational complexity of algorithms. Transactions of the American Mathematical Society, 117:285–306, 1965.
- [51] Johan Håstad. Almost optimal lower bounds for small depth circuits. Adv. Comput. Res., 5:143–170, 1989.
- [52] Johan Håstad. Tensor rank is NP-complete. J. Algorithms, 11(4):644–654, 1990. doi:10.1016/0196-6774(90)90014-6.
- [53] F. C. Hennie and Richard E Stearns. Two-tape simulation of multitape turing machines. J. ACM, 13(4):533–546, 1966. doi:10.1145/321356.321362.
- [54] Martin Hirt and Ueli M. Maurer. Complete characterization of adversaries tolerable in secure multi-party computation (extended abstract). In PODC, pages 25–34. ACM, 1997. doi:10.1145/259380.259412.
- [55] Martin Hirt and Ueli M. Maurer. Player simulation and general adversary structures in perfect multiparty computation. J. Cryptol., 13(1):31–60, 2000. doi:10.1007/S001459910003.
- [56] Pavel Hrubes and Pavel Pudlák. Random formulas, monotone circuits, and interpolation. In FOCS, pages 121–131. IEEE Computer Society, 2017. doi:10.1109/FOCS.2017.20.
- [57] Russell Impagliazzo and Ramamohan Paturi. On the complexity of -SAT. J. Comput. Syst. Sci., 62(2):367–375, 2001. doi:10.1006/JCSS.2000.1727.
- [58] Russell Impagliazzo, Ramamohan Paturi, and Francis Zane. Which problems have strongly exponential complexity? J. Comput. Syst. Sci., 63(4):512–530, 2001. doi:10.1006/JCSS.2001.1774.
- [59] Hamidreza Jahanjou, Eric Miles, and Emanuele Viola. Local reduction. Inf. Comput., 261:281–295, 2018. doi:10.1016/J.IC.2018.02.009.
- [60] Stasys Jukna. Combinatorics of monotone computations. Comb., 19(1):65–85, 1999. doi:10.1007/S004930050046.
- [61] Stasys Jukna. Boolean Function Complexity - Advances and Frontiers, volume 27 of Algorithms and combinatorics. Springer, 2012. doi:10.1007/978-3-642-24508-4.
- [62] Richard M. Karp and Richard J. Lipton. Some connections between nonuniform and uniform complexity classes. In STOC, pages 302–309. ACM, 1980. doi:10.1145/800141.804678.
- [63] Oliver Korten. The hardest explicit construction. In FOCS, pages 433–444. IEEE, 2021. doi:10.1109/FOCS52979.2021.00051.
- [64] Alexander Kozachinskiy and Vladimir V. Podolskii. Multiparty Karchmer-Wigderson games and threshold circuits. Theory Comput., 18:1–33, 2022. doi:10.4086/TOC.2022.V018A015.
- [65] J. M. Landsberg. New lower bounds for the rank of matrix multiplication. SIAM J. Comput., 43(1):144–149, 2014. doi:10.1137/120880276.
- [66] Jiatu Li and Tianqi Yang. circuit lower bounds for explicit functions. In STOC, pages 1180–1193. ACM, 2022. doi:10.1145/3519935.3519976.
- [67] Zeyong Li. Symmetric exponential time requires near-maximum circuit size: Simplified, truly uniform. In STOC, pages 2000–2007. ACM, 2024. doi:10.1145/3618260.3649615.
- [68] Nutan Limaye, Srikanth Srinivasan, and Sébastien Tavenas. Superpolynomial lower bounds against low-depth algebraic circuits. J. ACM, 72(4):26:1–26:35, 2025. doi:10.1145/3734215.
- [69] Andrea Lincoln, Virginia Vassilevska Williams, and R. Ryan Williams. Tight hardness for shortest cycles and paths in sparse graphs. In SODA, pages 1236–1252. SIAM, 2018. doi:10.1137/1.9781611975031.80.
- [70] Satyanarayana V. Lokam. Complexity lower bounds using linear algebra. Found. Trends Theor. Comput. Sci., 4(1-2):1–155, 2009. doi:10.1561/0400000011.
- [71] Shachar Lovett, Raghu Meka, Ian Mertz, Toniann Pitassi, and Jiapeng Zhang. Lifting with sunflowers. In ITCS, volume 215 of LIPIcs, pages 104:1–104:24. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPIcs.ITCS.2022.104.
- [72] Alex Massarenti and Emanuele Raviolo. The rank of matrix multiplication is at least . Linear Algebra and its Applications, 438(11):4500–4509, 2013.
- [73] Alex Massarenti and Emanuele Raviolo. Corrigendum to “The rank of matrix multiplication is at least ”. Linear Algebra and its Applications, 445:369–371, 2014.
- [74] Jesper Nederlof. Bipartite TSP in time, assuming quadratic time matrix multiplication. In STOC, pages 40–53. ACM, 2020.
- [75] Ramamohan Paturi, Pavel Pudlák, Michael E. Saks, and Francis Zane. An improved exponential-time algorithm for -SAT. J. ACM, 52(3):337–364, 2005. doi:10.1145/1066100.1066101.
- [76] Nicholas Pippenger and Michael J. Fischer. Relations among complexity measures. J. ACM, 26(2):361–381, 1979. doi:10.1145/322123.322138.
- [77] Toniann Pitassi and Robert Robere. Strongly exponential lower bounds for monotone computation. In STOC, pages 1246–1255. ACM, 2017. doi:10.1145/3055399.3055478.
- [78] Kevin Pratt. A stronger connection between the asymptotic rank conjecture and the set cover conjecture. In STOC, pages 871–874. ACM, 2024. doi:10.1145/3618260.3649620.
- [79] Pavel Pudlák and Zdeněk Vavřín. Computation of rigidity of order for one simple matrix. Commentationes Mathematicae Universitatis Carolinae, 32(2):213–218, 1991.
- [80] Sivaramakrishnan Natarajan Ramamoorthy and Cyrus Rashtchian. Equivalence of systematic linear data structures and matrix rigidity. In ITCS, volume 151 of LIPIcs, pages 35:1–35:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPIcs.ITCS.2020.35.
- [81] C. Ramya. Recent progress on matrix rigidity - A survey. CoRR, abs/2009.09460, 2020. arXiv:2009.09460.
- [82] Ran Raz. On the complexity of matrix product. SIAM J. Comput., 32(5):1356–1369, 2003. doi:10.1137/S0097539702402147.
- [83] Ran Raz and Amir Shpilka. Lower bounds for matrix product in bounded depth circuits with arbitrary gates. SIAM J. Comput., 32(2):488–513, 2003. doi:10.1137/S009753970138462X.
- [84] Alexander Razborov. Lower bounds on the monotone complexity of some Boolean function. In Soviet Math. Dokl., volume 31, pages 354–357, 1985.
- [85] Alexander Razborov. Lower bounds for the size of circuits of bounded depth with basis (AND, XOR). Math. notes of the Academy of Sciences of the USSR, 41(4):333–338, 1987.
- [86] Alexander Razborov. On rigid matrices. Manuscript (in russian), 1989.
- [87] Arnold Schönhage. Partial and total matrix multiplication. SIAM J. Comput., 10(3):434–455, 1981. doi:10.1137/0210032.
- [88] Claude E. Shannon. The synthesis of two-terminal switching circuits. Bell Syst. Tech. J., 28(1):59–98, 1949. doi:10.1002/J.1538-7305.1949.TB03624.X.
- [89] Mohammad Amin Shokrollahi, Daniel A. Spielman, and Volker Stemann. A remark on matrix rigidity. Inf. Process. Lett., 64(6):283–285, 1997. doi:10.1016/S0020-0190(97)00190-7.
- [90] Amir Shpilka. Lower bounds for matrix product. SIAM J. Comput., 32(5):1185–1200, 2003. doi:10.1137/S0097539702405954.
- [91] Roman Smolensky. Algebraic methods in the theory of lower bounds for Boolean circuit complexity. In STOC, pages 77–82. ACM, 1987. doi:10.1145/28395.28404.
- [92] Volker Strassen. Gaussian elimination is not optimal. Numerische mathematik, 13(4):354–356, 1969.
- [93] Volker Strassen. Die berechnungskomplexität von elementarsymmetrischen funktionen und von interpolationskoeffizienten. Numerische Mathematik, 20:238–251, 1973.
- [94] Volker Strassen. Die berechnungskomplexität der symbolischen differentiation von interpolationspolynomen. Theor. Comput. Sci., 1(1):21–25, 1975. doi:10.1016/0304-3975(75)90010-9.
- [95] Volker Strassen. The asymptotic spectrum of tensors and the exponent of matrix multiplication. In FOCS, pages 49–54. IEEE Computer Society, 1986. doi:10.1109/SFCS.1986.52.
- [96] Leslie G. Valiant. Graph-theoretic arguments in low-level complexity. In MFCS, volume 53 of Lecture Notes in Computer Science, pages 162–176. Springer, 1977. doi:10.1007/3-540-08353-7_135.
- [97] Virginia Vassilevska Williams. On some fine-grained questions in algorithms and complexity. In Proceedings of the international congress of mathematicians: Rio de janeiro 2018, pages 3447–3487. World Scientific, 2018.
- [98] Virginia Vassilevska Williams, Yinzhan Xu, Zixuan Xu, and Renfei Zhou. New bounds for matrix multiplication: from alpha to omega. In SODA, pages 3792–3835. SIAM, 2024. doi:10.1137/1.9781611977912.134.
- [99] Ben Lee Volk and Mrinal Kumar. A polynomial degree bound on equations for non-rigid matrices and small linear circuits. ACM Trans. Comput. Theory, 14(2):6:1–6:14, 2022. doi:10.1145/3543685.
- [100] R. Ryan Williams. A new algorithm for optimal 2-constraint satisfaction and its implications. Theor. Comput. Sci., 348(2-3):357–365, 2005. doi:10.1016/J.TCS.2005.09.023.
- [101] R. Ryan Williams. Algorithms and resource requirements for fundamental problems. PhD thesis, Carnegie Mellon University, 2007.
- [102] R. Ryan Williams. Improving exhaustive search implies superpolynomial lower bounds. SIAM J. Comput., 42(3):1218–1244, 2013. doi:10.1137/10080703X.
- [103] Ryan Williams. The orthogonal vectors conjecture and non-uniform circuit lower bounds. In FOCS, pages 1372–1387. IEEE, 2024. doi:10.1109/FOCS61266.2024.00088.
- [104] Henning Wunderlich. On a theorem of Razborov. Comput. Complex., 21(3):431–477, 2012. doi:10.1007/S00037-011-0021-5.
