arXiv CSopen access

Rectangular Matrix Multiplication in the Low-Bandwidth Model

Rectangular Matrix Multiplication in the Low-Bandwidth Model Jukka Suomela Aalto University, Helsinki, Finland [email protected]

arXiv:2606.04652v1 [cs.DC] 3 Jun 2026

Chetan Gupta IIT Roorkee, Roorkee, India [email protected]

Hossein Vahidi Aalto University, Helsinki, Finland [email protected]

Abstract We study rectangular matrix multiplication in the low-bandwidth model of distributed computing. There are n computers; initially the input matrices are distributed evenly between computers, and in each communication round every computer can send and receive an O(log n)-bit message. Eventually each computer must output its designated part of the product matrix. While prior work has focused primarily on square n × n multiplication under various sparsity assumptions, we study rectangular instances with no sparsity assumption. We denote by ⟨a, b, c⟩ the task of multiplying an a × b matrix by a b × c matrix in this model. We concentrate on two natural aspect ratios, ⟨n, d, n⟩ and ⟨d, n, d⟩, for d ≤ n, and we study how the round complexity depends on n and d. When d → n, both ⟨n, d, n⟩ and ⟨d, n, d⟩ approach ⟨n, n, n⟩, which is the usual task of multiplying square matrices. If we consider multiplication over semirings, the current best upper bound in that case is O(n4/3 ) rounds, and there is a trivial unconditional lower bound of Ω(n). We show that for ⟨d, n, d⟩, we can achieve the complexity of Õ(d4/3 ), which seems like a natural generalization of the upper bound Õ(n4/3 ) when d = n. However, the case of ⟨n, d,√n⟩ is fundamentally different, and also √ exhibits a phase transition. We show that for d ≤ n, the complexity of ⟨n, d, n⟩ is Θ(d n); we have matching √ upper and lower bounds. However, the behavior is genuinely different in the region d ≥ n, where the upper bound is O(d2/3 n2/3 ).

Keywords. distributed computing, low-bandwidth model, matrix multiplication Acknowledgements. We are grateful to the anonymous reviewers for their helpful feedback on prior versions of this work.

1

Introduction

In this work we study the fundamental problem of multiplying rectangular matrices in a massively parallel, bandwidth-limited setting.

1.1

Setting and Prior Work

Centralized setting. To set the scene, let us first recall what is known about square matrices. Assume we are calculating the matrix product X = AB, where A and B are n × n matrices. 1

In the classical centralized setting, for matrix multiplication over fields, we have a long sequence of nontrivial algorithms, starting with Strassen’s O(n2.808 )-time algorithm [20], and the latest news is the O(n2.371339 )-time algorithm from [1]. These algorithms fundamentally exploit subtraction, and for multiplication over a general semiring not much is known beyond the trivial O(n3 )-time algorithms. Congested clique. The centralized algorithms have direct analogs in the massively parallel setting. Let us first consider the congested clique model [17]; in this model we have n computers, each computer has a direct communication link to all other computers, computation proceeds in synchronous rounds, and in each round we can send an O(log n)-bit message over each communication link. This is equivalent to a setting where each node can send and receive O(n log n) bits in total in each round [16]. We do not restrict local computation; we only care about the number of communication rounds. When we study matrix multiplication in the congested clique model, it is natural to assume that computer number i initially holds row (or column) number i of matrices A and B, and it has to eventually hold row (or column) number i of the product matrix X. The main result of [5] connects matrix multiplication in the congested clique model with fast centralized matrix multiplication algorithms. Informally, their main result is this: Assume that we have a centralized matrix multiplication algorithm that uses only O(nω ) operations, for some 2 ≤ ω ≤ 3. Then there is a matrix multiplication algorithm in the congested clique model that takes only O(n1−2/ω ) communication rounds. By plugging in the latest value ω ≈ 2.371339 from [1] we obtain an algorithm for fields that runs in O(n0.1566 ) rounds. For semirings the trivial choice of ω = 3 yields an algorithm that runs in O(n1/3 ) rounds. Sparse and rectangular matrices. However, in many applications we have matrices that are not dense, square matrices. E.g. [4,6,15] have studied matrix multiplication in the congested clique model for sparse and rectangular matrices. To make our point clear, let us focus on the case that matrix A has dimensions n × d, matrix B has dimensions d × n, and the product matrix X has hence dimensions n × n for some d ≤ n; we use notation ⟨n, d, n⟩ to refer to this task. Furthermore, let us focus on the case of semirings, primarily so that we have convenient round numbers. Recall that when d = n, the round complexity in the congested clique model is O(n1/3 ). Now a particularly relevant prior work is [6]. Adapted to this setting, their work shows that, √ for d ≥ n, there is an algorithm with round complexity O(d2/3 /n1/3 + 1) in the congested clique model. In particular, the round complexity of this algorithm smoothly grows from O(1) √ to O(n1/3 ) as d grows from n to n. √ For the congested clique model, this essentially ends the line of research for d < n: if there is a constant-round algorithm, what else could we ask for? However, this result is mainly an artifact of the way the congested clique model is defined. The model is simply too powerful, as we have Θ(n log n) bits of bandwidth per node per round, and it is therefore ill-suited when analyzing massively parallel algorithms when the size of the input is relatively small. Low-bandwidth model. There is recent work [10, 11] that has studied sparse matrix multiplication in the low-bandwidth model; this is essentially the same model as what is known as the node-capacitated clique or node-congested clique in the literature [2]. In this model we have simply scaled down the bandwidth by a factor of n in comparison with the congested clique model: in each round, each node can send and receive only one message with O(log n) bits. All upper bounds from the congested clique model now directly apply, if we multiply the round complexities by n. For example, the square semiring algorithm now has the round complexity O(n4/3 ), and ⟨n, d, n⟩ can be solved in O(d2/3 n2/3 + n) rounds. However, now it is not 2

√ at all clear what happens when we go below d = n. Intuitively, we would expect to be able to do much better than Θ(n) rounds for a small d, but exactly how does the round complexity scale? For example, would Θ(d2/3 n2/3 ) be the right complexity for all d?

1.2

Our Contributions

