Exponent Of Matrix Multiplication Research Articles

Fast, deterministic computation of the Hermite normal form and determinant of a polynomial matrix

Given a nonsingular n×n matrix of univariate polynomials over a field K, we give fast and deterministic algorithms to compute its determinant and its Hermite normal form. Our algorithms use O˜(nω⌈s⌉) operations in K, where s is bounded from above by both the average of the degrees of the rows and that of the columns of the matrix and ω is the exponent of matrix multiplication. The soft-O notation indicates that logarithmic factors in the big-O are omitted while the ceiling function indicates that the cost is O˜(nω) when s=o(1). Our algorithms are based on a fast and deterministic triangularization method for computing the diagonal entries of the Hermite form of a nonsingular matrix.

Decoding Interleaved Gabidulin Codes using Alekhnovich's Algorithm

We prove that Alekhnovich's algorithm can be used for row reduction of skew polynomial matrices. This yields an O(ℓ3n(ω+1)/2log⁡(n)) decoding algorithm for ℓ-Interleaved Gabidulin codes of length n, where ω is the matrix multiplication exponent.

On the Shoshan-Zwick Algorithm for the All-Pairs Shortest Path Problem

The Shoshan-Zwick algorithm solves the all-pairs shortest paths problem in undirected graphs with integer edge costs in the range $\{1, 2, \dots, M\}$. It runs in $\tilde{O}(M\cdot n^{\omega})$ time, where $n$ is the number of vertices, $M$ is the largest integer edge cost, and $\omega < 2.3727$ is the exponent of matrix multiplication. It is the fastest known algorithm for this problem. This paper points out and corrects an error in the Shoshan-Zwick algorithm.

Fast computation of the rank profile matrix and the generalized Bruhat decomposition

The row (resp. column) rank profile of a matrix describes the stair-case shape of its row (resp. column) echelon form. We describe a new matrix invariant, the rank profile matrix, summarizing all information on the row and column rank profiles of all the leading sub-matrices. We show that this normal form exists and is unique over a field but also over any principal ideal domain and finite chain ring. We then explore the conditions for a Gaussian elimination algorithm to compute all or part of this invariant, through the corresponding PLUQ decomposition. This enlarges the set of known elimination variants that compute row or column rank profiles. As a consequence a new Crout base case variant significantly improves the practical efficiency of previously known implementations over a finite field. With matrices of very small rank, we also generalize the techniques of Storjohann and Yang to the computation of the rank profile matrix, achieving an (rω+mn)1+o(1) time complexity for an m×n matrix of rank r, where ω is the exponent of matrix multiplication. Finally, we give connections to the Bruhat decomposition, and several of its variants and generalizations. Consequently, the algorithmic improvements made for the PLUQ factorization, and their implementation, directly apply to these decompositions. In particular, we show how a PLUQ decomposition revealing the rank profile matrix also reveals both a row and a column echelon form of the input matrix or of any of its leading sub-matrices, by a simple post-processing made of row and column permutations.

Computing minimal interpolation bases

We consider the problem of computing univariate polynomial matrices over a field that represent minimal solution bases for a general interpolation problem, some forms of which are the vector M-Padé approximation problem in Van Barel and Bultheel (1992) and the rational interpolation problem in Beckermann and Labahn (2000). Particular instances of this problem include the bivariate interpolation steps of Guruswami–Sudan hard-decision and Kötter–Vardy soft-decision decodings of Reed–Solomon codes, the multivariate interpolation step of list-decoding of folded Reed–Solomon codes, and Hermite–Padé approximation.In the mentioned references, the problem is solved using iterative algorithms based on recurrence relations. Here, we discuss a fast, divide-and-conquer version of this recurrence, taking advantage of fast matrix computations over the scalars and over the polynomials. This new algorithm is deterministic, and for computing shifted minimal bases of relations between m vectors of size σ it uses O ˜(mω−1(σ+|s|)) field operations, where ω is the exponent of matrix multiplication, and |s| is the sum of the entries of the input shift s, with min⁡(s)=0. This complexity bound improves in particular on earlier algorithms in the case of bivariate interpolation for soft decoding, while matching fastest existing algorithms for simultaneous Hermite–Padé approximation.

Algebraic methods in the congested clique

