Abstract 1 Complexity Lower Bounds 2 Proof Ideas 3 Preliminaries 4 Circuit Lower Bounds 5 Matrices of High Rigidity 6 Tensors of High Rank References

Conditional Complexity Hardness: Monotone Circuit Size, Matrix Rigidity, and Tensor Rank

Nikolai Chukhin Neapolis University Pafos, Cyprus
JetBrains Research, Pafos, Cyprus
Alexander S. Kulikov ORCID JetBrains Research, Pafos, Cyprus Ivan Mihajlin JetBrains Research, Pafos, Cyprus Arina Smirnova Neapolis University Pafos, Cyprus
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 ω(n).

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 Σ2Π2, 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 2n time. Belova et al. (SODA 2024) proved that there exists an explicit polynomial family of arithmetic circuit size Ω(nδ), for any δ>0, assuming that 𝖬𝖠𝖷-3-𝖲𝖠𝖳 cannot be solved faster than in 2n 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 k, k-𝖲𝖠𝖳 cannot be solved in input-oblivious co-nondeterministic time O(2(1/2+ε)n), then there exists a monotone Boolean function family in 𝖼𝗈𝖭𝖯 of monotone circuit size 2Ω(n/logn). Combining this with the result above, we get win-win circuit lower bounds: either 𝖤𝖭𝖯 requires series-parallel circuits of size ω(n) or 𝖼𝗈𝖭𝖯 requires monotone circuits of size 2Ω(n/logn).

  • If, for all ε>0, 𝖬𝖠𝖷-3-𝖲𝖠𝖳 cannot be solved in co-nondeterministic time O(2(1ε)n), 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 n1+Δ, for some Δ>0.