Problem setting. In this work, we study rectangular matrix multiplication in the lowbandwidth model. We consider both of these cases, both for semirings and fields, for d ≤ n: • ⟨n, d, n⟩: multiply an n × d matrix by a d × n matrix, and the result is an n × n matrix. • ⟨d, n, d⟩: multiply a d × n matrix by an n × d matrix, and the result is a d × d matrix. We have n computers. The input is distributed among them in a balanced manner. In each round, each computer can send and receive one O(log n)-bit message (we assume that each matrix element fits in such a message). Eventually each computer must hold its own part of the output. It turns out that the precise distribution of inputs is not particularly important; our algorithms can be adapted to any balanced input distribution and the lower bounds hold for any balanced input distribution. Hence, conveniently, we can assume that e.g. if a matrix has dimensions n × d, computer number i initially holds row i, which contains d elements. The output matrix requires a bit more care in the ⟨n, d, n⟩ case, since reorganizing the output is expensive, but again we can design our algorithms to work for natural output distributions and our lower bounds hold for any balanced output distribution. Results. Our results are summarized in Tables 1 and 2 and Figure 1. We present both upper and lower bounds on the round complexity of ⟨n, d, n⟩ and ⟨d, n, d⟩ in the low-bandwidth model, for semirings and fields. We have both unconditional lower bounds and conditional lower bounds. The conditional lower bounds are conditioned on the current square matrix multiplication algorithms being optimal. Our highlight result is related to ⟨n, d, n⟩. We completely characterize what happens in √ √ the region d ≤ n: in that region we have an upper bound of O(d n) and a near-matching √ unconditional lower bound of Ω(d n). √ Notably, this means that there is a phase transition at d = Θ( n). At this point, the round complexity is Θ(n). Below this point, round complexity scales in proportion to Θ(d). However, above this point, the round complexity scales in proportion to O(d2/3 ). This also highlights how misleading a view of the complexity landscape we would get if we only look at the congested clique model. Only by zooming into the low-bandwidth model can we see that the true complexity of this problem is not, for example, Θ(d2/3 n2/3 ), but we can do √ strictly better for d ≤ n. Our results for ⟨d, n, d⟩ show, in particular, that the complexity landscape of this problem is fundamentally different from ⟨n, d, n⟩. In particular, there is no sign of a phase transition, and we can solve ⟨d, n, d⟩ faster than ⟨n, d, n⟩ across all values of d < n. Here it is good to note that the total size of the input matrices is the same, and only the output matrices differ in size; the smaller output matrix significantly helps.

1.3

Techniques

Upper bounds. Our upper bounds are based on the familiar idea of subdividing the input and output matrices appropriately into submatrices. However, as we will see, we need complementary approaches for ⟨n, d, n⟩ and ⟨d, n, d⟩:

3

Table 1: Rectangular matrix multiplication over semirings in the low-bandwidth model.

Upper bound Unconditional LB Conditional LB

⟨n, d, n⟩    n + d2/3 n2/3 , O min √ d n √ Ω(min{d n, n}) 14/9 Ω( dn2/9 )

⟨d, n, d⟩ Theorem 6

O(d4/3 + log n)

Theorem 10 Theorem 13

Ω( dn ) 2 Ω( nd2/3 )

2

Theorem 15 Theorem 19 Theorem 17

Table 2: Rectangular matrix multiplication over fields in the low-bandwidth model. ⟨n, d, n⟩  2−2/ω  , n  Omin n + d2/3 n2/3 ,   √  d n √ Ω(min{d n, n}) 2−4/3ω Ω( dn2/3ω )

⟨d, n, d⟩



Upper bound Unconditional LB Conditional LB

T (n) = ny

Theorem 7

O(d2−2/ω + log n)

Theorem 10 Theorem 14

Ω( dn ) 2 Ω( nd2/ω )

2

Theorem 19 Theorem 18

T (n) = ny

3 2

3 2

4 3

4 3

1

1

1 2

1 2

d = nx 0

1 7

Theorem 16

1 2

11 5 14 6

d = nx

1

0

(a) ⟨n, d, n⟩ bounds

1 3

1 2

1

(b) ⟨d, n, d⟩ bounds

Figure 1: This figure summarizes the results from Table 1. Here, blue indicates ranges where we have an upper bound, whereas in orange regions we have an unconditional lower bound, and in gray regions we have a conditional lower bound.

4

• For ⟨n, d, n⟩, we essentially associate one block of the output matrix to one computer. Then it suffices to route the right parts of input to the right computer. Here the key primitive that we need is broadcasting, as the same part of the input is needed by multiple computers. • For ⟨d, n, d⟩, we split the input so that we have one instance of ⟨d, d, d⟩ per d computers. The final result is the sum of the results of these subproblems, and hence a key primitive that we need in the end is aggregation. Here it is notable that such a simple partitioning strategy for ⟨n, d, n⟩ can yield an asymptotically √ optimal algorithm for all d ≤ n. This is one of our take-home messages: in this region, simple, practical, and easy-to-implement algorithms are provably optimal. Lower bounds. The technically more interesting part of this work is the lower bounds. In the conditional lower bounds we present reductions that show that fast rectangular matrix multiplication algorithms can be used to design faster algorithms for square matrices. A key technical challenge in the reductions is that, in our setting, matrix dimensions are coupled with the number of computers. For example, in the proof of Theorem 13 we therefore split the reduction in two steps: 1. We show that if we have a fast algorithm for solving ⟨n, d, n⟩ with n computers, we can also solve ⟨k, k, k⟩ fast (for some appropriately-chosen k) with the same number of computers n. Note that here the matrix dimensions are different from the number of computers. 2. Then we show that if we can solve ⟨k, k, k⟩ with n computers, we can also solve ⟨N, N, N ⟩ with N computers (for some appropriately-chosen N ). Here we are finally in the familiar setting where the matrix dimensions agree with the number of computers. In the unconditional lower bounds, we make use of information-theoretic arguments, where the spirit is this: a fast matrix multiplication algorithm could be used to transmit too many bits between Alice and Bob, in comparison with the total available bandwidth between them. However, here the main technical challenge is that we wanted to show that our lower bounds are not merely artifacts of some specific assumptions related to the input/output distribution. To this end, we let the algorithm designer choose any fixed division of input and output, and show that the lower bound still holds, as long as the distribution is balanced (of course without the balance requirement the task is trivial: if all the input is in computer 1, and all the output needs to be held by computer 1, there is no need for any communication). This means that our lower bound has to be adaptive to whatever choice of the input and output distribution the algorithm designer makes. For example, in the proof of Theorem 10 we connect the existence of suitable adversarial strategies with a certain graph coloring problem, and show that the graph coloring problem always admits a solution, and hence we also always have an adversarial strategy, no matter what choices the algorithm designer makes on the distribution of inputs and outputs.

