⚡ electrical engineering

Affine-coupled Distributed Optimization via Distributed Proximal Jacobian ADMM with Quantized Communication

This paper proposes a distributed optimization algorithm for resource allocation over directed graphs with limited bandwidth that combines Proximal Jacobian ADMM with finite-level quantized consensus, achieving sublinear convergence to a quantization-bounded neighborhood of the optimal solution.

Original authors: Xu Du, Boyu Han, Ivano Notarnicola, Karl H. Johansson, Apostolos I. Rikos

Published 2026-04-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Xu Du, Boyu Han, Ivano Notarnicola, Karl H. Johansson, Apostolos I. Rikos

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a massive team of 100 chefs working in separate kitchens across a city. Their goal is to bake a single, giant cake together.

Here's the catch:

The Recipe is Split: Each chef has their own special ingredient (a local objective) and a specific task.
The Constraint: The total amount of flour, sugar, and eggs used by all chefs combined must equal exactly one specific amount (the global constraint). If they use too much or too little, the cake fails.
The Problem: They can't just shout their numbers across the city. The "phone lines" (communication bandwidth) are narrow and clogged. If they try to send precise, high-definition numbers (like "12.3456789 grams"), the lines get jammed, and the process slows down or crashes.
The Old Way: Usually, they would need a Head Chef in a central tower to collect everyone's numbers, do the math, and tell them what to do next. But if the Head Chef gets sick or the tower is too far, the whole operation stops.

The Solution: The "Rough Sketch" Team

This paper introduces a new way for these chefs to work together without a Head Chef and without clogging the phone lines. They use a method called QDPJ-ADMM (a fancy name for a specific math algorithm).

Here is how it works, broken down into simple metaphors:

1. The "Rough Sketch" (Quantization)

Instead of sending precise numbers like "12.3456789," the chefs agree to only send rough estimates or "chunks."

The Metaphor: Imagine instead of saying "12.3456789," they just say "12" or "13." They round their numbers to the nearest whole number (or a specific level of detail).
Why? It's like sending a low-resolution sketch instead of a 4K photo. It takes up way less space on the phone line.
The Trade-off: The cake won't be perfectly precise (it might be slightly off), but the team can keep working much faster because the lines aren't clogged. The paper proves that if you make the "chunks" smaller (higher precision), the cake gets closer to perfect, but you need slightly more bandwidth.

2. No Head Chef (Fully Distributed)

In the old days, everyone waited for the Head Chef to say, "Okay, Chef 1, you have too much flour; Chef 2, you have too little."

The New Way: The chefs talk only to their immediate neighbors.
The Metaphor: It's like a game of "Telephone," but with a twist. Instead of just passing a message, they are constantly adjusting their own ingredients based on what their neighbors tell them.
The Magic: Even though they only talk to neighbors, the "rough sketches" they pass around eventually average out so that the entire city knows the total amount of ingredients used. They reach a consensus without a central boss.

3. The "Jacobian" Dance (Parallel Processing)

In many old methods, chefs had to wait for Chef 1 to finish, then Chef 2, then Chef 3 (like a line at the DMV).

The New Way: This algorithm uses a "Jacobian" approach, which means everyone works at the same time.
The Metaphor: Imagine all 100 chefs chopping vegetables simultaneously. They don't wait for each other. They make a guess, adjust based on their neighbors' rough sketches, and then make a new guess. They do this in parallel, which makes the whole process incredibly fast.

4. The "Two-Layer" System

The algorithm is smart enough to separate the "thinking" from the "talking."

Layer 1 (The Thinking): Each chef does their own math to figure out the best local move.
Layer 2 (The Talking): They use a special, efficient protocol to share their "rough sketches" until everyone agrees on the global total.
Why it helps: This keeps the math clean and the communication efficient.

The Results: What did they find?

The researchers ran simulations (computer tests) to see if this "Rough Sketch" team could actually bake a good cake.

Speed: They were much faster than teams trying to send perfect numbers because the phone lines weren't clogged.
Accuracy: The cake wasn't perfectly precise, but it was good enough. The paper proved mathematically that the "imperfection" is directly tied to how rough the sketches were. If you want a better cake, just use slightly finer sketches (more bits of data).
Robustness: Because there is no Head Chef, if one chef drops out or a phone line breaks, the rest of the team keeps working. The system is resilient.

The Bottom Line

This paper is about teaching a large group of computers (or robots, or sensors) to solve a complex puzzle together without needing a central boss and without needing super-fast internet.

They do this by agreeing to communicate in "low-resolution" (quantized) messages. It's a bit like playing a game where you only speak in short, simple words, but you speak them so efficiently that you can still build a skyscraper together. It's a perfect balance between speed (saving bandwidth) and quality (getting a good solution).

1. Problem Formulation

The paper addresses the distributed resource allocation optimization problem over directed graphs (digraphs) where communication bandwidth is limited.

