Exponent Of Matrix Multiplication Research Articles

Fast median computation for symmetric, orthogonal matrices under the rank distance

Biological genomes can be represented as square, symmetric, orthogonal, 0-1 matrices. It turns out that the rank distance applied to two genome matrices has a biological significance: it is related to the smallest number of basic rearrangement mutations, such as reversals, translocations, transpositions (taken with weight 2), etc. that explain the differences between the two genomes. Therefore, closer genomes will produce smaller rank distances.An important tool in this context is the median problem: given three genomes A, B, and C, find a fourth genome M that minimizes d(A,M)+d(B,M)+d(C,M). For genome matrices, the computational complexity of this problem is currently unknown. However, for orthogonal matrices, there are fast algorithms that solve it exactly.One such algorithm uses a “walk towards the median” paradigm. Starting from any of the input matrices, say, B, the algorithm produces rank-1 “steps”, which are rank-1 matrices that, added to B, decrease its rank distance to both A and C simultaneously. It can be shown that such steps always exist for orthogonal matrices, and can be found in polynomial time. The algorithm stops when no more improvement can be made, which is equivalent to saying that B lies between A and C in terms of the rank distance (the triangle inequality becomes an equality). There is an O(nω+1) algorithm implementing this idea, where ω is the matrix multiplication exponent. Here we propose a novel scheme that works for symmetric orthogonal matrices, and produces a median, also guaranteed to be symmetric, in O(nω) time.There is another O(nω) time algorithm that produces the so-called MI median, which agrees with the majority in the subspaces where A=B, B=C, or C=A, and is equal to the identity in the orthogonal complement of the sum of these subspaces. However, this algorithm produces a different median, and has only been proved to be correct for genomic matrices. The algorithm we present here is more general.

Rectilinear link diameter and radius in a rectilinear polygonal domain

We study the computation of the diameter and radius under the rectilinear link distance within a rectilinear polygonal domain of n vertices and h holes. We introduce a graph of oriented distances to encode the distance between pairs of points of the domain. This helps us transform the problem so that we can search through the candidates more efficiently. Our algorithm computes both the diameter and the radius in O(min⁡(nω,n2+nhlog⁡h+χ2)) time, where ω<2.373 denotes the matrix multiplication exponent and χ∈Ω(n)∩O(n2) is the number of edges of the graph of oriented distances. We also provide an alternative algorithm for computing the diameter that runs in O(n2log⁡n) time.

Lengths of words accepted by nondeterministic finite automata

We consider two natural problems about nondeterministic finite automata (NFA). First, given an NFA M of n states, and a length ℓ, does M accept a word of length ℓ? We show that the classic problem of triangle-free graph recognition reduces to this problem, and give an O(nω(log⁡n)1+ϵlog⁡ℓ)-time algorithm to solve it, where ω is the optimal exponent for matrix multiplication. Second, provided L(M) is finite, we consider the problem of listing the lengths of all words accepted by M. Although this problem seems like it might be significantly harder, we show that in the unary case this problem can be solved in O(nω(log⁡n)2+ϵ) time. Finally, we give a connection between NFA acceptance and the strong exponential-time hypothesis.

A simple approach to nondecreasing paths

We present a simple reduction of the problem of nondecreasing paths (with minimal last edge weight) in a directed edge-weighted graph to a reachability problem in a directed unweighted graph. The reduction yields an alternative simple method of solving the single-source nondecreasing paths problem in almost linear time. If the edge weights are integers then our algorithm can be implemented in O((n+m)log⁡log⁡n) time on the word RAM, where n and m stand for the number of vertices and edges in the input graph, respectively. By using the reduction, we obtain also a simple algorithm for the all-pairs nondecreasing paths problem. It runs in O˜(nωmin⁡{awGω,WG}) time, where awG denotes the average number of distinct weights of edges incident to the same vertex while WG stands for the total number of distinct edge weights in the input graph G, and ω is the exponent of fast matrix multiplication.

A fast randomized geometric algorithm for computing Riemann-Roch spaces