1.4

Discussion

Comparison with the MPC setting. Rectangular matrix multiplication has been considered in the literature in many different settings. In addition to the prior work in the congested clique model, there is also recent work that has studied matrix multiplication in the MPC (massively parallel computation) model [13]. The MPC setting is rather similar in spirit to the √ low-bandwidth model; however, the phase transition around d ≈ n in the ⟨n, d, n⟩ case seems to be a feature unique to the low-bandwidth model—there are no signs of a similar feature in the MPC results. 5

Comparison with BSP and distributed-memory matrix multiplication. There is a large body of work in the high-performance computing community on the communication complexity of parallel matrix multiplication, in models such as distributed-memory machines, BSP, and BSPRAM [3,7,8,12]. These works are closely related to ours, but they answer a different kind of question. Typically, one fixes the arithmetic circuit of a given algorithm to be evaluated—for example, the conventional cubic matrix-multiplication DAG, or a Strassen-like DAG—and then asks how much data movement is necessary for any parallel implementation that evaluates that circuit. For conventional rectangular matrix multiplication, Demmel et al. [8] and Al Daas et al. [7] give communication-optimal algorithms and matching lower bounds in a distributed-memory model. Their upper bound results are informative for our setting. If one plugs in P = n processors and dimensions ⟨n, d, n⟩, the resulting bandwidth expressions recover the same two √ regimes that appear in our upper bounds: d n and d2/3 n2/3 . Similarly, for dimensions ⟨d, n, d⟩, the corresponding expression gives d4/3 . Thus, the upper bounds in communication-avoiding literature can often be easily translated to upper bounds in the low-bandwidth model. The key difference is that these lower bounds are not lower bounds for the matrix multiplication problem as an arbitrary distributed task. They are lower bounds for evaluating a particular and fixed arithmetic circuit. For example, the lower bounds of Irony et al. [12] explicitly apply to conventional matrix multiplication: the computation consists of the elementary products aij bjk and their sums, and the analysis does not apply to Strassen’s algorithm or other non-conventional algorithms. Similarly, the lower bounds for Strassen-based algorithms [3] fix the Strassen computation DAG, and then prove that any parallel implementation of that DAG must communicate many words. These results still leave open whether a different distributed algorithm could solve the same problem faster. Our lower bounds do not assume that the algorithm evaluates a prescribed arithmetic circuit. Local computation is unrestricted, and the algorithm may use any strategy as long as, after the communication rounds, machines collectively output the product matrix. In particular, our lower bounds also account for techniques such as communication by silence, where information can be encoded or derived not only in the messages that are sent, but also in the absence of messages [9, 19]. Moreover, our bounds already hold for the seemingly easier special case of matrix multiplication over the Boolean semiring ({0, 1}, ∨, ∧). In this sense, our lower bound √ √ for ⟨n, d, n⟩ with d ≤ n shows that the d n barrier suggested by communication-avoiding conventional matrix multiplication is not merely a limitation of such algorithms: in the lowbandwidth model it is an unconditional barrier for all algorithms. Upper bounds in BSP and BSPRAM also fit naturally into this picture. McColl and Tiskin [18] give BSPRAM algorithms for matrix multiplication. If one focuses on the bandwidth term and sets the number of processors to p = n, these results recover the usual baseline bounds O(n4/3 ) for standard semiring multiplication and O(n2−2/ω ) for fast matrix multiplication over fields; these are consistent with the square-matrix primitives that we use as black boxes. Comparison with the supported setting. We point out that prior work on sparse matrix multiplication in the low-bandwidth setting [10, 11] uses the supported version of the model: the sparsity structure of the matrices is known in advance, and only the exact values of those elements are known at runtime. We emphasize that in the present work, we do not need to make any such structural assumptions, as our matrices are dense.

1.5

Open Problems for Future Work

√ The landscape of ⟨n, d, n⟩ is now fully understood for d ≤ n. On the other hand, proving a tight √ unconditional bound for d ≥ n would likely require major breakthroughs in our understanding

6

of matrix multiplication in general. However, we believe that proving a tight conditional lower √ bound for d ≥ n (or at least closing some of the gap) is within the reach of current techniques. The major open question is understanding the landscape of ⟨d, n, d⟩, where we currently have wide gaps for small values of d. We are not aware of fundamental barriers there. A particularly pressing question is understanding the case of d ≈ n1/3 for ⟨d, n, d⟩, which is the point where we do not have any lower bounds, conditional or unconditional.

2

Preliminaries

This section contains the definition of the model and problem, as well as a selection of helpful results and observations in the low-bandwidth model.

2.1

Model and Problem Definitions

We work in the low-bandwidth model, a distributed system that consists of n machines (or nodes), denoted by M = {1, 2, . . . , n}. Computation proceeds in synchronous communication rounds. Local computation. Each machine has unbounded local computational power and unbounded local memory. Local computation is free; the complexity measure of interest is the number of communication rounds. Communication. In each round, every machine may • send exactly one message to another machine, and • receive exactly one message from another machine. Each message contains at most O(log n) bits. Messages sent in round r are received by the end of the same round. Equivalently, in each round the communication forms a directed graph of maximum in-degree and out-degree 1. Problem. In this work, we study rectangular matrix multiplication. Given matrices A, B, the task is to compute the product X = AB. We denote by ⟨a, b, c⟩ the task of multiplying an a × b matrix A by a b × c matrix B in the low-bandwidth model. In this work, we will focus on ⟨n, d, n⟩ and ⟨d, n, d⟩ multiplications, where d ∈ [n]. Throughout the paper, we perform matrix multiplication over an arbitrary semiring (S, +, ·). We assume that every element of S admits an encoding of size O(log n) bits. In particular, a single semiring element fits within one communication message in the low-bandwidth model. Input and output distribution. The input is evenly distributed among the n machines, and each machine is responsible for producing an evenly sized portion of the output. More concretely, for the instances considered in this work: • each machine initially holds at most O(d) input entries, • each machine is required to output at most O(d) entries of ⟨d, n, d⟩ instances, or O(n) entries of ⟨n, d, n⟩ instances. The assignment of input and output indices to machines is fixed in advance and known to all machines (however, the values stored in the entries are not). In particular, machines know the value of d and n, and which multiplication instance is given. Complexity. An algorithm runs in T (n) rounds if, after T (n) communication rounds, all machines have produced their assigned output. 7