Objective: Minimize the sum of local convex objective functions $f_i(x_i)$ across $N$ nodes.
Constraint: The local decision variables $x_i$ are coupled via a global affine equality constraint:
$\sum_{i=1}^N A_i x_i = b$
Challenge: Traditional distributed optimization algorithms (like ADMM) typically require nodes to exchange real-valued messages, which creates a bandwidth bottleneck in large-scale networks. Furthermore, existing quantized consensus methods often fail when applied to resource allocation problems because the affine coupling constraints break the symmetry required by standard consensus protocols.
Goal: Develop a fully distributed algorithm that solves this problem using quantized communication (finite-bit messages) while maintaining convergence guarantees.

2. Methodology

The authors propose a novel algorithm called Quantized Distributed Proximal Jacobian ADMM (QDPJ-ADMM). The approach integrates the centralized Proximal Jacobian ADMM (PJ-ADMM) framework with a finite-level quantized consensus scheme.

Key Architectural Features:

Two-Layer Architecture:
- Outer Layer (Optimization): Handles the primal-dual variable updates based on the PJ-ADMM framework. Each node solves a local sub-problem involving a proximal regularization term.
- Inner Layer (Coordination): Implements a Distributed Finite-time Quantized Average Consensus (DFQAC) algorithm (based on Rikos et al., 2022) to estimate the global residual of the affine constraints. This layer decouples the optimization steps from the averaging process.
Algorithm Flow (per iteration $k$ ):
- Local Optimization: Each node $i$ updates its local variable $x_i^{[k+1]}$ by minimizing a local augmented Lagrangian function using its current local estimate of the global dual variable and constraint residual.
- Quantized Consensus: Nodes exchange information regarding the constraint residual ( $\phi_i = N(A_i x_i - b)$ $ϕ_{i} = N (A_{i} x_{i} - b)$ ) using a quantized averaging protocol. This protocol involves:
  - Quantizing values using an asymmetric mid-rise quantizer.
  - Splitting quantized values into integer pieces and transmitting them to neighbors.
  - Performing max-min consensus every $D$ time steps (where $D$ is the graph diameter) to ensure finite-time convergence of the average estimate.
- Dual Update: Nodes update their local copies of the dual variable $\lambda$ using the estimated global residual from the consensus layer.
Quantization Mechanism:
- The paper utilizes a quantizer $q_\Delta^a(b) = \lfloor b/\Delta \rfloor$ , where $\Delta$ is the quantization level.
- The algorithm is designed to handle the error introduced by this quantization, ensuring that the solution converges to a neighborhood of the optimum determined by $\Delta$ .

3. Key Contributions

First Integration of PJ-ADMM with Quantized Consensus: To the authors' knowledge, this is the first work to integrate PJ-ADMM with a fully distributed quantized consensus scheme specifically for affine-coupled resource allocation problems.
Handling Directed Graphs: The algorithm operates effectively over directed graphs, a more challenging topology than undirected graphs due to the lack of symmetry in information flow.
Theoretical Convergence Guarantees:
- The paper proves that under convex objective functions, the algorithm achieves sublinear convergence ( $O(1/K)$ ) to a neighborhood of the optimal solution.
- The size of the convergence neighborhood is explicitly bounded by the quantization level $\Delta$ . As $K \to \infty$ , the error is dominated by $O(\Delta)$ .
Communication Efficiency: By using quantized messages, the algorithm significantly reduces bandwidth requirements compared to real-valued transmission, making it scalable for large networks.

4. Results

Theoretical Analysis:
- Theorem 1 establishes that the Lagrangian function values converge to a neighborhood of the saddle point.
- Corollary 1 shows that the average squared difference between consecutive iterates is bounded by $O(1/K) + O(\Delta)$ .
- The analysis confirms that the quantization error does not prevent convergence but limits the final precision.
Numerical Simulations:
- Experiments were conducted on a random directed graph with $N=100$ nodes.
- Comparison: The proposed QDPJ-ADMM was compared against the centralized PJ-ADMM (with quantization) and standard real-valued transmission.
- Findings:
  - The algorithm converges to a neighborhood of the optimal solution.
  - Trade-off: Smaller quantization levels ( $\Delta$ ) yield higher accuracy but require more bits; larger $\Delta$ reduces bandwidth but increases the final error floor.
  - The proposed method outperforms centralized schemes in terms of communication efficiency while maintaining competitive convergence speed.

5. Significance

This work bridges a critical gap in distributed optimization by addressing the bandwidth-constrained nature of modern networked systems (e.g., IoT, federated learning, smart grids).

Scalability: By eliminating the need for a central coordinator and real-valued communication, the method is highly scalable.
Robustness: The use of quantized consensus makes the system robust to communication errors and interference, a common issue in wireless networks.
Theoretical Foundation: It provides a rigorous mathematical framework for analyzing how quantization noise affects the convergence of complex, coupled optimization problems, moving beyond simple consensus problems.

In summary, the paper presents a practical and theoretically sound solution for solving large-scale, constrained optimization problems in bandwidth-limited, directed network environments.