[Paper Review] Distributed Computing on Core-Periphery Networks: Axiom-based Design

Chen Avin, Michael Borokhovich+2 more|arXiv (Cornell University)|Apr 25, 2014

Stochastic Gradient Optimization Techniques35 references4 citations

TL;DR

This paper proposes an axiom-based design for core-periphery (CP) networks to enable efficient distributed computing with low communication overhead and high robustness. By defining three independent algorithmic axioms—core connectivity, efficient message routing, and core-based aggregation—it proves that any network satisfying all three supports optimal O(k) time for tasks like TopK and MST, while showing the axioms are minimal through lower bounds on incomplete axiom sets.

ABSTRACT

Inspired by social networks and complex systems, we propose a core-periphery network architecture that supports fast computation for many distributed algorithms and is robust and efficient in number of links. Rather than providing a concrete network model, we take an axiom-based design approach. We provide three intuitive (and independent) algorithmic axioms and prove that any network that satisfies all axioms enjoys an efficient algorithm for a range of tasks (e.g., MST, sparse matrix multiplication, etc.). We also show the minimality of our axiom set: for networks that satisfy any subset of the axioms, the same efficiency cannot be guaranteed for any deterministic algorithm.

Motivation & Objective

• To address the challenge of designing distributed networks that balance low communication cost, high robustness, and fast algorithmic performance.
• To identify minimal, abstract algorithmic requirements—rather than structural constraints—that ensure efficient distributed computation.
• To demonstrate that core-periphery network architectures satisfy these requirements and support fast algorithms for key tasks like MST and TopK.
• To prove the minimality of the axiom set by showing that violating any single axiom leads to Ω(kn_C) lower bounds on computation time.

Proposed method

• Introduces three independent axioms: A_C (core connectivity), A_B (efficient message routing), and A_E (core-based aggregation), which abstract essential algorithmic properties.
• Uses a core-periphery network model where the core is a dense subgraph and the periphery is sparsely connected to the core, with n_C = Ω(√n) core nodes.
• Employs a randomized message-passing model where nodes communicate in synchronous rounds, and leverages the axioms to design efficient algorithms for TopK and MST.
• Applies Theorem 5 (on message aggregation with M_s and M_r) to bound communication rounds, ensuring O(k) time complexity under the axioms.
• Proves minimality via counterexamples: families of networks violating one axiom but satisfying the others exhibit Ω(kn_C) lower bounds on time complexity.
• Designs Algorithm 8 for the TopK problem, where periphery nodes send values to core, core nodes sort and route top-k values per area, and results are delivered back in O(k) rounds.

Experimental results

Research questions

• RQ1 Can a minimal set of abstract algorithmic axioms be defined that guarantee efficient distributed computation on core-periphery networks?
• RQ2 What are the essential structural and operational properties that enable fast distributed algorithms without relying on specific topologies?
• RQ3 Is the proposed set of axioms minimal—i.e., does violating any single axiom lead to a fundamental performance degradation?
• RQ4 Can core-periphery networks support optimal O(k) time complexity for fundamental distributed tasks like TopK and MST?

Key findings

• Any network satisfying all three axioms (A_C, A_B, A_E) supports an O(k) round algorithm for the TopK problem with high probability.
• The core-periphery architecture enables efficient computation for MST, sparse matrix multiplication, and TopK, with time complexity matching the theoretical lower bound for such tasks.
• The axioms are minimal: for each axiom, there exists a network family violating only that axiom where any deterministic algorithm requires Ω(kn_C) rounds.
• The number of core nodes n_C must be Ω(√n) to ensure the efficiency of the algorithms, as shown in Theorem 2.
• Algorithm 8 achieves O(k) time complexity by leveraging core-based aggregation and routing, with each step bounded by the axioms and Theorem 5 on message passing.
• The proof of minimality relies on constructing specific counterexample networks (e.g., dumbbell networks) that violate one axiom while preserving the others, leading to provably worse performance.