Iterative Graph Balancing

• Iterative Graph Balancing is a family of techniques that adjust local graph variables, such as flows and weights, to reduce a global notion of imbalance.
• These methods range from exact integer circulation and node-weight recursions to matching-based load averaging and LP rounding approximations.
• They leverage distributed algorithms, spectral analysis, and combinatorial invariants to link local adjustments with global performance guarantees.

Searching arXiv for the cited works on iterative graph balancing and closely related formulations. Iterative graph balancing denotes a family of graph-theoretic, distributed, and combinatorial procedures in which local variables are repeatedly updated to reduce a global notion of imbalance. In the papers considered here, the balanced object may be an integer circulation on a digraph, a vector of node weights compensating for directed asymmetry, vertex loads induced by repeated pairwise exchanges, weighted in-degrees created by orienting edges, boundary degrees along a balanced merge tree, or red/blue edge counts inside a copy of a graph. The term is therefore not attached to a single canonical problem; it refers to several technically distinct iteration schemes that share repeated local adjustment toward a global balancing condition (Rikos et al., 2019, Makhdoumi et al., 2016, Berenbrink et al., 17 Oct 2025).

1. Principal formulations

Across these works, the state variable, feasibility constraints, and meaning of “balanced” vary substantially.

Setting	Balanced quantity	Iterative mechanism
Directed integer circulation	Node balances $b_j=f_j^- - f_j^+$ vanish	Distributed edge-weight updates
Directed optimization/consensus	$$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$	Linear node-weight recursion
Node-balancing by edge increments	All vertex weights equal	Repeated edge increments
Discrete load balancing	Load discrepancy becomes small	Matching-based pairwise averaging
Orientation balancing	Maximum weighted in-degree is minimized	Orientation, rounding, or local search
Balanced reassembling	Minimum-height binary merge tree	Bottom-up pairwise merges
Balanced-copy theory	A copy has evenly divided red/blue edges	Structural forcing in 2-colorings

The first distinction is between exact balancing and optimization-based balancing. In distributed circulation and edge-increment models, the objective is an exact equalization condition. In orientation-based graph balancing, by contrast, the objective is to minimize the maximum weighted in-degree rather than to make all local quantities equal. A second distinction is between edge-state, node-state, and cluster-state models: some papers update edge flows, others node weights or loads, and others a hierarchical decomposition tree. A third distinction concerns algorithmic regime: some methods are finite-time distributed algorithms under communication failures, some are linear recursions analyzed by Perron–Frobenius theory, some are strongly polynomial reductions to perfect $b$-matching, and some are NP-hard optimization problems or LP-based approximation schemes (Rikos et al., 2019, Eisenbrand et al., 2015, Mirzaei et al., 2016, Schwartz et al., 2021).

2. Constrained circulation on directed graphs

A particularly concrete formulation studies iterative graph balancing as distributed synthesis of an integer circulation on a strongly connected digraph $\mathcal G_d=(\mathcal V,\mathcal E)$, where each directed edge $(v_j,v_i)$ carries an integer flow $f_{ji}\in\mathbb N$ subject to interval constraints $0<l_{ji}\le f_{ji}\le u_{ji}$. Under the paper’s convention, $(v_j,v_i)$ represents possible flow from $v_i$ to $v_j$. For node $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$0, the inflow, outflow, and balance are

$$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$1

The graph is weight-balanced, or flow-balanced, iff $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$2 for every node. Because communication may be delayed, the algorithm also tracks perceived incoming flows $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$3, perceived inflow $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$4, and perceived balance $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$5. The global imbalance measures are $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$6 and $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$7, with the conservative inequality $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$8 playing a central role in the convergence proofs (Rikos et al., 2019).

Feasibility is characterized exactly by integer circulation conditions. For every edge, the admissible integer interval must be nonempty: $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$9 For every proper subset $b$0, the cut condition

$b$1

