On Solving Problems of Substantially Super-linear Complexity in N o(1) Rounds in the MPC Model
arXiv:2605.03376v1 [cs.DC] 5 May 2026
Andrzej Lingas1 Department of Computer Science, Lund University, Lund, Sweden. [email protected]
Abstract. We study the possibility of designing N o(1) -round protocols for problems of substantially super-linear polynomial-time (sequential) complexity in the model of Massively Parallel Computation, where N is the input size. We show that if the machines are not equipped with relatively large local memory and their number does not exceed N , then the exponent of the average time complexity of the local computation performed by a machine in a round (in terms of local memory size) in such protocols must be larger than the exponent of the time complexity of the given problem.
Keywords: Massively Parallel Computation (MPC), congested clique, number of rounds, sequential time complexity
1
Introduction
The distributed computational and communication model of Massively Parallel Computation (MPC) was introduced by Karloff, Suri, and Vassilvitskii in 2010 [9]. It mirrors several key features of modern large-scale computation systems, such as MapReduce, Hadoop, Dryad, or Spark. The model emphasizes the number of communication phases and the size of local memory while the cost of local computations is less important. Computation and communication proceeds in synchronized rounds. Initially, each machine has access to a distinct part of the input of preferably equal size. More specifically and ideally, if the total input size, measured in machine words, is N and there are m ≤ N machines, then each machine is initially assigned a distinct portion of the input of size roughly N/m. This implies that the size s of local memory assigned to each machine is at least N/m. In each round, each machine can receive messages posted by other machines in the previous round, perform local computations (limited only by the local memory size), and post messages to other machines. The total size of the messages received or sent by a machine in a round is bounded by the local memory size s. The main objective of the modern protocols in the MPC model is to minimize the number of rounds required to solve the input problem. However, this number depends heavily on the size of local memory available to each machine.
To illustrate the issue, let us consider the following approximate protocol for the NP-hard problem of finding k points (called centers) for a set of N input points in a metric space such that the maximum distance from an input point to its closest center is minimized [12]. The protocol is refereed as a 2-round 4approximation algorithm for the k-center problem in the MPC literature and is even used as a subroutine in an almost optimal MPC protocol for this problem [6]. In the first round each of the m machines runs the classic 2-approximation algorithm of Gonzalez [4] on the roughly N/m points assigned to it and sends the k selected centers to the first machine. Gonzalez’s algorithm picks an arbitrary input point as the first center and then repetitively adds the input point that is furthest from the current set of centers to this set until the set contains k points. In the second round, the first machine runs the 2-approximation Gonzalez ’s algorithm on the union of the received k-sets and outputs the resulting k centers for the union. The authors of [12] show that the protocol yields a 4approximation to the k-center problem for the input point set and observe that it can be implemented in two rounds if the local memory available to each machine has size s ≥ max{N/m, √ mk}. This is a√very generous memory requirement. For instance, if m = Θ( N ) and s = Θ( N ) then the delivery of the m k-center sets to the first machine in the first round would already require Ω(k) rounds. √ Moreover, since the first machine would have only O( N ) words of local memory, it would be able to store only O( k1 ) fraction of the k-sets, so the delivery would need to be repeated each time the fist machine adds a new point to the final set of k centers. This would result in Ω(k 2 ) rounds 1 . This example shows how strongly the round complexity depends on the size of allocated local memory and strongly suggests that upper bounds on the number of rounds in the MPC model should always be reported together with the required local memory size s and the number of machines m. So far one has succeeded to design very fast, i.e., O(1)-round, protocols for among other things sorting, searching, some geometric and geometric-graph problems in the MPC model [2, 5]. On the other hand, several problems including connectivity and distinguishing between 1 and 2 cycles are believed to require a non-constant number of rounds in the MPC model. Unfortunately, proving super-constant lower bounds on the number of rounds in the MPC model seems unfeasible as it would imply a breakthrough in circuit complexity [14]. In the literature, one can find several fast protocols in an alternative roundbased distributed computation model of congested clique. Roughly speaking, the main difference from the MPC model is that there is no limit on the size of local memory; however, the data that a machine can send or receive is more structured. In a single round, each machine can receive a message of logarithmic 1
In such scenario, the following straightforward (2k − 1)-round implementation of the 2-approximation Gonzalez’s algorithm could be better: in the (2i − 1)-th round the first machine selects the i-th center and if i < k sends it to each other machine, if i < k in the 2i-th round each machine selects a furthest point to the current center set among the points assigned to it and sends the selected point to the first machine. It would require only O(max{N/m, n, k}) local space.
2
size (with respect to the input size) from each other machine and likewise can send a logarithmic-size message to each other machine. As in the MPC model, the input is approximately equally partitioned among the machines. The number of machines is typically about the square root of the input size. The models of MPC and congested clique are, in general, quite different. For example, as the number of machines increases, the amount of data that a machine can exchange in a single round tends to decrease in the MPC model, whereas it increases in the congested clique model. The two models are most similar when both the number of machines and the size of local memory (the latter in the MPC model) are about the square root of the input size. In this regime, an MPC protocol can be efficiently simulated on the congested clique by using Lenzen’s O(1)-round routing protocol on the congested clique [10]. A reverse efficient simulation requires a large local memory size, at least proportional to the number of machines [7]. There are known fast protocols, even O(1) round ones, for several dense graph problems [13], for sorting and routing [10], and for certain geometric problems [8] on the congested clique. Om the other hand, for such fundamental problems as matrix multiplication and all-pairs shortest path, only O(N δ )-round protocols are currently known in this model [3], where N is the input size and δ is a positive constant. Observe that the known sequential algorithms for these problems run in substantially super-linear time. Proving Ω(N δ ) lower bounds on the round complexity in the congested clique model, for any δ > 0, is currently unfeasible, as such bounds would also imply a breakthrough in circuit complexity [14]. Recently, a simple argument was given in [11] showing that protocols for ℓ o(1) problems with sequential time complexity √ O(N ), where ℓ > 1, that run in N rounds on the congested clique with O( N )) nodes must perform local computations whose average time complexity has an exponent strictly larger than ℓ. Since the congested clique model imposes no restrictions on local computation, this result does not rule out the existence of fast protocols for problems with substantially super linear sequential complexity, it merely indicates that, if such protocols exist, then they must be quite involved. In this paper, we generalize and adopt the argument from [11] to the MPC model. The following example illustrates the main idea behind the adapted argument. Suppose we have some computational problem for which the best known sequential algorithm runs in N ψ time, where N is the input size and ψ > 1. Now √ suppose that we attempt to solve this problem in the MPC model, using m =√ N machines, each equipped with local memory of size s = Θ(N/m) = Θ( N ), in O(1) rounds. Clearly, the m machines must jointly perform Ω(N ψ ) units of work within the O(1) rounds. Hence on average, a machine has to perform 1 Ω(N ψ /m) = Ω(N ψ− 2 ) units of work. Otherwise, there would exist a faster sequential algorithm for this problem. Thus, the average time complexity of the local computation performed by a machine in a single round, expressed in terms of s, is Ω(s2ψ−1 ) while the fastest known sequential algorithm for this problem runs in O(N ψ ) time. Note that 2ψ − 1 > ψ under the assumption ψ > 1. Consequently, the asymptotic time complexity of the local computation 3
performed by a machine in a single round on average is higher than that of the fastest known sequential algorithm for this problem. While this does not yield a contradiction with the MPC model - since the model restricts only local memory, not local computation, it suggests that an O(1)-round solution to this problem in the assumed MPC setting (if it exists at all) must be highly non-trivial. In particular, it indicates that such a protocol would involve local computations that are asymptotically substantially more complex (in terms of the size of local memory) than just solving some sub-problems of asymptotic time complexity not exceeding that of the original problem. Note that the argument in the example above still applies even when the size of local memory s is N w , where w is a constant ≥ 12 , while the number of √ ψ− 1 ψ− 1 machines remains ≈ N , provided that w 2 > ψ, i.e., w < ψ 2 . Our results follow from a straightforward generalization and formalization of the example above covering: – arbitrary problems with substantially super-linear polynomial-time complexity O(N ψ ) (at present), – N o(1) -round protocols in the MPC model with m ≤ N machines and local N m memory size s = N w+o(1) , where 1 − logN m ≤ w < ψ−log , and ψ – even N δ -round protocols in this model for sufficiently small δ depending on the time complexity of the problem.
2
The Formalized Argument
We formulate our argument in the MPC model with m ≤ N machines, each equipped with local memory of size s ≥ N/m, where N denotes the input size. We assume that the work done by a protocol within t rounds in the MPC model is the total sequential time taken by the local computations of all m machines during these t rounds, measured in the unit-cost Random Access Machine model with computer words of logarithmic length [1]. Specifically, we assume that receiving or sending k words in a round requires Θ(k) work. For a problem P solvable in sequential time polynomial in the input size N, we define the exponent opt(P ) of the (sequential) time complexity of P as the smallest real number not less than 1, such that the problem is known to be solvable in O(N opt(P )+ϵ ) sequential time for any positive ϵ. Consider a protocol B that solves the problem P using tB (N, m, s) rounds and performing total work wB (N, m, s) in the MPC model with m machines, each equipped with local memory of size s. We define the lower bound ave(B) on the exponent of the average local time complexity of the protocol B (for a machine in wB (N,m,s) = O(save(B)+ϵ ) a round in terms of s) as the smallest real such that m×t B (N,m,s) for any positive ϵ. In this definition, we assume the upper bound of s on the maximal worst-case size of the data received by a machine before the current round, noting that the initial input data has size only N/m ≤ s.
4
Theorem 1. Consider a problem P solvable in polynomial time and a protocol B that solves an input instance of P of size N using tB (N, m, s) rounds in the model of MPC with m ≤ N machines equipped with local memory of size s. If ave(B) is well defined then the following inequality holds: ave(B) ≥
opt(P ) − logN m − logN tB (N, m, s) − o(1) . logN s
Proof. Let wB (N, m, s) be the total work performed by protocol B within its tB (N, m, s) rounds. By the definition of wB (N, m, s), the problem P can be solved in O(wB (N, m, s)) sequential time. Indeed, we may simulate the protocol sequentially, round by round. In each round, we perform the local computations of the machines, one after another, using O(s) registers to fetch the messages sent to the current machine in the previous rounds and to post new messages, respectively. Hence, by the definition of opt(P ) and the fact that P can be solved in O(wB (N, m, s)) time, we obtain wB (N, m, s) ≥ N opt(P )−o(1) . N opt(P )−o(1) . By the definition of ave(B), we therefore obtain save(B) ≥ m×t B (N,m,s) Consequently, we have N ave(B) logN s ≥ N opt(P )−logN m−logN tB (N,m,s)−o(1) . ⊔ ⊓
Taking logarithms yields the theorem. By straightforward calculations, we obtain the following corollaries.
Corollary 1. If tB (N, m, s) ≤ N o(1) and s = N w+o(1) , where w is a constant )−logN m , then ave(B) > opt(P ). satisfying 1 − logN m ≤ w < opt(Popt(P ) Corollary 2. If tB (N, m, s) ≤ N δ+o(1) , where δ is a non-negative constant satisfying δ < (1 − logN s)opt(P ) − logN m, then ave(B) > opt(P ). Proof. By Theorem 1, it suffices to solve the inequality obtained by substituting δ+o(1) for logN tB (N, m, s) in the right-hand side of the inequality in Theorem 1 and requiring that this expression exceeds opt(P ). The stated condition on δ follows by straightforward calculations. ⊓ ⊔ Our first example concerns matrix multiplication, say P = M M, in the MPC 1 1 model with m = N 2 +o(1) and s = N 2 +o(1) . We have opt(M M ) = ω/2, where ω is the exponent of the fast matrix multiplication [16]. Corollary 1 implies that ave(B) > opt(M M ) whenever tB (N, m, s) = N o(1) and ω > 2. The present upper bound on ω is 2.371552 [16] which yields opt(M M ) < 1.186. Hence, the threshold value of δ in Corollary 2 must be below (1 − 12 )1.186 − 12 ≤ 0.093 in the case of matrix multiplication. Note that the fastest known protocol for multiplying two n × n matrices on the corresponding congested clique with n = 1 N 2 nodes uses O(n0.157 ) rounds [3], i.e., O(N 0.0785 ) rounds. Thus, the exponent of the round complexity of the protocol from [3] lies below the threshold in Corollary 2 for the corresponding MPC model. 5
Generally, the larger opt(P ) is, the larger the gap becomes between ave(B) and opt(P ). This is illustrated in our second example, which concerns the allpairs shortest path problem (APSP) in an edge-weighted graph or digraph on n vertices. 1 Assume P = AP SP and again consider the MPC model with m = N 2 +o(1) 1 and s = N 2 +o(1) . No truly subcubic-time sequential algorithm for APSP is known [15]. Thus, the best known upper bound on opt(AP SP ) is 1.5. For example, Theorem 1 implies ave(B) > opt(AP SP ) + 0.4, when tB (N, m, s) = N o(1) and opt(AP SP ) = 1.5. The threshold value of δ in Corollary 2 must therefore be 0.25 for APSP. The fastest known protocol for APSP on an n-vertex graph in the congested n-clique model uses O(n1/3 ) rounds [3], i.e., O(N 1/6 ) rounds. Thus, the exponent of the round complexity of the APSP protocol from [3] is also below the threshold in Corollary 2 for the corresponding MPC model. On the other hand, the exponents of the round complexity of the aforementioned fastest known protocols for MM and APSP on the congested n-clique [3] are slightly above the analogous thresholds for congested n-clique presented in [11]. If these protocols could be implemented using almost the same asymptotic 1 1 number of rounds in the MPC model with m = N 2 +o(1) and s = N 2 +o(1) , then the exponent of the average time complexity of the local computations in the implementations would exceed the exponent of the (known) time complexity of the MM or APSP problem, respectively.
3
Final Remarks
If the round complexity of protocol B and the local memory size s satisfy the assumptions of Corollary 1 and/or 2, then the exponent ave(B) of the average local computation time of B has to be strictly greater than the exponent of the time complexity of the input problem P. This does not rule out the existence of such an MPC protocol B; rather, it suggests that any such protocol would necessarily be highly non-trivial. Of course, higher local computation complexity might arise when certain computations are duplicated across multiple machines in order to reduce communication. However, this scenario can be handled by disregarding duplicating computations in the definition of ave(B) without affecting the validity of the argument. Note also that the limit s on the size of local memory could be replaced just by the (implied) limit s on the size of data that a single machine can take to the next round, again without affecting the validity of the argument. Current research in the MPC and congested-clique models is heavily focused on designing very "fast" protocols, preferably of O(1) round complexity. This focus effectively restricts attention to problems with linear or near-linear sequential time complexity (assuming the number of machines does not exceed the input size). This is unfortunate, because problems of substantially super-linear sequential complexity are equally important and, in fact, need even more parallel speedup. One reason for this narrow focus is the absence of at least logarithmic lower bounds on round complexity for natural problems. O(1)-round protocols 6
are easy to publish because they are nearly optimal, while polynomial-round upper bounds for problems of super-linear sequential complexity appear hardly attractive because of the absence of stronger lower bounds on round complexity. Since proving such lower bounds is highly unlikely, the thresholds from Corollaries 1 and 2 could serve as a reference point for evaluating polynomial-round upper bounds for problems of substantially super-linear complexity. In this way, they could help broaden the current narrow focus of MPC research and stimulate progress on a wider class of problems.
References 1. A. Aho, J. Hopcroft, and J. Ullman. The Design and Analysis of Computer Algorithms. Addison-Wesley Publishing Company, Reading, 1974. 2. S. Behnezhad, M. Charikar, W. Ma, and L.-Y. Tan. Almost 3- approximate correlation clustering in constant rounds. In Proceedings of the 63rd IEEE Annual Symposium on Foundations of Computer Science (FOCS), pages 720–731. IEEE, 2022. 3. K. Censor-Hillel, P. Kaski, J. H. Korhonen, C. Lenzen, A. Paz, and J. Suomela. Algebraic methods in the congested clique. Distributed Computing, 32(6):461–478, 2019. 4. T. Gonzalez. Clustering to minimize the maximum intercluster distance. Theoretical Computer Science, 38:293–306, 1985. 5. M. Goodrich, N. Sitchinava, and Q. Zhang. Sorting, searching, and simulation in the MapReduce framework. In Proceedings of the 22nd Interna- tional Symposium on Algorithms and Computation (ISAAC), pages 374–383. Springer, 2011. 6. A. Haqi and H. Zarabi-Zadeh. Almost optimal massively parallel algorithms for kcenter clustering and diversity maximization. In Proceedings of the 35th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA’23). ACM, 2023. 7. J. W. Hegeman and S. V. Pemmanraju. Lessons from the congested clique applied to mapreduce. Theoretical Computer Science, 608:268–281, 2015. 8. J. Jansson, C. Levcopoulos, A. Lingas, V. Polishchuk, and Q. Xue. Deterministic protocols for voronoi diagrams and triangulations of planar point sets on the congested clique. Theoretical Computer Science, 105:115491, 2025. 9. H. Karloff, S. Suri, and S. Vassilvitskii. A model of computation for mapreduce. In Proceedings of the Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2010), pages 938–948. ACM-SIAM, 2010. 10. C. Lenzen. Optimal deterministic routing and sorting on the congested clique. In Proceedings of the 2013 ACM Symposium on Principles of Distributed Computing (PODC 2013), pages 42–50. ACM, 2013. 11. A. Lingas. A note on solving problems of substantially super-linear complexity in no(1) rounds of the congested clique. Parallel Processing Letters, 35, 2026. 12. G. Malkomes, M. Kusner, W. Chen, K. Weinberger, and B.Moseley. Fast distributed k-center clustering with outliers on massive data. Advances in Neural Information Processing Systems 28 (NIPS 2015), 2015. 13. K. Nowicki. A deterministic algorithm for the MST problem in constant rounds of congested clique. In Proceedings of the Fifty-Third Annual ACM SIGACT Symposium on Theory of Computing (STOC 2021), pages 1154–1165. ACM, 2021. 14. T. Roughgarden, S. Vassilvitskii, and J. Wang. Shuffles and circuits (on lower bounds for modern parallel computation). Journal of the ACM, 65(6), 2018.
7
15. V. V. Williams and R. Williams. Subcubic equivalences between path, matrix, and triangle problems. Journal of the ACM, 65, 2008. 16. V. V. Williams, Y. Xu, Z. Xu, and R. Zhou. New bounds for matrix multiplication: from alpha to omega. In Proceedings of the Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2024). ACM-SIAM, 2024.
8