2.2

Observations and Toolbox

For any integer n > 0, we denote by [n] the set {1, . . . , n}. Theorem 1 (Square matrix multiplication [5], [10]). Given n × n matrices A, B in the lowbandwidth model, X = AB can be computed for semirings in O(n4/3 ) rounds, or in O(n2−2/ω ) rounds for fields. Proof. Follows from simulating each congested clique round of the O(n1/3 )-round semiring algorithm (currently best known) from [5] and their O(n1−2/ω )-round algorithm over fields in O(n) rounds of the low-bandwidth model. Similarly, by simulating the O(d2/3 /n1/3 + 1)-round result from [6] we have the following. Theorem 2 (Simulation of [6]). In the low-bandwidth model, there is an O(d2/3 n2/3 + n)-round algorithm that solves ⟨n, d, n⟩ over semirings. Next, we briefly mention some useful tools. An important note here is that machines do not coordinate during the algorithm to know to which machine they need to send a message (or from which machine they need to receive one); this scheduling is already hard-coded into the algorithm and execution is merely the step in which the values are revealed and transferred. This is done to avoid the costly runtime coordination overhead. We will see this pattern in our algorithms as well. Lemma 3 (Broadcast [11, Lemma 6.9]). In the low-bandwidth model, broadcasting a single bit v ∈ {0, 1} to all machines takes Θ(log n) rounds. Moreover, if k > 1 messages are given, broadcasting can be done in O(k + log n) rounds. Proof. Broadcasting can be done in a power-jumping manner. Suppose machine 1 initially holds the value v. In round i, there are 2i−1 machines that know v. Each of them sends v to a distinct machine that does not yet know it, for example to machines {2i−1 + 1, . . . , 2i }. Thus after round i, 2i machines know v. After O(log n) rounds, all machines know v. The argument works for any value v that fits in a single message. By carefully interleaving broadcast instances of the above form [14], one can schedule all the messages in a pipeline manner to achieve O(k + log n) rounds. For details of the lower bound, we refer the reader to [11, Lemma 6.9]. Lemma 4 (Aggregation [11, Lemma 6.4]). In the low-bandwidth model where all n machines are given a single bit in {0, 1}, computing logical AND, OR, and sum of the values takes Θ(log n) rounds. Moreover, if machines are instead given k values that fit in a message, aggregation can be done in O(k + log n) rounds. Proof. The idea is similar to Theorem 3, but done in the reverse order. Similarly, this works for any v that fits into a message, and can be generalized to k values by the same pipelining idea of [14]. For details of the lower bound, we refer the reader to [11, Lemma 6.4]. We occasionally refer to a distribution D of data to emphasize which machine m ∈ M holds which value v (e.g. an element of a matrix); here v is typically small enough to fit in a single message, i.e. O(log n) bits. Observation 5 (Redistribution). Given a distribution D of d values per machine, we can rearrange the values to any distribution D′ of d values per machine. This is done thanks to the fact that the bipartite graph of senders and receivers where a value’s home and destination machine form an edge is d-regular, and therefore a d-coloring of the edges exists. One simply iterates over color classes and sends all messages of a color class in one round. Computing the coloring requires no communication and can be done locally by all machines as long as the distributions D and D′ are known globally. 8

3

⟨n, d, n⟩ Multiplication

3.1

Upper Bound for ⟨n, d, n⟩

Theorem 6. In the low-bandwidth model with n machines, ⟨n, d, n⟩ multiplication over semirings √ can be computed in O(min{d n, n + d2/3 n2/3 }) communication rounds. Proof. Let A, B be given matrices, and we are computing X = AB. Let A be an n × d matrix and B a d × n matrix. Assume that n is a perfect square; otherwise, we safely pad the matrices √ √ with zeros. We partition X into n × n blocks and write   χ1,1 χ1,2 · · · χ1,√n  χ2,1 χ2,2 · · · χ2,√n    X= . .. ..  . ..  .. . . .  χ√n,1 χ√n,2 · · ·

χ√n,√n

√ Formally, for every i, j ∈ [ n], √ for all p, q ∈ [ n].

(χi,j )p,q = X(i−1)√n+p, (j−1)√n+q We also partition A into

√

n row blocks: 

 A1  A2    A =  ..  .  .  A√n

Similarly, we partition B into

√

n column blocks:   B = B1 B2 · · · B√n .

Rewriting the multiplication, we have   A1  A2     AB =  ..  B1 B2 · · ·  .  A√ n  A1 B 1  A2 B 1  = .  ..

A1 B2 A2 B2 .. .

··· ··· .. .

A√ n B 1 A√ n B 2 · · ·

B √n



 A1 B √ n A2 B √ n    = X, ..  . A √n B √n

√ where for every i, j ∈ [ n], χi,j = Ai Bj . For simplicity, we assume that each machine initially holds a row of A and a column of B; √ otherwise, we can redistribute in O(d) rounds by Theorem 5. Moreover, for every pair i, j ∈ [ n] we assign a distinct machine, denoted by Mi,j , responsible for outputting χi,j . Since χi,j = Ai Bj , it is enough to route all elements of Ai and Bj to Mi,j , then compute Ai Bj locally. √ Routing. We first route all elements of A to the right machines. For any i ∈ [ n], Ai needs √ to be sent to {Mi,1 , Mi,2 , . . . , Mi,√n }. For all Ai ’s, in O(d n) rounds we can send Ai from host machines to Mi,1 . Then, we can use the power jump technique from Theorem 3 to broadcast √ √ Ai to all the above machines in O(d n + log n) = O(d n) rounds. Note that since no machine 9

belongs to more than one broadcast instance, all instances can run in parallel. Similarly, we √ route and broadcast Bj to all machines {M1,j , M2,j , . . . , M√n,j } in O(d n) rounds. Furthermore, ⟨n, d, n⟩ can be solved by Theorem 2 in O(d2/3 n2/3 + n) rounds. Combining √ the two algorithms, we conclude that ⟨n, d, n⟩ can be solved in O(min{d n, n + d2/3 n2/3 }) rounds. √ √ Note that our O(d n)-round algorithm outperforms known algorithms up to d = O( n). We can similarly prove the following for multiplication over fields. Theorem 7. In the low-bandwidth model with n machines, ⟨n, d, n⟩ multiplication over fields √ can be computed in O(min{d n, n + d2/3 n2/3 , n2−2/ω }) communication rounds.