In this work, we use algebraic methods for studying distance computation and subgraph detection tasks in the congested clique model. Specifically, we adapt parallel matrix multiplication implementations to the congested clique, obtaining an $O(n^{1-2/\omega})$ round matrix multiplication algorithm, where $\omega < 2.3728639$ is the exponent of matrix multiplication. In conjunction with known techniques from centralised algorithmics, this gives significant improvements over previous best upper bounds in the congested clique model. The highlight results include: -- triangle and 4-cycle counting in $O(n^{0.158})$ rounds, improving upon the $O(n^{1/3})$ triangle detection algorithm of Dolev et al. [DISC 2012], -- a $(1 + o(1))$-approximation of all-pairs shortest paths in $O(n^{0.158})$ rounds, improving upon the $\tilde{O} (n^{1/2})$-round $(2 + o(1))$-approximation algorithm of Nanongkai [STOC 2014], and -- computing the girth in $O(n^{0.158})$ rounds, which is the first non-trivial solution in this model. In addition, we present a novel constant-round combinatorial algorithm for detecting 4-cycles.

Finding Correlations in Subquadratic Time, with Applications to Learning Parities and the Closest Pair Problem

Given a set of n d -dimensional Boolean vectors with the promise that the vectors are chosen uniformly at random with the exception of two vectors that have Pearson correlation coefficient ρ (Hamming distance d · 1-ρ/ 2), how quickly can one find the two correlated vectors? We present an algorithm which, for any constant ϵ&gt;0, and constant ρ&gt;0, runs in expected time O (n 5-ω / 4-ω+ϵ +nd) &lt; O (n 1.62 +nd), where ω &lt; 2.4 is the exponent of matrix multiplication. This is the first subquadratic--time algorithm for this problem for which ρ does not appear in the exponent of n , and improves upon O (n 2-O(ρ) ), given by Paturi et al. [1989], the Locality Sensitive Hashing approach of Motwani [1998] and the Bucketing Codes approach of Dubiner [2008]. Applications and extensions of this basic algorithm yield significantly improved algorithms for several other problems. Approximate Closest Pair. For any sufficiently small constant ϵ&gt;0, given n d -dimensional vectors, there exists an algorithm that returns a pair of vectors whose Euclidean (or Hamming) distance differs from that of the closest pair by a factor of at most 1+ϵ, and runs in time O (n 2-Θ(√ϵ )). The best previous algorithms (including Locality Sensitive Hashing) have runtime O (n 2-O(ϵ) ). Learning Sparse Parities with Noise. Given samples from an instance of the learning parities with noise problem where each example has length n , the true parity set has size at most k « n , and the noise rate is η, there exists an algorithm that identifies the set of k indices in time n ω+ϵ/3 k poly(1/1-2η) &lt; n 0.8k poly(1/1-2 η). This is the first algorithm with no dependence on η in the exponent of n , aside from the trivial O (( n k )) ≈ O ( n k ) brute-force algorithm, and for large noise rates (η &gt; 0.4), improves upon the results of Grigorescu et al. [2011] that give a runtime of n (1+(2 η) 2 + o (1))k/2 poly (1/1-2η). Learning k -Juntas with Noise. Given uniformly random length n Boolean vectors, together with a label, which is some function of just k « n of the bits, perturbed by noise rate η, return the set of relevant indices. Leveraging the reduction of Feldman et al. [2009], our result for learning k -parities implies an algorithm for this problem with runtime n ω+ϵ/3 k poly (1/1-2η) &lt; n 0.8k poly (1/1-2 η), which is the first runtime for this problem of the form n ck with an absolute constant c &lt; 1. Learning k -Juntas without Noise. Given uniformly random length n Boolean vectors, together with a label, which is some function of k « n of the bits, return the set of relevant indices. Using a modification of the algorithm of Mossel et al. [2004], and employing our algorithm for learning sparse parities with noise via the reduction of Feldman et al. [2009], we obtain an algorithm for this problem with runtime n ω+ ϵ/4 k poly(n) &lt; n 0.6k poly(n) , which improves on the previous best of n ω+1/ωk ≈ n 0.7k poly(n) of Mossel et al. [2004].

Upgrading Subgroup Triple-Product-Property Triples

In 2003, Cohn and Umans introduced a group-theoretic approach to fast matrix multiplication. This involves finding large subsets of a group satisfying the Triple Product Property (TPP) as a means to bound the exponent of matrix multiplication. Recently, Hedtke and Murthy discussed several methods to find TPP triples. Because the search space for subset triples is too large, it is only possible to focus on subgroup triples. We present methods to upgrade a given TPP triple to a bigger TPP triple. If no upgrade is possible, we use reduction methods (based on random experiments and heuristics) to create a smaller TPP triple that can be used as input for the upgrade methods. If we apply the upgrade process for subset triples after one step with the upgrade method for subgroup triples for the known maximal subgroup TPP triples in groups of order up to 1,000, we achieve an enlargement of the triple size of 100% in the best case. Further, we test the upgrade process with all examples from the 2003 and 2005 papers from Cohn et al. and are able to increase the triple size by 595% in the best case (in the group D 5 6 ).