We propose a probabilistic variant of Brill-Noether's algorithm for computing a basis of the Riemann-Roch space $L(D)$ associated to a divisor $D$ on a projective nodal plane curve $\mathcal C$ over a sufficiently large perfect field $k$. Our main result shows that this algorithm requires at most $O(\max(\mathrm{deg}(\mathcal C)^{2\omega}, \mathrm{deg}(D_+)^\omega))$ arithmetic operations in $k$, where $\omega$ is a feasible exponent for matrix multiplication and $D_+$ is the smallest effective divisor such that $D_+\geq D$. This improves the best known upper bounds on the complexity of computing Riemann-Roch spaces. Our algorithm may fail, but we show that provided that a few mild assumptions are satisfied, the failure probability is bounded by $O(\max(\mathrm{deg}(\mathcal C)^4, \mathrm{deg}(D_+)^2)/\lvert \mathcal E\rvert)$, where $\mathcal E$ is a finite subset of $k$ in which we pick elements uniformly at random. We provide a freely available C++/NTL implementation of the proposed algorithm and we present experimental data. In particular, our implementation enjoys a speedup larger than 6 on many examples (and larger than 200 on some instances over large finite fields) compared to the reference implementation in the Magma computer algebra system. As a by-product, our algorithm also yields a method for computing the group law on the Jacobian of a smooth plane curve of genus $g$ within $O(g^\omega)$ operations in $k$, which equals the best known complexity for this problem.

Faster Replacement Paths and Distance Sensitivity Oracles

Shortest paths computation is one of the most fundamental problems in computer science. An important variant of the problem is when edges can fail, and one needs to compute shortest paths that avoid a (failing) edge. More formally, given a source node s , a target node t , and an edge e , a replacement path for the triple ( s , t , e ) is a shortest s - t path avoiding edge e . Replacement paths computation can be seen either as a static problem or as a data structure problem. In the static setting, a typical goal is to compute for fixed s and t , for every possible failed edge e , the length of the best replacement path around e ( replacement paths problem ). In the data structure setting, a typical goal is to design a data structure ( distance sensitivity oracle ) that, after some preprocessing, quickly answers queries of the form: What is the length of the replacement path for the triple ( s , t , e )? In this article, we focus on n -node directed graphs with integer edge weights in [− M , M ], and present improved replacement paths algorithms and distance sensitivity oracles based on fast matrix multiplication. In more detail, we obtain the following main results: • We describe a replacement paths algorithm with runtime Õ( Mn ω ), where ω &lt; 2.373 is the fast matrix multiplication exponent. For a comparison, the previous fastest algorithms have runtime õ( Mn 1+2ω /3 ) [Weimann,Yuster—FOCS’10] and, in the unweighted case, õ( n 2.5 ) [Roditty, Zwick—ICALP’05]. Our result shows that, at least for small integer weights, the replacement paths problem in directed graphs may be easier than the related all-pairs shortest paths problem, as the current best runtime for the latter is õ( M 1\4−ω n 2+1 \ 4−ω ): this is Ω ( n 2.5 ) even if ω = 2. Our algorithm also implies that the k shortest simple s - t paths can be computed in õ( kMn ω ) time. • We consider the single-source generalization of the replacement paths problem, where only the source s is fixed. We show how to solve this problem in all-pairs shortest paths time, currently õ( M 1\4−ω n 2+1\4−ω ). Our runtime reduces to õ( Mn ω ) for positive weights, hence matching our mentioned result for the simpler replacement paths case (that, however, holds also for nonpositive weights). One of the ingredients that we use is an algorithm to compute the distances from a set s of source nodes to a set T of target nodes in õ( Mn ω +| S |ṡ | T |ṡ ( Mn ) 1\4−ω ) time. This improves on a result in Yuster,Zwick—FOCS’05. • We present the first distance sensitivity oracle that achieves simultaneously subcubic preprocessing time and sublinear query time. More precisely, for a given parameter α ∈ [0,1], our oracle has preprocessing time Õ( Mn ω + 1\ 2 + Mn ω + α (4−ω) ) and query time Õ( n 1−&amp;alpha ). The previous best oracle for small integer weights has Õ( Mn ω +1−α ) preprocessing time and (superlinear) Õ( n 1+α ) query time [Weimann,Yuster-FOCS’10]. From a technical point of view, an interesting and novel aspect of our oracle is that it exploits as a subroutine our single-source replacement paths algorithm. We also present an oracle with the same preprocessing time as in Weimann,Yuster—FOCS’10 and with smaller query time õ( n 1−1−α\4−ω + n 2α ).

A New Algorithm for Fast Generalized DFTs