3.2

Unconditional Lower Bound for ⟨n, d, n⟩

Suppose AB = X is an ⟨n, d, n⟩ instance. Let Y be an n × n matrix which is the same as X, except it only contains those elements that machine 1 will output, in the same position as they appear in X, and the other elements are 0. Since each machine is responsible for outputting an even share of the product matrix, we know that Y contains n nonzero elements. Our idea to prove the lower bound works as follows. Suppose matrix A contains arbitrary elements but we can set the elements of B as 0 and 1 in such a way that after multiplying A with B, Y contains k elements of A, in other words yij = aij for some k indices (where yij and aij are the elements of Y and A). Since machine 1 initially contains only d elements of A, we will prove that any algorithm will take Ω(k − d) rounds to communicate the remaining ≥ (k − d) elements of A from other machines to machine 1 (or we might use the opposite setting where elements of A are set to 0 and 1 and matrix B is any arbitrary matrix). We first prove the following lemma, which we will use to prove the desired lower bound. Suppose Alice and Bob are two players such that Alice has a bit vector of length b log n that Bob wants to learn. Let A be an algorithm for this task in the low-bandwidth model. Lemma 8. Algorithm A requires at least b rounds. Proof. There are 2b log n bit vectors of length b log n; enumerate them as v1 , . . . , v2b log n . Assume that A completes the communication in r < b rounds. Since in each round Bob can receive at most log n bits, he receives at most r log n bits in total. Because r log n < b log n, there must exist two distinct vectors vi and vj such that Bob receives the same sequence of bits when Alice holds either vi or vj . Consequently, Bob cannot distinguish between these two cases and therefore outputs an incorrect vector in at least one case. Hence, A must take at least b rounds. Returning to our lower bound proof, we divide the rows of Y into two parts, heavy and light: √ the heavy part contains those rows that have at least n elements, and the light part contains √ those rows that have fewer than n elements. Without loss of generality, the rows in the heavy part have higher indices (top rows) than the rows in the light part (since we can swap rows of A in a way such that the condition holds. In fact, we can assume that the rows are sorted, from top to bottom, according to the number of elements in them). Now divide the remaining analysis into two cases. Case 1: Heavy rows contain at least n2 elements. If the number of heavy rows is √ ≥ d, then the first d top rows (heavy rows with high indices) collectively contain at least d n elements. Also, if the number of heavy rows is less than d, then we know that the first d top rows contain Ω(n) elements. Now, suppose that we construct a matrix B in such a way that it contains some arbitrary elements in the same positions as in the first d top rows of Y . Matrix A contains the identity matrix in its first d top rows and d columns, and the remaining elements are 0. Now, √ in order to do A × B, these min{d n, n} elements of B need to be communicated to machine 10

1. We treat machine 1 as Bob and all remaining machines together as Alice. Alice initially √ √ holds min{d n, n} elements of B, corresponding to a bit vector of length (min{d n, n}) log n √ that Bob must learn. By Theorem 8, any algorithm requires Ω(min{d n, n}) rounds for the multiplication of A and B in this case. Case 2: Light rows contain more than n2 elements. Since d ≤ n, we can say that √ there are at least Ω( n) light rows. Mark the first d elements from each light row of Y (if the number of elements in a row is less than d, then select all of them). We can prove that the √ number of marked elements is Ω(d n). The proof goes as follows. First, let us sort the rows √ according to the number of elements present in them. Look at the top n/2 light rows. (i) If √ the last row among these n/2 rows contains at least d elements, then the marked elements in √ √ √ the top n/2 rows alone give us Ω(d n) elements. (ii) If the last row among these n/2 rows does not contain d elements, that means all the remaining light rows also contain fewer than d elements. Now, let us count the maximum number of unmarked elements in this case. All √ the unmarked elements can only be present in the top n/2 rows, therefore they are at most √ √ n the total elements of the light rows, we get that the total 2 ( n − d). By subtracting that from √ number of marked elements is Ω(d n). √ Now that we have marked Ω(d n) elements in matrix Y , we will show that for any arbitrary matrix A, one can carefully set the elements of B as 0 and 1 such that after multiplication, √ Ω(d n) elements of A appear at these marked positions of Y . Note that if each column of B contains exactly one 1 and all the other elements are 0, then each column of X will be nothing but a column of A. Now the idea is to set elements of B in such a way that each column contains √ a single 1 and after multiplication Ω(d n) distinct elements of A land at the marked positions of Y . Let us suppose that the i-th row of Y contains t marked elements, namely yi,j1 , yi,j2 , . . . , yi,jt . Also, suppose in matrix B columns j1 , j2 , . . . , jt contain 1 in rows k1 , k2 , . . . , kt , respectively (and of course all the other elements in these columns are 0). In such a setting, after multiplication we will have that yi,jl = ai,kl for all l ∈ [t]. Notice that if all kl are distinct, then ai,kl is also distinct. In other words, we can say that if there are p distinct kl among k1 , k2 , . . . , kt , then p distinct elements from row i of A will land on the marked elements of matrix Y . For each row i of matrix Y , we define a number fi as follows. If yi,j1 , yi,j2 , . . . , yi,jt are the marked elements of row i of X, then fi is the maximum number of columns among j1 , j2 , . . . , jt in matrix B such that no two columns among these fi columns contain 1 in the same row. Now if we can prove √ that we can set the matrix B in such a way that Σfi = Ω(d n) then we are done. We can convert this problem into a graph coloring problem as follows. Let us look at the matrix Y (only marked elements) as a bipartite graph G = (L, R) with n nodes on each set L and R. Let us index the nodes on each side as 1, 2, . . . , n. Put an edge (i, j) if yi,j is marked. In other words, edges incident on node i ∈ L represent the marked elements of row i in Y and edges incident on node j ∈ R represent the marked elements in column j of Y . Lemma 9 (Distinct-Neighbor Coloring). Let G = (L, R, E) be a bipartite graph with |L| = |R| = n. Assume that every vertex v ∈ L has degree at most d ≤ n. Then there exists a coloring c : R → [d] such that X |E| |c(N (v))| ≥ . 2 v∈L