A deterministic algorithm for inverting a polynomial matrix

Improved cost estimates are given for the problem of computing the inverse of an n×n matrix of univariate polynomials over a field. A deterministic algorithm is demonstrated that has worst case complexity (n3s)1+o(1) field operations, where s≥1 is an upper bound for the average column degree of the input matrix. Here, the “+o(1)” in the exponent indicates a missing factor c1(logns)c2 for positive real constants c1 and c2. As an application we show how to compute the largest invariant factor of the input matrix in (nωs)1+o(1) field operations, where ω is the exponent of matrix multiplication.

Algebraic Algorithms for Linear Matroid Parity Problems

We present fast and simple algebraic algorithms for the linear matroid parity problem and its applications. For the linear matroid parity problem, we obtain a simple randomized algorithm with running time O ( mr ω-1 ), where m and r are the number of columns and the number of rows, respectively, and ω ≈ 2.3727 is the matrix multiplication exponent. This improves the O ( mr ω )-time algorithm by Gabow and Stallmann and matches the running time of the algebraic algorithm for linear matroid intersection, answering a question of Harvey. We also present a very simple alternative algorithm with running time O ( mr 2 ), which does not need fast matrix multiplication. We further improve the algebraic algorithms for some specific graph problems of interest. For the Mader’s disjoint S -path problem, we present an O ( n ω )-time randomized algorithm where n is the number of vertices. This improves the running time of the existing results considerably and matches the running time of the algebraic algorithms for graph matching. For the graphic matroid parity problem, we give an O ( n 4 )-time randomized algorithm where n is the number of vertices, and an O ( n 3 )-time randomized algorithm for a special case useful in designing approximation algorithms. These algorithms are optimal in terms of n as the input size could be Ω ( n 4 ) and Ω ( n 3 ), respectively. The techniques are based on the algebraic algorithmic framework developed by Mucha and Sankowski, Harvey, and Sankowski. While linear matroid parity and Mader’s disjoint S -path are challenging generalizations for the design of combinatorial algorithms, our results show that both the algebraic algorithms for linear matroid intersection and graph matching can be extended nicely to more general settings. All algorithms are still faster than the existing algorithms even if fast matrix multiplication is not used. These provide simple algorithms that can be easily implemented in practice.

Dynamic Matrix Rank with Partial Lookahead

We consider the problem of maintaining information about the rank of a matrix M under changes to its entries. For an n×n matrix M, we show an amortized upper bound of O(n ω−1) arithmetic operations per change for this problem, where ω<2.373 is the exponent for matrix multiplication, under the assumption that there is a lookahead of up to Θ(n) locations. That is, we know up to the next Θ(n) locations (i 1,j 1),(i 2,j 2),…, whose entries are going to change, in advance; however we do not know the new entries in these locations in advance. We get the new entries in these locations in a dynamic manner. The dynamic matrix rank problem was first studied by Frandsen and Frandsen who showed an upper bound of O(n 1.575) and a lower bound of Ω(n) for this problem and later Sankowski showed an upper bound of O(n 1.495) for this problem when allowing randomization and a small probability of error. These algorithms do not assume any lookahead. For the dynamic matrix rank problem with lookahead, Sankowski and Mucha showed a randomized algorithm (with a small probability of error) that is more efficient than these algorithms.

Fast matrix rank algorithms and applications

We consider the problem of computing the rank of an m × n matrix A over a field. We present a randomized algorithm to find a set of r = rank( A ) linearly independent columns in Õ (| A | + r ω ) field operations, where | A | denotes the number of nonzero entries in A and ω &lt; 2.38 is the matrix multiplication exponent. Previously the best known algorithm to find a set of r linearly independent columns is by Gaussian elimination, with deterministic running time O ( mnr ω-2 ). Our algorithm is faster when r &lt; max{ m , n }, for instance when the matrix is rectangular. We also consider the problem of computing the rank of a matrix dynamically, supporting the operations of rank one updates and additions and deletions of rows and columns. We present an algorithm that updates the rank in Õ ( mn ) field operations. We show that these algorithms can be used to obtain faster algorithms for various problems in exact linear algebra, combinatorial optimization and dynamic data structure.

Replacement Paths and Distance Sensitivity Oracles via Fast Matrix Multiplication