We give an new arithmetic algorithm to compute the generalized Discrete Fourier Transform (DFT) over finite groups G . The new algorithm uses O (∣ G ∣ ω /2 + o (1) ) operations to compute the generalized DFT over finite groups of Lie type, including the linear, orthogonal, and symplectic families and their variants, as well as all finite simple groups of Lie type. Here ω is the exponent of matrix multiplication, so the exponent ω/2 is optimal if ω = 2. Previously, “exponent one” algorithms were known for supersolvable groups and the symmetric and alternating groups. No exponent one algorithms were known, even under the assumption ω = 2, for families of linear groups of fixed dimension, and indeed the previous best-known algorithm for SL 2 (F q ) had exponent 4/3 despite being the focus of significant effort. We unconditionally achieve exponent at most 1.19 for this group and exponent one if ω = 2. Our algorithm also yields an improved exponent for computing the generalized DFT over general finite groups G , which beats the longstanding previous best upper bound for any ω. In particular, assuming ω = 2, we achieve exponent √ 2, while the previous best was 3/2.

Subquadratic Time Encodable Codes Beating the Gilbert–Varshamov Bound

We construct explicit algebraic geometry codes built from the Garcia-Stichtenoth function field tower beating the Gilbert-Varshamov bound for alphabet sizes at least 192. Messages are identied with functions in certain Riemann-Roch spaces associated with divisors supported on multiple places. Encoding amounts to evaluating these functions at degree one places. By exploiting algebraic structures particular to the Garcia-Stichtenoth tower, we devise an intricate deterministic \omega/2 < 1.19 runtime exponent encoding and 1+\omega/2 < 2.19 expected runtime exponent randomized (unique and list) decoding algorithms. Here \omega < 2.373 is the matrix multiplication exponent. If \omega = 2, as widely believed, the encoding and decoding runtimes are respectively nearly linear and nearly quadratic. Prior to this work, encoding (resp. decoding) time of code families beating the Gilbert-Varshamov bound were quadratic (resp. cubic) or worse.

Grothendieck constant is norm of Strassen matrix multiplication tensor

We show that two important quantities from two disparate areas of complexity theory --- Strassen's exponent of matrix multiplication $\omega$ and Grothendieck's constant $K_G$ --- are intimately related. They are different measures of size for the same underlying object --- the matrix multiplication tensor, i.e., the $3$-tensor or bilinear operator $\mu_{l,m,n} : \mathbb{F}^{l \times m} \times \mathbb{F}^{m \times n} \to \mathbb{F}^{l \times n}$, $(A,B) \mapsto AB$ defined by matrix-matrix product over $\mathbb{F} = \mathbb{R}$ or $\mathbb{C}$. It is well-known that Strassen's exponent of matrix multiplication is the greatest lower bound on (the log of) a tensor rank of $\mu_{l,m,n}$. We will show that Grothendieck's constant is the least upper bound on a tensor norm of $\mu_{l,m,n}$, taken over all $l, m, n \in \mathbb{N}$. Aside from relating the two celebrated quantities, this insight allows us to rewrite Grothendieck's inequality as a norm inequality \[ \lVert\mu_{l,m,n}\rVert_{1,2,\infty} =\max_{X,Y,M\neq0}\frac{|\operatorname{tr}(XMY)|}{\lVert X\rVert_{1,2}\lVert Y\rVert_{2,\infty}\lVert M\rVert_{\infty,1}}\le K_G. \] We prove that Grothendieck's inequality is unique: If we generalize the $(1,2,\infty)$-norm to arbitrary $p,q, r \in [1, \infty]$, \[ \lVert\mu_{l,m,n}\rVert_{p,q,r}=\max_{X,Y,M\neq0}\frac{|\operatorname{tr}(XMY)|}{\|X\|_{p,q}\|Y\|_{q,r}\|M\|_{r,p}}, \] then $(p,q,r )=(1,2,\infty)$ is, up to cyclic permutations, the only choice for which $\lVert\mu_{l,m,n}\rVert_{p,q,r}$ is uniformly bounded by a constant independent of $l,m,n$.

Computing the chromatic number using graph decompositions via matrix rank