is necessary and sufficient for the existence of a feasible integer balanced assignment. This places the problem squarely in the theory of circulations with lower and upper bounds: the algorithm is not balancing unconstrained real weights, but constructing a feasible integer circulation under box constraints.

The bounded-delay algorithm is synchronous in iteration index $b$2, but not in information freshness. Each node knows the true values of its outgoing-edge variables and only perceived values of incoming-edge variables. If $b$3, node $b$4 does nothing. If $b$5, it tries to eliminate its positive excess by decreasing incoming flows and increasing outgoing flows one unit at a time, subject to edge bounds and a fixed round-robin order on incident edges. Delayed change aggregation enters through terms such as

$b$6

and the updates are

$b$7

$b$8

followed by projection onto $b$9. A second algorithm replaces delayed increments by exchange of desirable full edge values, so that packet drops can be treated as unbounded delays with Bernoulli link successes.

The convergence mechanism is monotone. If $\mathcal G_d=(\mathcal V,\mathcal E)$0, then

$\mathcal G_d=(\mathcal V,\mathcal E)$1

Under bounded delays, the algorithm reaches a balanced feasible integer flow in finite time. Under packet drops with $\mathcal G_d=(\mathcal V,\mathcal E)$2 on every link, finite-time convergence holds with probability one. The proofs are contradiction arguments based on the subset-balance identity

$\mathcal G_d=(\mathcal V,\mathcal E)$3

together with saturation at lower and upper bounds and the cut feasibility condition. The paper explicitly leaves worst-case iteration complexity as future work.

3. Balancing weights for directed consensus and optimization

A second major formulation uses node weights to balance a directed communication graph so that distributed optimization over directed edges behaves as if the mixing were symmetric. For a strongly connected digraph $\mathcal G_d=(\mathcal V,\mathcal E)$4, node weights $\mathcal G_d=(\mathcal V,\mathcal E)$5 balance the graph when

$\mathcal G_d=(\mathcal V,\mathcal E)$6

This is a node-weight balancing notion, not an edge-flow balancing notion. The balancing iteration is

$\mathcal G_d=(\mathcal V,\mathcal E)$7

or in matrix form,

$\mathcal G_d=(\mathcal V,\mathcal E)$8

If the weights converge, the fixed-point equation is exactly the balancing relation (Makhdoumi et al., 2016).

The paper analyzes this recursion via Perron–Frobenius theory. Under strong connectivity, $\mathcal G_d=(\mathcal V,\mathcal E)$9 is primitive, $(v_j,v_i)$0, and $(v_j,v_i)$1, where $(v_j,v_i)$2 balances the graph. The limiting vector is the Perron right eigenvector direction of $(v_j,v_i)$3. A small-initialization lemma ensures positivity of the self-coefficient $(v_j,v_i)$4: if

$(v_j,v_i)$5

then $(v_j,v_i)$6 for all $(v_j,v_i)$7. This condition is not needed for convergence of the weight iteration itself, but it is needed for the coupled optimization dynamics.

The balancing recursion is embedded directly into a distributed subgradient method. Each node updates

$(v_j,v_i)$8

where $(v_j,v_i)$9. The estimate-mixing matrix $f_{ji}\in\mathbb N$0 is column stochastic for every $f_{ji}\in\mathbb N$1, but not doubly stochastic at finite time. As $f_{ji}\in\mathbb N$2, the limit matrix $f_{ji}\in\mathbb N$3 becomes row stochastic as well, hence doubly stochastic. This is the mechanism by which balancing removes the asymmetry of directed communication.

The paper proves that products $f_{ji}\in\mathbb N$4 converge geometrically to averaging: $f_{ji}\in\mathbb N$5 A special case with $f_{ji}\in\mathbb N$6 yields average consensus over directed graphs: $f_{ji}\in\mathbb N$7 The broader optimization result is that the ergodic average of the distributed subgradient estimates attains objective-value and consensus-violation convergence rate $f_{ji}\in\mathbb N$8. In this line, iterative graph balancing is therefore an enabling mechanism for consensus and optimization rather than the primary end state.