Keywords and phrases:
computational complexity, circuit complexity, lower bounds, conditional lower bounds, monotone circuits, matrix rigidity, tensor rank, arithmetic circuits, fine-grained complexity
Copyright and License:
[Uncaptioned image] © Nikolai Chukhin, Alexander S. Kulikov, Ivan Mihajlin, and Arina Smirnova; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Problems, reductions and completeness
Related Version:
Full Version: https://eccc.weizmann.ac.il/report/2025/038 [28]
Acknowledgements:
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ắng

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 O(nk), for any k>1, 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 A cannot be solved in polynomial-time, then B 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 A into an instance of B. 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 O(2(1ε)n), for any ε>0, then the Orthogonal Vectors problem cannot be solved in time O(n2ε), for any ε>0. 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 T(n), then it can also be solved by circuits of size O(T(n)logT(n)) [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 Ω(2n/n). 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 ω(n). 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 𝖬𝖠𝖷-k-𝖲𝖠𝖳 cannot be solved in co-nondeterministic time O(2(1ε)n), for any ε>0, then, for any δ>0, there exists an explicit polynomial family that cannot be computed by arithmetic circuits of size O(nδ). Also, Williams [103] proved that if the Orthogonal Vectors conjecture (𝖮𝖵𝖢) holds, then Boolean Inner Product on n-bit vectors cannot be computed by 𝖤𝖳𝖧𝖱𝖤𝖳𝖧𝖱 circuits of size 2εn, for some ε>0. 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 2Ω(n/logn) monotone circuit lower bounds (improving best known bounds of the form 2Ω(n)) under an assumption that 𝖲𝖠𝖳 requires co-nondeterministic time O(2(1/2+ε)n) if the verifier is given a proof that depends only on the length of the input.

Theorem 1.

If, for some ε>0 and k3, k-𝖲𝖠𝖳 cannot be solved in input-oblivious co-nondeterministic time O(2(1/2+ε)n), then there exists a monotone Boolean function family in 𝖼𝗈𝖭𝖯 of monotone circuit size 2Ω(n/logn).

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 2Ω(n/logn).

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. 1.

    𝖤𝖭𝖯 requires series-parallel circuits of size ω(n);

  2. 2.

    There exists a monotone Boolean function family in 𝖼𝗈𝖭𝖯 of monotone circuit size 2Ω(n/logn).

Each of these lower bounds is far from what is currently known: the best known circuit lower bound for 𝖤𝖭𝖯 is 3.1no(n) [66], whereas the best known monotone circuit lower bound for 𝖼𝗈𝖭𝖯 is 2Ω(n) (see Section 1.2).

Another result in this direction demonstrates how to derive circuit lower bounds from 𝖭𝖤𝖳𝖧 (which asserts that 3-𝖲𝖠𝖳 cannot be solved in co-nondeterministic time 2o(n)). Specifically, we establish lower bounds for the classes Qtn.

Definition 4.

Let Qtn denote the set of all Boolean functions f over n variables such that for any x1,,xtf1(0), there exists an i[n] for which xi1==xit=0.

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 Qtn coincides precisely with the set of functions f for which there exists a circuit C, composed solely of 𝖳𝖧𝖱l+1lt+1 gates for arbitrary l1, such that Cf [29, 64]111By Cf, we mean that C(x)f(x) for all inputs x..

Our result indicates that Qtn contains functions that are exponentially hard to represent using 𝖳𝖧𝖱l+1lt+1 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. 1.

    𝖤𝖭𝖯 requires circuits of size ω(n);

  2. 2.

    For any t=ω(1), there exists a function fQtn𝖯/𝗉𝗈𝗅𝗒 such that any circuit Cf, composed only of 𝖳𝖧𝖱l+1lt+1 gates for arbitrary l1 over variables, has size 2Ω(n). Moreover, f 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 2n.

Theorem 6.

If, for every ε>0, 𝖬𝖠𝖷-3-𝖲𝖠𝖳 cannot be solved in co-nondeterministic time O(2(1ε)n), then, for all δ>0, there is a generator g:{0,1}logO(1)k𝔽k×k computable in time polynomial in k such that, for infinitely many k, there exist a seed s for which g(s) has k12δ-rigidity k2δ.

Our third result extends the second result by including high-rank tensors.

Theorem 7.

If, for any ε>0, 𝖬𝖠𝖷-3-𝖲𝖠𝖳 cannot be solved in co-nondeterministic time O(2(1ε)n), then, for all δ>0 and some Δ>0, there are two generators g1:{0,1}logO(1)k𝔽k×k and g2:{0,1}logO(1)k𝔽k×k×k computable in time polynomial in k such that, for infinitely many k, at least one of the following is satisfied:

  • g1(s) has k1δ-rigidity k2δ, for some s;

  • rank(g2(s)) is at least k1+Δ, for some s.

It is worth noting that [12] showed circuit lower bounds under the same assumption: if 𝖬𝖠𝖷-k-𝖲𝖠𝖳 cannot be solved in co-nondeterministic time O(2(1ε)n) for any ε>0, then for any δ>0, there exists an explicit polynomial family that cannot be computed by arithmetic circuits of size O(nδ).

The best known lower bound for the size of depth-three circuits computing an explicit Boolean function is 2Ω(n) [51, 75]. Proving a 2ω(n) lower bound for this restricted circuit model remains a challenging open problem and it is known that a lower bound as strong as 2ω(n/loglogn) would give an ω(n) 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 T is an n×n matrix of r-rigidity r3, then the corresponding bilinear function requires canonical circuits of size 2Ω(r) [42]. Goldreich and Tal [41] showed that a random Toeplitz matrix has r-rigidity n3r2logn, which implies a 2Ω(n3/5) lower bound on canonical depth-three circuits for an explicit function. By substituting n2/3δ-rigidity for some δ>0 in Theorem 7, one gets the following result.

Corollary 8.

If, for every ε>0, 𝖬𝖠𝖷-3-𝖲𝖠𝖳 cannot be solved in co-nondeterministic time O(2(1ε)n), then, for any δ>0, one can construct an explicit family of 2logO(1)n functions such that, for infinitely many n, at least one of them is either bilinear and requires canonical circuits of size 2Ω(n2/3δ) or trilinear and requires arithmetic circuits of size Ω(n1.25).

This conditionally improves the recent result of Goldreich [40], who presented an O(1)-linear function that requires canonical depth-two circuits of size 2Ω(n1ε), for every ε>0. Moreover, every bilinear function can be computed by canonical circuits of size 2O(n2/3), 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 nΩ(logn) on monotone circuit size obtained by the approximation method (which was recently improved to 2nΩ(1) [23]). Subsequently, Andreev [9] proved a 2n1/8o(1) 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 2n1/2o(1). 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 F is hard to refute in the resolution proof system, then a monotone function associated with F has large monotone circuit complexity. In this manner, following the work of [39, 44, 71], the lower bound of 2Ω(n) was also achieved. Just recently, Blasiok and Meierhöfer [20] established the lower bound 2Ω(n) for the Clique problem.

Proving a 2ω(n1/2) lower bound remains a challenging open problem (whereas a lower bound 2Ω(n) 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 M over a field 𝔽 has r-rigidity s if for any matrices R,S over a field 𝔽 such that M=R+S and rank(R)r, S has at least s nonzero entries. That is, one needs to change at least s elements in M to change its rank down to at most r. 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 M has εn-rigidity n1+δ for some ε,δ>0, then the bilinear form of M cannot be computed by arithmetic circuits of size O(n) and depth O(logn). Following Razborov [86], Wunderlich [104] proved that the existence of strongly-explicit matrices with 2(loglogn)ω(1)-rigidity δn2, for some δ>0, implies the existence of a language that does not belong to the communication complexity analog of 𝖯𝖧. Although it is known [96] that for any r almost every n×n matrix has r-rigidity Ω((nr)2logn) 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 r-rigidity n2rlog(n/r) for any r, which was proved by Shokrollahi, Spielman and Stemann [89]. Goldreich and Tal [41] proved that a random n×n Toeplitz matrix over 𝔽2 (i.e., a matrix of the form Ai,j=aij for random bits a(n1),,an1) has r-rigidity n3r2logn for rn. However, the size of that family is exponential in n. Our Theorem 6 demonstrates that, under the assumption that 𝖬𝖠𝖷-3-𝖲𝖠𝖳 is hard, for any δ>0, for infinitely many n one can construct a 2logO(1)n-sized family of n×n matrices with at least one having n1/2δ-rigidity n2δ.

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 r<n and improves the result of Goldreich and Tal [41] by substantially reducing the family size while maintaining the same rigidity for rn. 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 δ>0 such that one can construct n×n matrices with 2logn/Ω(loglogn)-rigidity δn2 in FNP. Subsequently, Chen and Lyu [26] demonstrated a method for constructing highly rigid matrices, proving that there exists a constant δ>0 such that one can construct n×n matrices with 2log1δn-rigidity (1/2exp(log2/3δn))n2 in 𝖯𝖭𝖯. More recently, Alman and Liang [4] showed that the Walsh-Hadamard matrix Hn has c1logn-rigidity n2(12nc2) for some constants c1,c2>0. Our construction, in the class 𝖣𝖳𝖨𝖬𝖤[2logO(1)n]𝖭𝖯, produces matrices with n12δ-rigidity n2δ for any δ>0, 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 i=1nxin requires arithmetic circuits of size Ω(nlogn), provided n does not divide the characteristic of 𝔽. Raz [82] further established that arithmetic circuits with bounded coefficients require Ω(n2logn) 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 2, exponential lower bounds are known [85, 91]. For other finite characteristics, exponential lower bounds are known only for depth 3 [46, 47]. For characteristic 0, 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 d-dimensional tensor is said to have rank q if it can be expressed as a sum of q rank-one tensors. Here, a rank-one d-dimensional tensor is a tensor of the form u1ud, where stands for a tensor product. By a multiplication tensor, we mean a tensor of size n2×n2×n2 (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 2.5n2Θ(n). Subsequently, Shpilka [90] improved the bound to 3n2o(n2) over 𝔽2. The bound 3n2o(n2) 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 d-dimensional tensors with rank 2nd2+nΘ(dlogn), 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 d-dimensional tensor is 𝖭𝖯-hard for any d3. Consequently, a major open problem is to construct an explicit family of d-dimensional tensors with rank at least nd2+ε for some ε>0 and d3.

Our Theorem 7 shows that, under an assumption that 𝖬𝖠𝖷-3-𝖲𝖠𝖳 cannot be solved fast co-nondeterministically, one gets an explicit 2logO(1)n-size family of n×n-matrices and n×n×n-tensors, such that, for any δ>0 and some Δ>0, at least one of the matrices has n1δ-rigidity n2δ or one of the tensors has rank n1+Δ. 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 ε>0, the bipartite Traveling Salesman problem cannot be solved in time 2(1ε)n, then the matrix multiplication tensor has superlinear rank. Additionally, Björklund and Kaski [17] recently proved that if, for any ε>0, there exists a k such that the k-Set Cover problem cannot be solved in time O(2(1ε)n||), then there is an explicit tensor with superlinear rank, where is a family of subsets of [n], each of size at most k. Pratt [78] improved this result, showing that under the same conjecture there exists an explicit tensor of shape n×n×n and rank at least n1.08. [16] showed that if for every ε>0 Chromatic Number problem cannot be solved in time 2(1ε)n, 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 3-𝖲𝖠𝖳 in Theorem 12 into t parts, where t=ω(1), then creating an explicit function equivalent to t-𝖮𝖵 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 2ω(n).

Moreover, the existence of small monotone circuits not only refutes 𝖭𝖲𝖤𝖳𝖧 but also establishes that 𝖴𝖭𝖲𝖠𝖳 has input-oblivious proof size 2o(n) that can be verified in time 2n2+o(n). 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 ε>0, 𝖬𝖠𝖷-3-𝖲𝖠𝖳 cannot be solved in co-nondeterministic time O(2(1ε)n), then, for all δ>0 there exists a small family of tensors of size k×k×k such that, for infinitely many k, at least one of them has rank at least k1+δ.

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 ε>0, 𝖬𝖠𝖷-3-𝖲𝖠𝖳 can be solved in co-nondeterministic time O(2(1ε)n).

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 O(2(1ε)n), for some ε>0.

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 2Ω(n/logn) for monotone circuit size of 𝖼𝗈𝖭𝖯 under 𝖭𝖲𝖤𝖳𝖧, we assume that all monotone functions from 𝖼𝗈𝖭𝖯 have monotone circuit size 2o(n/logn) and show how this can be used to solve 𝖴𝖭𝖲𝖠𝖳 nondeterministically in less than 2n steps.

Given a k-CNF F, we construct an instance (AF,BF) of 𝖮𝖵 of size 2n/2 using Theorem 12. We show (see Lemma 15) that (AF,BF) is a yes-instance if and only if there exists a monotone Boolean function separating (AF,BF¯). Hence, one can guess a small monotone circuit separating (AF,BF¯) and verify that it is correct. Overall, the resulting nondeterministic algorithm proceeds as follows.

  1. 1.

    In time O(n22n/2), generate the sets AF and BF.

  2. 2.

    Guess a monotone circuit CF of size O(2(1ε)n/2).

  3. 3.

    Verify that CF separates (AF,BF¯). To do this, check that CF(a)=1, for every aAF. Then, check that CF(b)=0, for every bBF¯. The running time of this step is

    O(2(1ε)n/2|AF|+2(1ε)n/2|BF¯|)=O(2(1ε)n/22n/2)=O(2(1ε/2)n).
  4. 4.

    If CF separates (AF,BF¯), then F𝖴𝖭𝖲𝖠𝖳.

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 𝖬𝖠𝖷-3-𝖲𝖠𝖳 cannot be solved fast co-nondeterministically, we proceed as follows. Take a 3-CNF formula over n variables and an integer t and transform it, using Theorem 14, into a 4-partite 3-uniform hypergraph G with each part of size k=nO(1)2n4. The graph G contains a 4-clique if and only if one can satisfy t clauses of F. We show that checking whether G has a 4-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 4-Clique on G in co-nondeterministic time O(k4ε): 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 𝖬𝖠𝖷-3-𝖲𝖠𝖳 faster than 2n co-nondeterministically. Thus, this reduction is a generator of rigid matrices: it takes a 3-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 k, [k]={1,2,,k}, whereas for a predicate P, [P]=1 if P is true and [P]=0 otherwise (the Iverson bracket). For a set S and an integer k, by (Sk) we denote the set of all subsets of S of size k.

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 F, by n(F) and m(F) we denote the number of variables and clauses of F, respectively. We write just n and m, 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 k-𝖲𝖠𝖳, the given formula is in k-CNF (that is, all clauses have at most k literals). In 𝖬𝖠𝖷-k-𝖲𝖠𝖳, one is given a k-CNF and an integer t and is asked to check whether it is possible to satisfy exactly t 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 (β,k)-𝖲𝖠𝖳, we denote a special case of k-𝖲𝖠𝖳 where the input k-CNF formula has at most βn clauses.

Theorem 9 (Sparsification Lemma, [58]).

For any k3 and ε>0, there exists α=α(k,ε) and an algorithm that, given a k-CNF formula F over n variables, outputs t2εn formulas F1,,Ft in k-CNF such that n(Fi)n and m(Fi)αn, for all i[t], and F𝖲𝖠𝖳 if and only if i[t]Fi𝖲𝖠𝖳. The running time of the algorithm is O(nO(1)2εn).

Corollary 10.

There exists a function β:3×>0>0 such that, if there exists ε>0 for which (β(k,ε),k)-𝖲𝖠𝖳 can be solved in time O(2n/2+εn) for any k3, then k-𝖲𝖠𝖳 can be solved in time O(2n/2+2εn).

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 ε>0, there is k such that k-𝖲𝖠𝖳 cannot be solved in time O(2(1ε)n). The Nondeterministic 𝖲𝖤𝖳𝖧 (𝖭𝖲𝖤𝖳𝖧), introduced in [22], extends 𝖲𝖤𝖳𝖧 by asserting that 𝖲𝖠𝖳 is difficult even for co-nondeterministic algorithms: for any ε>0, there is k such that k-𝖲𝖠𝖳 cannot be solved in co-nondeterministic time O(2(1ε)n). 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 ω(n). [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 ω(n).

𝖲𝖤𝖳𝖧-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 A,B{0,1}d of size n, check whether there exists aA and bB such that ab=i[d]aibi=0. It is straightforward to see that 𝖮𝖵 can be solved in time O(n2d). Williams [100] proved that under 𝖲𝖤𝖳𝖧, there is no algorithm solving 𝖮𝖵 in time O(n2εdO(1)), for any ε>0. This follows from the following reduction.

Theorem 12 ([100]).

There exists an algorithm that, given a CNF formula F with n variables and m clauses, outputs two sets AF,BF{0,1}m such that |AF|=|BF|=2n/2 and F𝖲𝖠𝖳 if and only if (AF,BF)𝖮𝖵. The running time of the algorithm is O(mn2n/2).

In a similar manner, one can reduce a CNF formula to the t-𝖮𝖵 problem involving a greater number of sets. Consider the t-𝖮𝖵 problem, where one is given t sets A1,,At{0,1}d, each of size n, and the objective is to determine whether there exist elements a1A1,,atAt such that i[d]ai1ait=0.

Lemma 13.

There exists an algorithm which, given a CNF formula F with n variables and m clauses, along with an integer t, constructs t sets AF1,,AFt{0,1}m such that |AF1|==|AFt|=2n/t and F𝖲𝖠𝖳 if and only if (AF1,,AFt)t-𝖮𝖵. The running time of the algorithm is O(mn2n/t).

The proof follows the approach presented in [100]. An instance (A1,,At)t-𝖮𝖵 if and only if for all vectors a1A1,,atAt, the vectors share a common coordinate with value one. This can equivalently be formulated by stating that the union Q=A1At possesses the property that for every a1,,atQ, the vectors share a common one. Consequently, the instance (A1,,At)t-𝖮𝖵 if and only if there exists a circuit C, composed of 𝖳𝖧𝖱l+1lt+1 gates and variables, such that C(x¯)=0 for every xA1At.

A similar reduction allows to solve 𝖬𝖠𝖷-3-𝖲𝖠𝖳 by finding a 4-clique in a 3-uniform hypergraph. A subset of l nodes in a k-hypergraph is called an l-clique, if any k of them form an edge in the graph.

Theorem 14 ([101, 69]).

There exists an algorithm that, given a 3-CNF formula F with n variables and an integer t, outputs a 4-partite 3-uniform hypergraph G with parts of size k=nO(1)2n/4 such that G has a 4-clique if and only if it is possible to satisfy exactly t clauses of F.

The proof is given in the full version [28].

3.2 Rigidity and Tensor Rank

For a field 𝔽, by 𝔽a×b we denote the set of all matrices of size a×b over 𝔽. Similarly, by 𝔽a×b×c we denote the set of all three-dimensional tensors of shape a×b×c over 𝔽. For two tensors A and B (of arbitrary shape), by AB we denote a tensor product of A and B. For a matrix M𝔽a×b, by |M| we denote the number of nonzero entries of M.

For a matrix M𝔽a×b, we say that it has r-rigidity s if it is necessary to change at least s entries of M to reduce its rank to r. That is, for each decomposition M=R+S such that rank(R)r, it holds that |S|s.

The rank of a three-dimensional tensor is a natural extension of the matrix rank. For a tensor 𝒜𝔽n×n×n, we define its rank, rank(𝒜), as the smallest integer r such that there exist r tuples of vectors al,bl,cl𝔽n for which

𝒜=l[r]alblcl,

or equivalently,

𝒜[i,j,k]=l[r]al[i]bl[j]cl[k],

for all i,j,k[n].

We denote by ω the smallest real number such that any two n×n matrices can be multiplied in time O(nω+ε) for any ε>0 using only field operations333The value of ω may depend on the field over which the calculations are performed [87]..

Consider the three-dimensional tensor 𝒜n𝔽n2×n2×n2:

𝒜n[(i,j),(i,k),(k,j)]=1,

for all i,j,k[n], with all other entries being zero. Using an approach based on the work of Strassen [92], for any positive integer k, if rank(𝒜k)=q, then one can construct an arithmetic circuit of size O(nlogk(q)) to perform multiplication of two n×n matrices. Thus, ω satisfies the following equation:

ω=infk>0logkrank(𝒜k).

In other words, for sufficiently large k, we have that rank(𝒜k)kω. Specifically, if n=k2, then 𝒜k𝔽n×n×n, and rank(𝒜k)nω/2. Therefore, if ω>2, this yields superlinear lower bounds on arithmetic circuits and on the rank of the multiplication tensor.

The best known upper bound on ω is 2.371339 [98, 3]. Further details on the matrix multiplication tensor can be found in [5, 19].

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 ε>0 and k3, k-𝖲𝖠𝖳 cannot be solved in input-oblivious co-nondeterministic time O(2(1/2+ε)n), then there exists a monotone Boolean function family in 𝖼𝗈𝖭𝖯 of monotone circuit size 2Ω(n/logn).

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. 1.

    𝖤𝖭𝖯 requires series-parallel circuits of size ω(n);

  2. 2.

    There exists a monotone Boolean function family in 𝖼𝗈𝖭𝖯 of monotone circuit size 2Ω(n/logn).

For the proof of Theorem 1, we need two technical lemmas. Recall that the reduction from 𝖲𝖠𝖳 to 𝖮𝖵 (see Theorem 12), given a formula F, produces two sets AF,BF{0,1}m(F) such that |AF|=|BF|=2n(F)/2 and F𝖲𝖠𝖳 if and only if (AF,BF)𝖮𝖵.

Lemma 15.

Let F be a CNF formula. Then, F𝖲𝖠𝖳 if and only if (AF,BF¯) can be separated by a monotone function.

For a CNF formula F, let fF:{0,1}m(F){0,1} be defined as follows:

fF(x)=[bBF¯:bx]. (1)

It is immediate that fF is monotone and that BF¯fF1(0).

Proof of Lemma 15.

Assume that F𝖲𝖠𝖳. We show that the function fF separates (AF,BF¯). To do this, it suffices to show that AFfF1(1). If this is not the case, then there is aAF such that fF(a)=0, that is, there exists bBF¯ such that ba. Hence, there is no i[m] such that bi=0 and ai=1. In turn, this means that, for b¯BF, there is no i[m] such that b¯i=1 and ai=1, meaning that (AF,BF)𝖮𝖵, contradicting F𝖲𝖠𝖳.

For the reverse direction, assume that for some monotone function h:{0,1}m{0,1}, it holds that AFh1(1) and BF¯h1(0). By the monotonicity of h, for every aAF and every bBF¯, ba. Hence, for every aAF and every bBF¯, there exists i[m] such that bi=0 and ai=1. Switching from BF¯ to BF, we get that, for every aAF and every bBF, there exists i[m] such that bi=1 and ai=1, meaning that (AF,BF)𝖮𝖵 and F𝖲𝖠𝖳. Note that the function fF can be viewed as a monotone unsatisfiability certificate for F. Such functions have been studied in proof complexity; see Hrubeš–Pudlák [56].

By n,k,β denote the set of k-CNF formulas with n variables and at most βn clauses. Any formula Fn,k,β can be encoded in binary using at most γnlogn bits (for some γ=γ(k,β)): each variable is encoded using logn bits, all other symbols (parentheses as well as negations, disjunctions, and conjunctions require a constant number of bits). Hence,

|n,k,β|2γnlogn.

Let us call 𝒲n,k the set of all binary strings of length n and weight k:

𝒲n,k={x{0,1}n:w(x)=k}.

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 e:{0,1}n𝒲4n,2n such that computing and inverting e takes time linear in n.

As a simple corollary, applying Lemma 16 to Boolean formulas, one can obtain the following result.

Lemma 17.

There exists a parameter l=O(nlogn) and an injective encoding

e:n,k,β𝒲l,l/2

such that computing and inverting e takes time polynomial in n.

Proof.

Given a formula Fn,k,β, we can encode it in binary using at most γnlogn 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 N variables in 𝖼𝗈𝖭𝖯 can be computed by monotone circuits of size 2o(N/logN).

Let F be a k-CNF over n variables. Thanks to Corollary 10, we may assume that m(F)βn, where β=β(k,ε2). Then, solving n,k,β in co-nondeterministic time O(2n/2+εn) for ε=ε2 will be sufficient for a contradiction.

Below, we define a universal function f containing fF, for all Fn,k,β, as subfunctions (recall the definition (1) of fF). Let N=l+m, where l=O(nlogn) and e is the function from Lemma 17 and m=βn (hence, N=O(nlogn)). We define f:{0,1}N{0,1} as follows. Let (c,x), where c{0,1}l and x{0,1}m, be an input of f. Then,

f(c,x)={1,if w(c)>l/2,0,if w(c)<l/2,1,if w(c)=l/2 and e1(c)=,0,if w(c)=l/2 and e1(c)𝖲𝖠𝖳,fF(x),if w(c)=l/2 and F=e1(c)𝖲𝖠𝖳.

We now ensure three important properties of f.

  1. 1.

    The function f is monotone. For the sake of contradiction, assume that (c,x)(c,x), but 0=f(c,x)<f(c,x)=1. Since f(c,x)=1, w(c)l/2. If w(c)>l/2, then f(c,x)=1, since w(c)w(c)>l/2. Hence, assume that w(c)=w(c)=l/2. Since cc, we conclude that c=c (implying that e1(c)). If e1(c)𝖲𝖠𝖳, then f(c,x)=0. Hence e1(c)𝖲𝖠𝖳, thus f(c,x)=fF(x) and f(c,x)=fF(x), where F=e1(c)=e1(c), and fF is clearly monotone.

  2. 2.

    The function f is explicit: f𝖼𝗈𝖭𝖯. Assume that f(c,x)=0. This can happen for one of the three following reasons.

    • w(c)<l/2. This is easily verifiable.

    • w(c)=l/2 and e1(c)𝖲𝖠𝖳. To verify this, one computes F=e1(c) (in time O(𝗉𝗈𝗅𝗒(n)), due to Lemma 17), guesses its satisfying assignment and verifies it.

    • w(c)=l/2, F=e1(c)𝖲𝖠𝖳, and fF(x)=0. Recall that if F𝖲𝖠𝖳, then we can guess and verify its satisfying assignment, so in this case there is no need to verify the unsatisfiability of F. Since fF(x)=0, there exists bBF¯ such that bx. To verify this, one computes F=e1(c), guesses the corresponding assignment to the second half of the variables of F, ensures that it produces the vector b¯, and verifies that bx.

  3. 3.

    Assume that f can be computed by a monotone circuit C of size 2o(N/logN). We show that, then, for any k3, k-𝖲𝖠𝖳 can be solved in input-oblivious co-nondeterministic time O(2n/2+εn). Since N=O(nlogn), then size(C)=O(2εn).

    Let Fn,k,β be an unsatisfiable formula with n variables and no more than βn clauses. The following algorithm verifies its unsatisfiability in input-oblivious nondeterministic time O(2n/2+εn).

    1. (a)

      In time O(n22n/2), generate the sets AF and BF.

    2. (b)

      Guess a monotone circuit C. This can be done in time O(size(C))=O(2εn).

    3. (c)

      Compute c=e(F) and substitute the first l variables of C by c. Call the resulting circuit CF.

    4. (d)

      Verify that CF separates (AF,BF¯). To do this, check that CF(a)=1, for every aAF. Then, check that CF(b)=0, for every bBF¯. The running time of this step is

      O((|AF|+|BF¯|)size(CF))=O(2n/22εn)=O(2n/2+εn).
    5. (e)

      If CF is monotone and separates (AF,BF¯), then we are certain that F𝖲𝖠𝖳, thanks to Lemma 15.

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 O(2(1ε)n), for any ε>0, we obtain a generator of high rigidity matrices. Throughout this section, rigidity decompositions are considered over a finite field 𝔽.

See 6 The proof is given in the full version [28].

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 r-rigidity n2rlog(n/r).

Corollary 18.

If 𝖬𝖠𝖷-3-𝖲𝖠𝖳 cannot be solved in co-nondeterministic time O(20.92n), then there exists a generator g:{0,1}logO(1)k𝔽k×k computable in time polynomial in k such that, for infinitely many k, there exists a seed s for which g(s) has k0.34-rigidity k1.68.

Proof.

The generator is the one constructed in the proof of Theorem 6. Substituting r=k0.34 and s=k1.68 into the running time O(k2s+r2k3) yields the running time O(k3.68)=O(20.92n), thereby completing the proof. Note that rs=k2.02, so further weakening the assumption will result in worse rigidity than that achieved in [89].

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 qk and A,B,C𝔽q×k. Let also f:[k]3𝔽 be defined as follows:

f(i,j,m)=l[q]A[l,i]B[l,j]C[l,m].

One can compute f(i,j,m), for all (i,j,m)[k]3 simultaneously, in time O(qkω).

The proof of Lemma 19 is given in the full version [28].

Theorem 20.

Let k=nO(1)2n/4 and rk, qk. There exist functions g1:{0,1}logO(1)k𝔽k×k and g2:{0,1}logO(1)k𝔽k×k×k computable in time kO(1) such that, if, for any e, g1(e) has r-rigidity s and g2(e) has rank at most q, then, 𝖬𝖠𝖷-3-𝖲𝖠𝖳 for formulas with n variables can be solved in co-nondeterministic time

O(k2s+qr2kω1).

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 α[0.5,1] and β[1,2] be constants satisfying α5βω2. If 𝖬𝖠𝖷-3-𝖲𝖠𝖳 cannot be solved in co-nondeterministic time O(2(1ε)n), for any ε>0, then, for all δ>0, there exist functions g1:{0,1}logO(1)k𝔽k×k and g2:{0,1}logO(1)k𝔽k×k×k computable in time kO(1), such that, for infinitely many k, at least one of the following is satisfied, for at least one e:

  • g1(e) has kαδ-rigidity k2δ;

  • rank(g2(e)) is at least kβδ.

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 O(2(1ε)n) for any ε>0, then for all δ>0 there are two polynomial-time generators g1:{0,1}logO(1)k𝔽k×k and g2:{0,1}logO(1)k𝔽k×k×k such that for infinitely many k at least one of the following is satisfied:

  • g1(s) has k2ω2δ-rigidity k2δ , for some s.

  • rank(g2(s)) is at least k1+δ, for some s.

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 𝒜k of size k×k×k. If ω=2, then the statement follows from Corollary 22. If ω2+2Δ for some Δ>0, then for infinitely many k, we have rank(𝒜k)k1+δ.

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 O(20.85n), then, for some Δ>0, there exist two generators g1:{0,1}logO(1)k𝔽k×k and g2:{0,1}logO(1)k𝔽k×k×k, computable in time polynomial in k, such that, for infinitely many k, at least one of the following conditions holds:

  • g1(s) has k0.7-rigidity k1.4, for some s;

  • rank(g2(s)) is at least k1+Δ, for some s.

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 T is an n-by-n matrix that has rigidity m3 for rank m, then the corresponding bilinear function F requires canonical circuits of size exp(m).

Then, the following corollary holds. See 8

Proof.

It suffices to verify that α=23 and β=1.25 satisfy the inequalities in the statement of Theorem 21 for any possible value of ω<2.38. 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 52n2-lower bound for the rank of n×n 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-3n 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 O(1)-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 k-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. 3.1no(n) 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 n×n matrix multiplication is at least 3n222n323n. Linear Algebra and its Applications, 438(11):4500–4509, 2013.
  • [73] Alex Massarenti and Emanuele Raviolo. Corrigendum to “The rank of n×n matrix multiplication is at least 3n222n323n”. Linear Algebra and its Applications, 445:369–371, 2014.
  • [74] Jesper Nederlof. Bipartite TSP in O(1.9999n) 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 k-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 n2r 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.