Computing the smallest number q such that the vertices of a given graph can be properly q-colored, known as the chromatic number, is one of the oldest and most fundamental problems in combinatorial optimization. The q-Coloring problem has been studied intensively using the framework of parameterized algorithmics, resulting in a very good understanding of the best-possible algorithms for several parameterizations based on the structure of the graph. For example, algorithms are known to solve the problem on graphs of treewidth tw in time O⁎(qtw), while a running time of O⁎((q−ε)tw) is impossible assuming the Strong Exponential Time Hypothesis (SETH). While there is an abundance of work for parameterizations based on decompositions of the graph by vertex separators, almost nothing is known about parameterizations based on edge separators. We fill this gap by studying q-Coloring parameterized by cutwidth, and parameterized by pathwidth in bounded-degree graphs. Our research uncovers interesting new ways to exploit small edge separators.We present two algorithms for q-Coloring parameterized by cutwidth ctw: a deterministic one that runs in time O⁎(2ω⋅ctw), where ω is the square matrix multiplication exponent, and a randomized one with runtime O⁎(2ctw). In sharp contrast to earlier work, the running time is independent of q. The dependence on cutwidth is optimal: we prove that even 3-Coloring cannot be solved in O⁎((2−ε)ctw) time assuming SETH. Our algorithms rely on a new rank bound for a matrix that describes compatible colorings. Combined with a simple communication protocol for evaluating a product of two polynomials, this also yields an O⁎((⌊d/2⌋+1)pw) time randomized algorithm for q-Coloring on graphs of pathwidth pw and maximum degree d. Such a runtime was first obtained by Björklund, but only for graphs with few proper colorings. We also prove that this result is optimal in the sense that no O⁎((⌊d/2⌋+1−ε)pw)-time algorithm exists assuming SETH.

A Rank 18 Waring Decomposition of sM 〈3〉 with 432 Symmetries

The recent discovery that the exponent of matrix multiplication is determined by the rank of the symmetrized matrix multiplication tensor has invigorated interest in better understanding symmetrized matrix multiplication. Author present an explicit rank 18 Waring decomposition of and describe its symmetry group.

A General Purpose Algorithm for Counting Simple Cycles and Simple Paths of Any Length

We describe a general purpose algorithm for counting simple cycles and simple paths of any length $\ell$ on a (weighted di)graph on $N$ vertices and $M$ edges, achieving a time complexity of $O\left(N+M+\big(\ell^\omega+\ell\Delta\big) |S_\ell|\right)$. In this expression, $|S_\ell|$ is the number of (weakly) connected induced subgraphs of $G$ on at most $\ell$ vertices, $\Delta$ is the maximum degree of any vertex and $\omega$ is the exponent of matrix multiplication. We compare the algorithm complexity both theoretically and experimentally with most of the existing algorithms for the same task. These comparisons show that the algorithm described here is the best general purpose algorithm for the class of graphs where $(\ell^{\omega-1}\Delta^{-1}+1) |S_\ell|\leq |\text{Cycle}_\ell|$, with $|\text{Cycle}_\ell|$ the total number of simple cycles of length at most $\ell$, including backtracks and self-loops. On Erd\H{o}s-R\'enyi random graphs, we find empirically that this happens when the edge probability is larger than circa $4/N$. In addition, we show that some real-world networks also belong to this class. Finally, the algorithm permits the enumeration of simple cycles and simple paths on networks where vertices are labeled from an alphabet on $n$ letters with a time complexity of $O\left(N+M+\big(n^\ell\ell^\omega+\ell\Delta\big) |S_\ell|\right)$. A Matlab implementation of the algorithm proposed here is available for download.

Asymptotic tensor rank of graph tensors: beyond matrix multiplication

We present an upper bound on the exponent of the asymptotic behaviour of the tensor rank of a family of tensors defined by the complete graph on $k$ vertices. For $k\geq4$, we show that the exponent per edge is at most 0.77, outperforming the best known upper bound on the exponent per edge for matrix multiplication ($k=3$), which is approximately 0.79. We raise the question whether for some $k$ the exponent per edge can be below $2/3$, i.e. can outperform matrix multiplication even if the matrix multiplication exponent equals 2. In order to obtain our results, we generalise to higher order tensors a result by Strassen on the asymptotic subrank of tight tensors and a result by Coppersmith and Winograd on the asymptotic rank of matrix multiplication. Our results have applications in entanglement theory and communication complexity.

Conditional Lower Bounds for All-Pairs Max-Flow