4. Local transfer models and discrete load balancing

A different exact balancing model begins with an integer node-weight assignment $f_{ji}\in\mathbb N$9 on a graph $0<l_{ji}\le f_{ji}\le u_{ji}$0 and allows the legal move of choosing an edge $0<l_{ji}\le f_{ji}\le u_{ji}$1 and incrementing both endpoints by $0<l_{ji}\le f_{ji}\le u_{ji}$2. The balancing question is whether repeated edge increments can make all vertex weights equal. If edge $0<l_{ji}\le f_{ji}\le u_{ji}$3 is used $0<l_{ji}\le f_{ji}\le u_{ji}$4 times and the final common value is $0<l_{ji}\le f_{ji}\le u_{ji}$5, feasibility is equivalent to

$0<l_{ji}\le f_{ji}\le u_{ji}$6

which is exactly a perfect $0<l_{ji}\le f_{ji}\le u_{ji}$7-matching condition with $0<l_{ji}\le f_{ji}\le u_{ji}$8. The paper gives a structural characterization of graphs for which every assignment is equatable: $0<l_{ji}\le f_{ji}\le u_{ji}$9 must be connected, $(v_j,v_i)$0 must be odd, and for every $(v_j,v_i)$1, the graph $(v_j,v_i)$2 must have fewer than $(v_j,v_i)$3 isolated vertices. It also gives a strongly polynomial-time algorithm that decides whether a given assignment is equatable and constructs a smallest multiset of balancing edge increments. The general graph theory is governed by Tutte’s theorem for perfect $(v_j,v_i)$4-matchings, the bipartite specialization by a strict Hall condition, and the hypergraph analogue is NP-complete (Eisenbrand et al., 2015).

Another iterative model studies discrete load balancing via matchings on an undirected connected graph $(v_j,v_i)$5. Each round chooses a matching $(v_j,v_i)$6, and matched nodes average their token loads; when the sum is odd, the excess token is assigned uniformly at random. The quality measure is the discrepancy

$(v_j,v_i)$7

The paper introduces a height-sensitive token process and proves a precise decomposition of discrete-minus-continuous error into propagated rounding errors. Its main theorem states that, for a broad class of $(v_j,v_i)$8-good matching sequences on arbitrary connected graphs, the process reaches discrepancy at most $(v_j,v_i)$9 and then at most $v_i$0 with high probability after

$v_i$1

rounds. In the balancing circuit and random matching models, this asymptotically matches the standard spectral bound for the corresponding continuous process. The paper emphasizes that, in this general class, discrete load balancing is no harder than continuous load balancing (Berenbrink et al., 17 Oct 2025).

A more specialized use of the term appears in balanced graph reassembling. Here the iterations are not local edge or node updates, but levels of a binary tree $v_i$2 over $v_i$3. A reassembling is balanced iff

$v_i$4

and the objective is to minimize either

$v_i$5

The paper proves that both balanced $v_i$6-optimization and balanced $v_i$7-optimization are NP-hard. In this formulation, “balanced” refers to minimum tree height and maximally parallel pairwise merging rather than to equalized flow or load values (Mirzaei et al., 2016).

5. Orientation balancing, LP rounding, and local search

In the approximation-algorithm literature, graph balancing usually means orienting a weighted undirected graph so as to minimize the maximum weighted in-degree,

$v_i$8

This is a special case of makespan minimization or restricted-assignment scheduling. A two-edge-type case, where edge weights are scaled to $v_i$9 with $v_j$0, admits a tight $v_j$1-approximation. The method is not iterative local rebalancing, but a flow-network construction $v_j$2 followed by threshold-based orientation of big edges and, in the even case, a matching-based repair of unresolved ties. The paper states that approximation better than $v_j$3 is impossible even with only two edge sizes, so the $v_j$4 result settles that special case (Chakrabarty et al., 2016).