Proof. Let N (v) be the neighbors of v. Assign to each j ∈ R a color c(j) ∈ [d] independently and uniformly at random. Fix a vertex i ∈ L with degree t ≤ d. For a fixed color z ∈ [d], the probability that none of the t neighbors of i receives color z is (1 − 1/d)t . Hence the probability that color z appears among the neighbors of i is 1 − (1 − 1/d)t . By linearity of expectation, E[|c(N (i))|] = d(1 − (1 − 1/d)t ). 11

Using the inequality d(1 − (1 − 1/d)t ) ≥

t 2

for t ≤ d,

we obtain

t E[|c(N (i))|] ≥ . 2 Summing over all i ∈ L and using linearity of expectation, " # X X deg(i) |E| E |c(N (i))| ≥ = . 2 2 i∈L

i∈L

Therefore there exists a coloring c such that X

|c(N (i))| ≥

i∈L

|E| . 2

Now this lemma gives us the combinatorial gadget that enables us to force a lot of distinct entries of A to appear in the positions that machine 1 is responsible for outputting. We now construct the matrix B as follows: each column j contains a single 1 in row c(j), and all other entries are 0. Then for all (i, j) ∈ E, xi,j =

d X

ai,t bt,j = ai,c(j) .

t=1

Therefore, for each row i the number of distinct entries of A that appear in the marked positions of row i is exactly |c(N (i))|. Summing over all rows, the total number of distinct entries of A that appear in the marked positions is at least X √ |c(N (i))| = Ω(d n). i∈L

√ Machine 1 must output all Ω(d n) distinct entries corresponding to Y ; by Theorem 8, this √ takes Ω(d n) rounds. On the other hand, by definition, machine 1 does not output more than √ n elements. Thus, the Ω(min{d n, n}) bound follows. This proves the following theorem. Theorem 10. In the low-bandwidth model with n machines, any algorithm that computes the √ product ⟨n, d, n⟩ over fields or semirings requires Ω(min{d n, n}) communication rounds. In particular, we get the following corollary. Corollary 11. In the low-bandwidth model with n machines, any algorithm that computes the product ⟨n, n, n⟩over fields or semirings requires Ω(n) communication rounds.

3.3

Conditional Lower Bound for ⟨n, d, n⟩

 14/9  4 In this section, we will prove Ω dn2/9 for ⟨n, d, n⟩ assuming that Ω(n 3 ) is the lower bound for ⟨n, n, n⟩. We begin by proving that if we have an algorithm to solve ⟨n, d, n⟩ instances, we can 1 use it to solve ⟨k, k, k⟩ instances, with no asymptotic overhead, where k = (nd2 ) 3 . Lemma 12. If ⟨n, d, n⟩ can be solved in O(nβ ) rounds, then we can solve ⟨k, k, k⟩ in O(nβ ) rounds as well.

12

Proof. Let A × B = C be an instance where A, B, and C are of size k × k. We can divide the task of multiplying A and B into multiplying ( nd ) instances of ⟨d, d, d⟩. Let us first divide the 2 1 matrices A and B into ( nd ) 3 submatrices of size d × d as follows. Let t = ( nd ) 3 .     A1 A2 · · · At B1 B2 · · · Bt   At+1 At+2 · · · A2t  Bt+2 · · · B2t     Bt+1  ×  .. .. ..   .. .. ..  . .. ..    . . . . . . . .  At2 −t+1 At2 −t+2 · · ·

Bt2 −t+1 Bt2 −t+2 · · ·

At2

Bt2

From this, we conclude that in order to compute A × B, we need to compute t3 = nd instances of type Ai × Bj for some combination of i, j ∈ [t2 ]. Let us rename these t3 instances as A′i × Bi′ . Now we prove that if ⟨n, d, n⟩ can be solved in O(nβ ) rounds, then these t3 instances can also be computed in O(nβ ) rounds. We create an ⟨n, d, n⟩ instance by arranging the matrices A′i vertically and the matrices Bi′ horizontally as follows:  ′   ′ A1 C1 · · · · · · · · ·   A′  C2′ · · · · · ·    2  ′ ′ ′  ..  × [ B1 B2 · · · Bt3 ] =  .. .. ..  . .  .  .  . . .  ′ At3 · · · · · · · · · Ct′3 Let us denote these larger matrices by A′ , B ′ , and C ′ . Let C1′ , C2′ , · · · , Ct′3 be the d × d matrices that appear on the diagonal of the resultant matrix C ′ . We can see that the matrices Ci′ are the desired t3 matrices that we wanted, which, by our assumption, can be computed in O(nβ ) rounds. This implies that C can also be computed in O(nβ ) rounds. Let us assume that d = nα for some 0 ≤ α ≤ 1. From the above, we conclude that 1+2α 1+2α ⟨n , n 3 , n 3 ⟩ can be solved in O(nβ ) rounds with n machines. Let us denote γ = ( 1+2α 3 ) 1+2α 3

β

1

and N = nγ . That implies that ⟨N, N, N ⟩ can be solved in O(N γ ) rounds with N γ machines. 1 1 Since γ ≤ 1, we have N γ ≥ N . Now suppose that instead of N γ machines, we use N machines to run the same algorithm. In such a scenario, one machine is responsible for handling the 1 −1 γ communication of N machines. This means that a task that could be done in one round 1 1 −1 with N γ machines will now require N γ rounds. Therefore, we can say that ⟨N, N, N ⟩ can β

+ 1 −1

be solved in O(N γ γ ) rounds with N machines. Now if we assume that ⟨n, n, n⟩ requires 4 Ω(n 3 ) rounds with n machines in the low bandwidth model, from the above we can conclude that β+1−γ ≥ 43 . This implies γ 7γ 7(2α + 1) 14α − 2 −1= −1= . 3 9 9  14/9  Since d = nα , we can conclude that ⟨n, d, n⟩ requires Ω dn2/9 rounds. β≥

14/9

Theorem 13. Assume that we can solve ⟨n, d, n⟩ over semirings in O( nd2/9+ϵ ) rounds in the low-bandwidth model with n machines. Then we can also solve dense matrix multiplication in O(n4/3−ϵ/2 ) rounds. By using similar ideas with small adjustments we can also prove the following bound for multiplication over fields. 2−4/3ω