We provide evidence that computing the maximum flow value between every pair of nodes in a directed graph on n nodes, m edges, and capacities in the range [1‥ n ], which we call the All-Pairs Max-Flow problem, cannot be solved in time that is significantly faster (i.e., by a polynomial factor) than O ( n 3 ) even for sparse graphs, namely m = O ( n ); thus for general m , it cannot be solved significantly faster than O ( n 2 m ). Since a single maximum st -flow can be solved in time Õ( m √ n ) [Lee and Sidford, FOCS 2014], we conclude that the all-pairs version might require time equivalent to Ω ˜ ( n 3/2 ) computations of maximum st -flow, which strongly separates the directed case from the undirected one. Moreover, if maximum st -flow can be solved in time Õ( m ), then the runtime of Ω ˜ ( n 2 ) computations is needed. This is in contrast to a conjecture of Lacki, Nussbaum, Sankowski, and Wulff-Nilsen [FOCS 2012] that All-Pairs Max-Flow in general graphs can be solved faster than the time of O ( n 2 ) computations of maximum st -flow. Specifically, we show that in sparse graphs G = ( V , E , w ), if one can compute the maximum st -flow from every s in an input set of sources S ⊆ V to every t in an input set of sinks T ⊆ V in time O ((| S || T | m ) 1−ε ), for some | S |, | T | and a constant ε &gt; 0, then MAX-CNF-SAT (maximum satisfiability of conjunctive normal form formulas) with n ′ variables and m ′ clauses can be solved in time m ′ O (1) 2 (1−δ) n ′ for a constant δ(ε) &gt; 0, a problem for which not even 2 n ′ / poly ( n ′) algorithms are known. Such running time for MAX-CNF-SAT would in particular refute the Strong Exponential Time Hypothesis (SETH). Hence, we improve the lower bound of Abboud, Vassilevska-Williams, and Yu [STOC 2015], who showed that for every fixed ε &gt; 0 and | S | = | T | = O (√ n ), if the above problem can be solved in time O ( n 3/2−ε ), then some incomparable (and intuitively weaker) conjecture is false. Furthermore, a larger lower bound than ours implies strictly super-linear time for maximum st -flow problem, which would be an amazing breakthrough. In addition, we show that All-Pairs Max-Flow in uncapacitated networks with every edge-density m = m ( n ) cannot be computed in time significantly faster than O ( mn ), even for acyclic networks. The gap to the fastest known algorithm by Cheung, Lau, and Leung [FOCS 2011] is a factor of O ( m ω−1 / n ), and for acyclic networks it is O ( n ω−1 ), where ω is the matrix multiplication exponent. Finally, we extend our lower bounds to the version that asks only for the maximum-flow values below a given threshold (over all source-sink pairs).

A Faster Subquadratic Algorithm for Finding Outlier Correlations