The addition of orientation costs produces a bicriteria problem: minimize both makespan and total orientation cost. A strengthened LP $v_j$5, with local set constraints

$v_j$6

supports a two-phase rounding framework. First, edges with sufficiently strong fractional preference $v_j$7 are locally committed; second, the residual instance is completed by Shmoys–Tardos rounding. This yields tradeoffs such as

$v_j$8

and

$v_j$9

The framework extends to variants with hyperedges and unrelated weights, and the paper also gives LP-based lower bounds showing that if one wants approximation better than $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$00 in the makespan, some loss in total orientation cost is unavoidable (Schwartz et al., 2021).

A more explicitly iterative line uses local search and the configuration LP. The paper proving an integrality-gap bound of $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$01 maintains an ordered list of pending flips, dynamically repelled edges, and two types of pending flips, raw and regular. A regular pending flip is executed only when it is valid with respect to the current target load bound $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$02, where $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$03. If the local search gets stuck while a bad vertex remains, the proof constructs a dual witness $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$04 showing infeasibility of the configuration LP at value $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$05. This establishes that the configuration LP has integrality gap at most $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$06 for graph balancing. The paper explicitly notes, however, that termination in polynomial time is not known, so the $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$07 bound is non-constructive as an approximation algorithm (Jansen et al., 2018).

6. Alternative meanings, boundaries, and recurrent themes

A separate extremal-combinatorial line uses “balancing” to study balanced copies of a fixed graph $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$08 inside a 2-edge-colored complete graph. Here a copy is balanced when its edge set can be partitioned into two evenly divided parts lying in the red and blue color classes, and the central thresholds are the balancing number $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$09 and the list balancing number $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$10. In the list version, edges with list $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$11 act as jokers. The paper proves that every graph has a list balancing number, that $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$12 whenever the former exists, gives exact values for all odd cycles and for $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$13 in the list setting, tight bounds for $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$14, and shows that $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$15. This formulation is structurally related to balancing, but it is not an iterative algorithmic model (Dailly et al., 2020).

The literature surveyed here therefore supports several clarifications. First, “graph balancing” is not terminologically uniform. It may denote exact flow conservation on a digraph, convergence of balancing weights for directed averaging, equalization by edge increments, discrepancy reduction by matching-based token exchanges, optimization of weighted in-degree by orientation, balanced merge trees, or existence thresholds for balanced subgraphs. Second, “iterative” does not always mean local search: it may mean synchronous distributed edge-weight updates, a linear node-weight recursion, repeated pairwise averaging, or simply the level-by-level evolution of a reassembling tree. Third, guarantees range from exact finite-time convergence under feasibility conditions, to strongly polynomial solvability, to spectral-time discrepancy bounds, to bicriteria approximation tradeoffs, to NP-hardness and NP-completeness, depending on the model (Rikos et al., 2019, Eisenbrand et al., 2015, Berenbrink et al., 17 Oct 2025, Mirzaei et al., 2016).

A recurring theme is that apparently local balancing steps are governed by global structure. Integer circulation balancing is possible exactly under cut feasibility conditions. Edge-increment balancing is characterized by perfect $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$16-matchings. Matching-based token averaging is analyzed through mixing matrices and propagated rounding errors. Directed optimization uses balancing weights so that a column-stochastic update becomes asymptotically doubly stochastic. Orientation balancing depends on flow relaxations, configuration LPs, or strengthened local subset constraints. Even the extremal balanced-copy theory reduces threshold questions to families such as $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$17 and extremal numbers $$w_i d_i^{\text{out}}=\sum_{j\in N^{\text{in}}(i)} w_j$$18. This suggests that “iterative graph balancing” is best understood not as a single algorithmic template, but as a collection of graph-structured balancing problems whose iterative dynamics are tightly constrained by feasibility, spectral, matching-theoretic, LP, or extremal-combinatorial invariants.