A distance sensitivity oracle of an n -vertex graph G = ( V , E ) is a data structure that can report shortest paths when edges of the graph fail. A query ( u ∈ V , v ∈ V , S ⊆ E ) to this oracle returns a shortest u -to- v path in the graph G ′ = ( V , E ∖ S ). We present randomized (Monte Carlo) algorithms for constructing a distance sensitivity oracle of size Õ ( n 3−α ) for | S | = O (lg n /lg lg n ) and any choice of 0 &lt; α &lt; 1. For real edge-lengths, the oracle is constructed in O ( n 4−α ) time and a query to this oracle takes Õ ( n 2−2(1−α)/|S| ) time. For integral edge-lengths in {− M ,..., M }, using the current ω &lt; 2.376 matrix multiplication exponent, the oracle is constructed in O ( Mn 3.376−α ) time with Õ ( n 2−(1−α)/|S| ) query, or alternatively in O ( M 0.681 n 3.575−α ) time with Õ ( n 2−2(1−α)/|S| ) query. Distance sensitivity oracles generalize the replacement paths problem in which u and v are known in advance and | S | = 1. In other words, if P is a shortest path from u to v in G , then the replacement paths problem asks to compute, for every edge e on P , a shortest u -to- v path that avoids e . Our new technique for constructing distance sensitivity oracles using fast matrix multiplication also yields the first subcubic-time algorithm for the replacement paths problem when the edge-lengths are small integers. In particular, it yields a randomized (Monte Carlo) Õ ( Mn 2.376 + M 2 3 n 2.584 )-time algorithm for the replacement paths problem assuming M ≤ n 0.624 . Finally, we mention that both our replacement paths algorithm and our distance sensitivity oracle can be made to work, in the same time and space bounds, for the case of failed vertices rather than edges, that is, when S is a set of vertices and we seek a shortest u -to- v path in the graph obtained from G by removing all vertices in S and their adjacent edges.

On Minimum Witnesses for Boolean Matrix Multiplication

Minimum witnesses for Boolean matrix multiplication play an important role in several graph algorithms. For two Boolean matrices A and B of order n, with one of the matrices having at most m nonzero entries, the fastest known algorithms for computing the minimum witnesses of their product run in either O(n2.575) time or in O(n2+mnlog(n2/m)/log2n) time. We present a new algorithm for this problem. Our algorithm runs either in time $$\tilde{O}\bigl(n^{\frac{3}{4-\omega}}m^{1-\frac{1}{4-\omega }}\bigr) $$ where ω<2.376 is the matrix multiplication exponent, or, if fast rectangular matrix multiplication is used, in time $$O\bigl(n^{1.939}m^{0.318}\bigr). $$ In particular, if ω−1<α<2 where m=nα, the new algorithm is faster than both of the aforementioned algorithms.

Finding, Minimizing, and Counting Weighted Subgraphs

For a pattern graph $H$ on $k$ nodes, we consider the problems of finding and counting the number of (not necessarily induced) copies of $H$ in a given large graph $G$ on $n$ nodes, as well as finding minimum weight copies in both node-weighted and edge-weighted graphs. Our results include the following: 1. The number of copies of an $H$ with an independent set of size $s$ can be computed exactly in $O^*(2^s n^{k-s+3})$ time and $poly(n,k)+O(2^s n^2)$ space, or in $O^*(4^s n^{k-s+3})$ time and $poly(n,k)$ space. (The $O^*$ notation omits $poly(k)$ factors.) To obtain these algorithms we provide fast algorithms for computing the permanent of a $k \times n$ matrix over rings and semirings. 2. The number of copies of any $H$ having minimum (or maximum) node-weight (with arbitrary real weights on nodes) can be found in $O(n^{\omega k/3} + n^{2k/3+o(1)})$ time, where $\omega < 2.38$ is the matrix multiplication exponent and $k$ is divisible by $3$. Similar results hold for other values of $k$. Also, the number of copies having exactly a prescribed weight can be found within this time. These algorithms extend the technique of Czumaj and Lingas [in Proceedings of SODA 2007, ACM, New York, SIAM, Philadelphia, 2007, pp. 986--994] and give a new (algorithmic) application of multiparty communication complexity. 3. Finding an edge-weighted triangle of weight exactly $0$ in general graphs requires $\Omega(n^{3-\varepsilon})$ time for all $\varepsilon > 0$, unless the $3$SUM problem on $N$ numbers can be solved in $O(N^{2 - \varepsilon})$ time. This suggests that the edge-weighted problem is much harder than its node-weighted version.

Counting and Detecting Small Subgraphs via Equations