Theorem 14. Assume that we can solve ⟨n, d, n⟩ over fields in O( nd 2/3ω+ϵ ) rounds, for some ϵ > 0, in the low-bandwidth model with n machines. Then we can solve dense n × n matrix 2 multiplication over fields in O(n2− ω −ϵ/2 ) rounds. 13

4

⟨d, n, d⟩ Multiplication

4.1

Upper Bound for ⟨d, n, d⟩

Theorem 15. In the low-bandwidth model with n machines, ⟨d, n, d⟩ multiplication over semirings can be computed in O(d4/3 + log n) communication rounds. Proof. Let AB = X be the multiplication we are computing, where A is a d × n matrix and B is an n × d matrix. We split matrix A into m := nd square submatrices A1 , . . . , Am of size d × d such that A = [ A1 | A2 | · · · | Am ]. Similarly, we split B,

 B1  B2    B =  . .  ..  

Bm Note that if n is not divisible P by d, we can safely pad the last block with zeros. Now X = AB can be computed as X = m i=1 Ai Bi , so it is enough to compute the smaller dense but square matrix multiplication instances and add them all together. Step 1: Multiplications. We assume that for each i ∈ [m] there are d machines such that each machine holds a row of Ai and a column of Bi , otherwise a redistribution of the input can easily be done in O(d) rounds by Theorem 5. This essentially gives us m independent instances of ⟨d, d, d⟩, i.e. C (i) = Ai Bi , using d machines. These can be solved in parallel in O(d4/3 ) rounds by Theorem 1. Step 2: Aggregation. To compute X, we just need to aggregate all the values to compute Pm (i) . Formally, we may assume that for each result matrix C (i) , where C the sum X = i=1 (i) (i) i ∈ [m], each row Cj,∗ is held in a single machine Mj . Then using Theorem 4 we can aggregate the sum in O(d + log n) rounds. Combining the above two steps, we solve ⟨d, n, d⟩ multiplication in O(d4/3 + log n) communication rounds. Similarly, we can show the following result. Theorem 16. In the low-bandwidth model with n machines, ⟨d, n, d⟩ multiplication over fields can be computed in O(d2−2/ω + log n) communication rounds.

4.2

Conditional Lower Bound for ⟨d, n, d⟩ 2

d Theorem 17. Assume that we can solve ⟨d, n, d⟩ over semirings in O( n2/3+ϵ ) rounds, ϵ > 0, in the low-bandwidth model with n machines. Then we can also solve dense matrix multiplication in O(n4/3−ϵ/2 ) rounds.

Proof. Let d = nα , where 0 < α ≤ 1. Suppose we have an algorithm that solves ⟨d, n, d⟩ ≡ ⟨nα , n, nα ⟩ type of matrix multiplication instance in O(nβ ) rounds. We can use this algorithm as a black box to solve ⟨n, n, n⟩ as follows. Given matrices A, B ∈ S n×n , to compute A × B = C, we divide the matrices A, B and C into nα × nα square submatrices Aij , Bij , and Cij where P 1−α i, j ∈ [n1−α ] such that Cij = nk=1 Aik × Bkj . Note that Cij can be thought of as an ⟨nα , n, nα ⟩ instance (where matrices Aik are arranged horizontally to create an nα × n matrix and matrices Bkj are arranged vertically to form an n × nα matrix). Therefore, we can use the above nβ 14

round algorithm to compute this product. Applying the same algorithm to all n2−2α instances of Cij , one by one, gives us an O(n2−2α+β ) round algorithm to compute C. ′ Now, if there are no algorithms that solve square matrix multiplication in O(n4/3−ϵ ) rounds, for some ϵ′ > 0, then 2 − 2α + β ≥ 4/3 − ϵ′ and hence β ≥ 2α − 32 − ϵ′ . Recall that we set 2 d = nα . By substitution, it follows that no O(d2 n− 3 −ϵ )-round algorithm for ⟨d, n, d⟩ exists, where ϵ = 2ϵ′ . By using similar ideas with small adjustments we can also prove the following bound for multiplication over fields. 2

d Theorem 18. Assume that we can solve ⟨d, n, d⟩ over fields in O( n2/ω+ϵ ) rounds, for some ϵ > 0, in the low-bandwidth model with n machines. Then we can also solve dense n × n matrix multiplication over fields in O(n2−2/ω−ϵ/2 ) rounds.

4.3

Unconditional Lower Bound for ⟨d, n, d⟩

Here we aim to prove the following. Theorem 19. In the low-bandwidth model with n machines, any algorithm that computes the 2 product ⟨d, n, d⟩ over fields or semirings requires Ω( dn ) communication rounds. Proof. We can use the idea of the conditional lower bound, but use the unconditionally true bound from Theorem 11 that square matrix multiplication cannot be done in o(n) rounds.

References [1] Josh Alman, Ran Duan, Virginia Vassilevska Williams, Yinzhan Xu, Zixuan Xu, and Renfei Zhou. More asymmetry yields faster matrix multiplication. In Yossi Azar and Debmalya Panigrahi, editors, Proceedings of the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2025, New Orleans, LA, USA, January 12-15, 2025, pages 2005–2039. SIAM, 2025. doi:10.1137/1.9781611978322.63. [2] John Augustine, Mohsen Ghaffari, Robert Gmyr, Kristian Hinnenthal, Christian Scheideler, Fabian Kuhn, and Jason Li. Distributed computation in node-capacitated networks. In Christian Scheideler and Petra Berenbrink, editors, The 31st ACM Symposium on Parallelism in Algorithms and Architectures, SPAA 2019, Phoenix, AZ, USA, June 22-24, 2019, pages 69–79. ACM, 2019. doi:10.1145/3323165.3323195. [3] Grey Ballard, James Demmel, Olga Holtz, Benjamin Lipshitz, and Oded Schwartz. Brief announcement: strong scaling of matrix multiplication algorithms and memory-independent communication lower bounds. In Guy E. Blelloch and Maurice Herlihy, editors, 24th ACM Symposium on Parallelism in Algorithms and Architectures, SPAA ’12, Pittsburgh, PA, USA, June 25-27, 2012, pages 77–79. ACM, 2012. doi:10.1145/2312005.2312021. [4] Keren Censor-Hillel, Michal Dory, Janne H. Korhonen, and Dean Leitersdorf. Fast approximate shortest paths in the congested clique. Distributed Computing, 34(6):463–487, 2021. doi:10.1007/S00446-020-00380-5. [5] Keren Censor-Hillel, Petteri Kaski, Janne H. Korhonen, Christoph Lenzen, Ami Paz, and Jukka Suomela. Algebraic methods in the congested clique. Distributed Computing, 32(6):461–478, 2019. doi:10.1007/S00446-016-0270-2. [6] Keren Censor-Hillel, Dean Leitersdorf, and Elia Turner. Sparse matrix multiplication and triangle listing in the congested clique model. In Jiannong Cao, Faith Ellen, Luís Rodrigues, 15