We study the problem of detecting outlier pairs of strongly correlated variables among a collection of n variables with otherwise weak pairwise correlations. After normalization, this task amounts to the geometric task where we are given as input a set of n vectors with unit Euclidean norm and dimension d , and for some constants 0&lt;τ &lt; ρ &lt; 1, we are asked to find all the outlier pairs of vectors whose inner product is at least ρ in absolute value, subject to the promise that all but at most q pairs of vectors have inner product at most τ in absolute value. Improving on an algorithm of Valiant [FOCS 2012; J. ACM 2015], we present a randomized algorithm that for Boolean inputs ({ −1,1}-valued data normalized to unit Euclidean length) runs in time Õ(( n max,{ 1−γ + M (Δ γ ,γ), M (1−γ ,2 Δ γ)} + qdn 2γ ), where 0&lt;γ &lt; 1 is a constant tradeoff parameter and M (μ, ν) is the exponent to multiply an ⌊ n μ ⌋ × ⌊ n ν ⌋ matrix with an ⌊ n ν ⌋ × ⌊ n μ ⌋ matrix and Δ =1/(1−log τ ρ). As corollaries we obtain randomized algorithms that run in time Õ( ( n 2/ω 3−log τ ρ + qdn 2/(1−log τ ρ)3=log ττ ρ ) and in time õ( ( n 4 / 2+α (1−log τ ρ) + qdn 2/α (1−log τ ρ)2+α (1−log τ ρ) &gt;), where 2≤ ω &lt;2.38 is the exponent for square matrix multiplication and 0.3&lt;α ≤ 1 is the exponent for rectangular matrix multiplication. The notation Õ(ṡ) hides polylogarithmic factors in n and d whose degree may depend on ρ and τ. We present further corollaries for the light bulb problem and for learning sparse Boolean functions.

Polynomials and the exponent of matrix multiplication

The exponent of matrix multiplication is the smallest constant ω such that two n × n matrices may be multiplied by performing O ( n ω + ε ) arithmetic operations for every ε > 0 . Determining the constant ω is a central question in both computer science and mathematics. Strassen [Linear Algebra Appl. 52/53 (1983) 645–685] showed that ω is also governed by the tensor rank of the matrix multiplication tensor. We define certain symmetric tensors, that is, cubic polynomials, and our main result is that their symmetric rank also grows with the same exponent ω, so that ω can be computed in the symmetric setting, where it may be easier to determine. In particular, we study the symmetrized matrix multiplication tensor s M ⟨ n ⟩ defined on an n × n matrix A by s M ⟨ n ⟩ ( A ) = trace ( A 3 ) . The use of polynomials enables the introduction of additional techniques from algebraic geometry in the study of the matrix multiplication exponent ω.

Counting Minimum Weight Arborescences

In a directed graph $$D = (V, A)$$ with a specified vertex $$r \in V$$ , an arc subset $$B \subseteq A$$ is called an r-arborescence if B has no arc entering r and there is a unique path from r to v in (V, B) for each $$v \in V \backslash \{ r \}$$ . The problem of finding a minimum weight r-arborescence in a weighted digraph has been studied for decades starting with Chu and Liu (Sci Sin 14:1396–1400, 1965), Edmonds (J Res Natl Bur Stand 71B:233–240, 1967) and Bock (Developments in operations research, Gordon and Breach, New York, pp 29–44, 1971). In this paper, we focus on the number of minimum weight arborescences. We present an algorithm for counting minimum weight r-arborescences in $$O(n^{\omega })$$ time, where n is the number of vertices of an input digraph and $$\omega $$ is the matrix multiplication exponent.

Revisiting Decomposition by Clique Separators

We study the complexity of decomposing a graph by means of clique separators. This common algorithmic tool, first introduced by Tarjan, allows one to cut a graph into smaller pieces, and so it can be applied to preprocess the graph in the computation of optimization problems. However, the best-known algorithms for computing a decomposition have respective ${\cal O}(nm)$-time and ${\cal O}(n^{(3+\alpha)/2}) = o(n^{2.69})$-time complexity with $\alpha < 2.3729$ being the exponent for matrix multiplication. Such running times are prohibitive for large graphs. Here we prove that for every graph $G$, a decomposition can be computed in ${\cal O}(T(G) + \min\{n^{\alpha},\omega^2 n\})$-time with $T(G)$ and $\omega$ being, respectively, the time needed to compute a minimal triangulation of $G$ and the clique-number of $G$. In particular, it implies that every graph can be decomposed by clique separators in ${\cal O}(n^{\alpha}\log n)$-time. Based on prior work from Kratsch et al., we prove in addition that decompo...

If the Current Clique Algorithms Are Optimal, so Is Valiant's Parser

The CFG recognition problem is as follows: given a context-free grammar $\mathcal{G}$ and a string $w$ of length $n$, decide whether $w$ can be obtained from $\mathcal{G}$. This is the most basic parsing question and is a core computer science problem. Valiant's parser from 1975 solves the problem in $O(n^{\omega})$ time, where $\omega<2.373$ is the matrix multiplication exponent. Dozens of parsing algorithms have been proposed over the years, yet Valiant's upper bound remains unbeaten. The best combinatorial algorithms have mildly subcubic $O(n^3/\log^3{n})$ time complexity. Evidence for the nonexistence of more efficient algorithms was given in a result of Lee (JACM'01), who showed that any algorithm with running time $O(|\mathcal{G}|\cdot n^{3-\varepsilon})$, which can solve a more general parsing problem in the unusual case that $|\mathcal{G}|=\Omega(n^6)$, can be converted into a surprising subcubic time algorithm for Boolean Matrix Multiplication. However, nothing was known for the more relevant case of constant size grammars. In this work, we make the first progress on the constant size grammar case in 40 years, and prove that any improvement on Valiant's algorithm, either in terms of runtime or by avoiding the inefficiencies of the known fast matrix multiplication algorithms, would imply a breakthrough algorithm for the $k$-Clique problem: given a graph of $n$ nodes, decide whether there are $k$ nodes that form a clique. Using similar techniques, we derive similar lower bounds for more modern and well-studied cubic time problems for which faster algorithms are highly desirable in practice: RNA Folding, a central problem in computational biology, and Dyck Language Edit Distance, answering an open question of Saha (FOCS'14).

On the complexity of integer matrix multiplication

Let M(n) denote the bit complexity of multiplying n-bit integers, let ω∈(2,3] be an exponent for matrix multiplication, and let lg⁎⁡n be the iterated logarithm. Assuming that log⁡d=O(n) and that M(n)/(nlog⁡n) is increasing, we prove that d×d matrices with n-bit integer entries may be multiplied inO(d2M(n)+dωn2O(lg⁎⁡n−lg⁎⁡d)M(lg⁡d)/lg⁡d) bit operations. In particular, if n is large compared to d, say d=O(log⁡n), then the complexity is only O(d2M(n)).