We present a general technique for detecting and counting small subgraphs. It consists of forming special linear combinations of the numbers of occurrences of different induced subgraphs of fixed size in a graph. These combinations can be efficiently computed by rectangular matrix multiplication. Our two main results utilizing the technique are as follows. Let $H$ be a fixed graph with $k$ vertices and an independent set of size $s.$ 1. Detecting if an $n$-vertex graph contains a (not necessarily induced) subgraph isomorphic to $H$ can be done in time $O(n^{\omega(\lceil (k-s)/2 \rceil, 1, \lfloor (k-s)/2 \rfloor )})$, where $\omega (p,q,r)$ is the exponent of fast arithmetic matrix multiplication of an $n^p\times n^q$ matrix by an $n^q\times n^r$ matrix. 2. When $s=2,$ counting the number of (not necessarily induced) subgraphs isomorphic to $H$ can be done in the same time, i.e., in time $O(n^{\omega(\lceil (k-2)/2 \rceil, 1, \lfloor (k-2)/2 \rfloor )}).$ It follows in particular that we can count the nu...

A Deterministic Algorithm for the Frieze–Kannan Regularity Lemma

The Frieze–Kannan regularity lemma is a powerful tool in combinatorics. It has also found applications in the design of approximation algorithms and recently in the design of fast combinatorial algorithms for boolean matrix multiplication. The algorithmic applications of this lemma require one to efficiently construct a partition satisfying the conditions of the lemma. R. Williams recently asked if one can construct a partition satisfying the conditions of the Frieze–Kannan regularity lemma in deterministic subcubic time. We resolve this problem by designing an $\tilde O(n^{\omega})$ time algorithm for constructing such a partition, where $\omega < 2.376$ is the exponent of fast matrix multiplication. The algorithm relies on a spectral characterization of vertex partitions satisfying the properties of the Frieze–Kannan regularity lemma.

Search and test algorithms for triple product property triples

In 2003 Cohn and Umans introduced a group-theoretic approach to fast matrix multiplication. This involves finding large subsets of a group satisfying the triple product property (TPP) as a means to bound the exponent of matrix multiplication. We present two new characterizations of the TPP, which are used for theoretical considerations and for TPP test algorithms. We describe the algorithms for all known TPP tests and present the runtime differences between their GAP implementations. We prove that the search for non-trivial-sized TPP triples of subgroups of a given group can be restricted to the set of its non-normal subgroups, and apply this, together with other preconditions, to describe brute-force search algorithms for largest-sized TPP triples of subgroups and subsets. In addition we present the results of the subset brute-force search for all groups of order up to 32 and selected results of the subgroup brute-force search for 2-groups, and . Our results for the groups and suggest tentative answers to certain questions posed by Cohn and Umans.

Efficient algorithms for order basis computation

In this paper, we present two algorithms for the computation of a shifted order basis of an m×n matrix of power series over a field K with m≤n. For a given order σ and balanced shift s→ the first algorithm determines an order basis with a cost of O∼(nω⌈mσ/n⌉) field operations in K, where ω is the exponent of matrix multiplication. Here an input shift is balanced when max(s→)−min(s→)∈O(mσ/n). This extends the earlier work of Storjohann which only determines a subset of an order basis that is within a specified degree bound δ using O∼(nωδ) field operations for δ≥⌈mσ/n⌉.While the first algorithm addresses the case when the column degrees of a complete order basis are unbalanced given a balanced input shift, it is not efficient in the case when an unbalanced shift results in the row degrees also becoming unbalanced. We present a second algorithm which balances the high degree rows and computes an order basis also using O∼(nω⌈mσ/n⌉) field operations in the case that the shift is unbalanced but satisfies the condition ∑i=1n(max(s→)−s→i)≤mσ. This condition essentially allows us to locate those high degree rows that need to be balanced. This extends the earlier work by the authors from ISSAC’09.

Approximate shortest paths in weighted graphs

We present an approximation algorithm for the all pairs shortest paths (APSP) problem in weighed graphs. Our algorithm solves the APSP problem for weighted directed graphs, with real (positive or negative) weights, up to an additive error of ϵ. For any pair of vertices u , v , the algorithm finds a path whose length is at most δ ( u , v ) + ϵ . The algorithm is randomized and runs in O ˜ ( n ( ω + 3 ) / 2 ) < O ( n 2.688 ) time, where n is the number of vertices and ω is the matrix multiplication exponent. The absolute weights are allowed to mildly depend upon n, being at most n o ( 1 ) (we note that even if the weights are constants, δ ( u , v ) can be linear in n, while the error requirement ϵ is a small constant independent of n). Clearly, ϵ-additive approximations generalize exact algorithms for integer weighted instances. Hence, if ω = 2 + o ( 1 ) , this algorithm is as fast as any algorithm known for integer APSP in directed graphs, and is more general.