and Bernardo Ferreira, editors, 22nd International Conference on Principles of Distributed Systems, OPODIS 2018, Hong Kong, December 17-19, 2018, volume 125 of LIPIcs, pages 4:1–4:17. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2018. doi:10.4230/LIPICS. OPODIS.2018.4. [7] Hussam Al Daas, Grey Ballard, Laura Grigori, Suraj Kumar, and Kathryn Rouse. Brief announcement: Tight memory-independent parallel matrix multiplication communication lower bounds. In Kunal Agrawal and I-Ting Angelina Lee, editors, SPAA ’22: 34th ACM Symposium on Parallelism in Algorithms and Architectures, Philadelphia, PA, USA, July 11 - 14, 2022, pages 445–448. ACM, 2022. doi:10.1145/3490148.3538552. [8] James Demmel, David Eliahu, Armando Fox, Shoaib Kamil, Benjamin Lipshitz, Oded Schwartz, and Omer Spillinger. Communication-optimal parallel recursive rectangular matrix multiplication. In 27th IEEE International Symposium on Parallel and Distributed Processing, IPDPS 2013, Cambridge, MA, USA, May 20-24, 2013, pages 261–272. IEEE Computer Society, 2013. doi:10.1109/IPDPS.2013.80. [9] Martin Dietzfelbinger, Mirosław Kutyłowski, and Rüdiger Reischuk. Exact lower time bounds for computing Boolean functions on CREW PRAMs. Journal of Computer and System Sciences, 48(2):231–254, 1994. doi:10.1016/S0022-0000(05)80003-0. [10] Chetan Gupta, Juho Hirvonen, Janne H. Korhonen, Jan Studený, and Jukka Suomela. Sparse matrix multiplication in the low-bandwidth model. In Kunal Agrawal and I-Ting Angelina Lee, editors, SPAA ’22: 34th ACM Symposium on Parallelism in Algorithms and Architectures, Philadelphia, PA, USA, July 11 - 14, 2022, pages 435–444. ACM, 2022. doi:10.1145/3490148.3538575. [11] Chetan Gupta, Janne H. Korhonen, Jan Studený, Jukka Suomela, and Hossein Vahidi. Lowbandwidth matrix multiplication: Faster algorithms and more general forms of sparsity. In Ulrich Schmid and Roman Kuznets, editors, Structural Information and Communication Complexity - 32nd International Colloquium, SIROCCO 2025, Delphi, Greece, June 2-4, 2025, Proceedings, volume 15671 of Lecture Notes in Computer Science, pages 333–349. Springer, 2025. doi:10.1007/978-3-031-91736-3_20. [12] Dror Irony, Sivan Toledo, and Alexandre Tiskin. Communication lower bounds for distributed-memory matrix multiplication. Journal of Parallel and Distributed Computing, 64(9):1017–1026, 2004. doi:10.1016/J.JPDC.2004.03.021. [13] Lakshya Joshi, Arya Deshmukh, Atharv Chhabra, and Chetan Gupta. Matrix multiplication in the MPC model. In Neeldhara Misra and Arti Pandey, editors, Algorithms and Discrete Applied Mathematics - 12th International Conference, CALDAM 2026, Dharwad, India, February 12-14, 2026, Proceedings, volume 16445 of Lecture Notes in Computer Science, pages 209–220. Springer, 2026. doi:10.1007/978-3-032-17156-6_16. [14] Ramakrishnan Kannan, Grey Ballard, and Haesun Park. A high-performance parallel algorithm for nonnegative matrix factorization. In Rafael Asenjo and Tim Harris, editors, Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPoPP 2016, Barcelona, Spain, March 12-16, 2016, pages 9:1–9:11. ACM, 2016. doi:10.1145/2851141.2851152. [15] François Le Gall. Further algebraic algorithms in the congested clique model and applications to graph-theoretic problems. In Cyril Gavoille and David Ilcinkas, editors, Distributed Computing - 30th International Symposium, DISC 2016, Paris, France, September 27-29, 2016. Proceedings, volume 9888 of Lecture Notes in Computer Science, pages 57–70. Springer, 2016. doi:10.1007/978-3-662-53426-7_5. 16

[16] Christoph Lenzen. Optimal deterministic routing and sorting on the congested clique. In Panagiota Fatourou and Gadi Taubenfeld, editors, ACM Symposium on Principles of Distributed Computing, PODC ’13, Montreal, QC, Canada, July 22-24, 2013, pages 42–50. ACM, 2013. doi:10.1145/2484239.2501983. [17] Zvi Lotker, Elan Pavlov, Boaz Patt-Shamir, and David Peleg. MST construction in O(log log n) communication rounds. In Arnold L. Rosenberg and Friedhelm Meyer auf der Heide, editors, SPAA 2003: Proceedings of the Fifteenth Annual ACM Symposium on Parallelism in Algorithms and Architectures, June 7-9, 2003, San Diego, California, USA (part of FCRC 2003), pages 94–100. ACM, 2003. doi:10.1145/777412.777428. [18] William F. McColl and Alexandre Tiskin. Memory-efficient matrix multiplication in the BSP model. Algorithmica, 24(3-4):287–297, 1999. doi:10.1007/PL00008264. [19] Tim Roughgarden, Sergei Vassilvitskii, and Joshua R. Wang. Shuffles and circuits (on lower bounds for modern parallel computation). Journal of the ACM, 65(6):41:1–41:24, 2018. doi:10.1145/3232536. [20] Volker Strassen. Gaussian elimination is not optimal. Numerische Mathematik, 13(4):354– 356, 1969. doi:10.1007/bf02165411.

17