Nodewise Rebalancing: Local & Global Insights

• Nodewise rebalancing is a local balancing mechanism that adjusts individual node states—such as vehicle potentials or tree occupancies—to preserve critical global invariants.
• It integrates diverse corrective strategies, including rotations in balanced trees, pricing in AMoD systems, and coded exchange in distributed storage, to optimize performance.
• The approach underscores trade-offs involving metadata, coding, and fairness, demonstrating how local operations can harmonize with global planning for improved system reliability.

Nodewise rebalancing denotes a family of local balancing mechanisms in which corrective actions are attached to individual nodes and their immediate incident structure—stations in mobility systems, zones in ride-hailing, tree nodes in dynamic search structures, storage nodes in replicated databases, or vertices in graphs—while preserving a system-level invariant such as flow conservation, bounded height, equal black height, equalized load, replication factor, or zero net wealth. Across the literature, nodewise rebalancing appears both as a purely local operational primitive and as the local execution layer of globally optimized plans (Wollenstein-Betech et al., 2020, Pourdamghani et al., 2023, Krishnan et al., 2020).

1. Scope, locality, and recurrent invariants

A common feature of nodewise rebalancing is that the state variable being corrected is indexed by nodes rather than by global aggregates alone. In Autonomous Mobility-on-Demand (AMoD), the relevant quantity is the node potential $\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$ or its priced variant, and rebalancing chooses empty-vehicle flows $r_{ij}$ so that station-level conservation holds. In SeedTree, the local state is the occupancy of a tree node with capacity $c$, and rebalancing preserves both the per-level item count invariant and the unique-path invariant. In balanced and self-balancing trees, nodewise repair is expressed through rotations, promotions, demotions, or subtree rebuilds triggered by local height, color, or weight conditions. In distributed storage, the nodewise target is equal storage under a fixed replication factor; in payment channel networks, it is zero net flow at every node under a feasible circulation; and in graph balancing by edge-increments, it is equality of terminal node weights (Wollenstein-Betech et al., 2020, Pourdamghani et al., 2023, Jugé, 2024, Krishnan et al., 2020, Avarikioti et al., 2021, Eisenbrand et al., 2015).

Context	Node entity	Local invariant or target
AMoD and ride-hailing	region, station, or zone	station balance, fleet conservation, weighted demand coverage
Self-adjusting and balanced trees	tree node	per-level occupancy, bounded height, child/grandchild balance, black height
Distributed storage	storage node	equal storage and replication factor
Graph and payment networks	vertex or channel node	equal target weight or zero net flow

Locality, however, does not imply absence of global information. The non-recursive P2P load-balancing algorithm invokes one global min/max query per insertion or deletion even though all data movement is performed by NbrAdjust and Reorder. Hide & Seek computes a globally optimal circulation via MPC, but reveals only local incident-edge outputs to participants. Efficient top-down AVL updates read a fixed descendant window at each visited node, then perform only constant-size local transformations without backtracking. A recurrent misconception is therefore that nodewise rebalancing must be greedy or myopic; several of the cited formulations are local in execution but global in planning or certification (Chawachat et al., 2012, Avarikioti et al., 2021, Jugé, 2024).

2. Mobility systems: station balance, pricing, and fairness

In AMoD, nodewise rebalancing is formalized at station level through conservation constraints on customer flows, empty-vehicle repositioning flows, and fleet capacity. The steady-state balance condition is

$$\sum_j \lambda_{ji}(u_{ji}) + \sum_j r_{ji} = \sum_j \lambda_{ij}(u_{ij}) + \sum_j r_{ij}, \quad \forall i,$$

with node potential $\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$ indicating deficit or surplus. The rebalancing-only problem chooses $r_{ij}\ge 0$ to minimize $\sum_{i,j} T_{ij} r_{ij}$ subject to nodewise conservation, while the joint problem chooses prices $u_{ij}$, rebalancing flows $r_{ij}$, and fleet size $m$ so that pricing attenuates $r_{ij}$0 and rebalancing eliminates the residual imbalance. The minimum fleet requirement in steady state is

$r_{ij}$1

and, in the pricing-only case, balance can be enforced directly by the feasible set

$r_{ij}$2

The dynamic fluid model is well posed in the Filippov sense, preserves total fleet size, and yields locally asymptotically stable equilibria when the price vector lies in the balancing set and the fleet exceeds the induced in-transit requirement (Wollenstein-Betech et al., 2020).

The data-driven New York City case study illustrates the operational effect of this nodewise formulation. The joint pricing-plus-rebalancing policy increased profits by approximately $r_{ij}$3–$r_{ij}$4 relative to pricing-only, rebalancing-only, sequential, or origin-only joint baselines, depending on time window and benchmark. The same study reports that pricing alone already reduces average absolute node potential $r_{ij}$5, rebalancing reduces it further, and the joint formulation enforces zero by constraint. It also reports that origin-only surge pricing performs close to OD-aware pricing, within approximately $r_{ij}$6–$r_{ij}$7 in the NYC setting, while destination-aware pricing still yields measurable gains (Wollenstein-Betech et al., 2020).

A fairness-oriented variant appears in ride-hailing rebalancing over Manhattan taxi zones. There, the node is a zone-time pair, the upstream task is fairness-regularized demand prediction via SA-STGCN, and the downstream task is Matching-Integrated Vehicle Rebalancing (MIVR) with nodewise decision variables $r_{ij}$8 for rebalancing and $r_{ij}$9 for matching. Fairness enters through node weights $c$0 derived from a socio-aware graph; higher $c$1 increases the penalty for unmet demand and pickup distance in disadvantaged nodes. In simulation with NYC TLC FHV data, the reported “best efficiency–fairness balance” reduced the standard deviation and average customer wait times by $c$2 and $c$3, respectively, relative to baseline STGCN, while a different hyperparameter setting achieved an $c$4 reduction in cross-zone wait-time variability with a $c$5 increase in average wait time. The paper explicitly notes that fairness is embedded through objective weights rather than hard fairness constraints (Guo et al., 2023).

3. Self-adjusting and multidimensional trees

In SeedTree, nodewise rebalancing is a two-phase local reconfiguration triggered by an access: move the requested item to the root, then push one uniformly random item per level downward along that item’s own LocalRouting choice until level occupancy is restored. Each primitive move affects only a parent and one child, and all modified nodes lie on the accessed item’s path or the attempted push-down path. Two invariants are central: the per-level item count invariant and the unique-path invariant induced by randomized item addresses. These local rules yield the expected MRU bound

$c$6

and, together with a potential-function argument, imply constant competitiveness. For $c$7, the explicit competitive bound is $c$8 (Pourdamghani et al., 2023).

A different local doctrine appears in dynamic $c$9-d trees. Here rotations are disallowed because the split dimension changes with depth, so cyclic node exchange destroys the sorted order of the $$\sum_j \lambda_{ji}(u_{ji}) + \sum_j r_{ji} = \sum_j \lambda_{ij}(u_{ij}) + \sum_j r_{ij}, \quad \forall i,$$0-d tree. Nodewise rebalancing therefore means checking balance as recursion unwinds and rebuilding the entire subtree rooted at any unbalanced node. Balance can follow either an AVL threshold $$\sum_j \lambda_{ji}(u_{ji}) + \sum_j r_{ji} = \sum_j \lambda_{ij}(u_{ij}) + \sum_j r_{ij}, \quad \forall i,$$1 or a red-black-inspired ratio criterion; for very small subtrees, rebuild is constant-time, while larger rebuilds use static $$\sum_j \lambda_{ji}(u_{ji}) + \sum_j r_{ji} = \sum_j \lambda_{ij}(u_{ij}) + \sum_j r_{ij}, \quad \forall i,$$2-d builders in $$\sum_j \lambda_{ji}(u_{ji}) + \sum_j r_{ji} = \sum_j \lambda_{ij}(u_{ij}) + \sum_j r_{ij}, \quad \forall i,$$3 or $$\sum_j \lambda_{ji}(u_{ji}) + \sum_j r_{ji} = \sum_j \lambda_{ij}(u_{ij}) + \sum_j r_{ij}, \quad \forall i,$$4. The reported aggregate timings for inserting, deleting, and searching random points are $$\sum_j \lambda_{ji}(u_{ji}) + \sum_j r_{ji} = \sum_j \lambda_{ij}(u_{ij}) + \sum_j r_{ij}, \quad \forall i,$$5 empirically, and insertion into the dynamic structure is approximately $$\sum_j \lambda_{ji}(u_{ji}) + \sum_j r_{ji} = \sum_j \lambda_{ij}(u_{ij}) + \sum_j r_{ij}, \quad \forall i,$$6 slower than static balanced $$\sum_j \lambda_{ji}(u_{ji}) + \sum_j r_{ji} = \sum_j \lambda_{ij}(u_{ij}) + \sum_j r_{ij}, \quad \forall i,$$7-d tree construction performed en masse (Brown, 9 Sep 2025).

The negative side of strictly local repair is made explicit by randomized bottom-up BST rebalancing without auxiliary metadata. RebalanceZig and RebalanceZigZag choose an action point by a geometric coin-flip climb from the newly inserted leaf, then perform at most one or two rotations. The schemes have expected $$\sum_j \lambda_{ji}(u_{ji}) + \sum_j r_{ji} = \sum_j \lambda_{ij}(u_{ij}) + \sum_j r_{ij}, \quad \forall i,$$8 time and expected $$\sum_j \lambda_{ji}(u_{ji}) + \sum_j r_{ji} = \sum_j \lambda_{ij}(u_{ij}) + \sum_j r_{ij}, \quad \forall i,$$9 random bits per insertion, with action distance distribution $\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$0, yet they are not robust across insertion orders. For increasing or decreasing sequences, both schemes can yield $\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$1; for finger sequences, RebalanceZigZag attains the same when $\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$2. By contrast, the converging sequence forces $\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$3 expected average depth for Zig, and the pairs sequence forces $\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$4 expected average depth for both Zig and ZigZag. This establishes that local randomized nodewise repair without metadata is not, by itself, a guarantee of logarithmic shape (Brodal, 2024).

4. Weight balance, AVL repair, and red-black deletion

Grand-children weight-balanced binary search trees strengthen classical weight-balanced trees by imposing both child and grandchild inequalities. For a node $\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$5,

$\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$6

and nodewise rebalancing is realized by local A(u,v) and B(w) bricks, followed by the composite AB(u,v,w), which choose simple or double rotations according to heavy-child or heavy-grandchild inequalities in the immediate neighborhood. The resulting grand-children balanced trees are reported to have a smaller node depth than standard weight-balanced trees, with a $\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$7 decrease in the worst case and a $\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$8 decrease on average; in particular, all such trees with $\zeta_i := \sum_j \lambda_{ij}-\lambda_{ji}$9 nodes have height less than $r_{ij}\ge 0$0. Away from critical parameter boundaries, both the bottom-up and top-down maintenance algorithms perform a constant amortised number of rotations per update (Jugé, 2024).

Efficient top-down AVL updates recast nodewise rebalancing as local repair with fixed look-ahead. During descent, the algorithm inspects a bounded window of descendants, identifies insertion-safe or efficient-deletion-safe nodes, and, if necessary, creates a safe node deeper in the path and propagates exactly one imbalance signal—a zero-edge after insertion or a four-node after deletion—up only through the prepared window. The terminal repair at the top of the window is a constant-size rotation, promotion, demotion, or cut rebalancing, after which descent continues without backtracking. With fixed look-ahead, eventually instantiated with $r_{ij}\ge 0$1, the algorithm achieves $r_{ij}\ge 0$2 time per update and $r_{ij}\ge 0$3 amortized memory writes per update while preserving the strict AVL invariant $r_{ij}\ge 0$4 (Jugé, 2024).

Red-black deletion supplies a complementary example in which the nodewise object being rebalanced is not height but black height. The symbolic-arithmetic formulation introduces the temporary color [DB](https://www.emergentmind.com/topics/differentiable-binarization-db-model) for double-black and encodes local fix-up through rewrite rules such as

$r_{ij}\ge 0$5

The canonical propagation step applies $r_{ij}\ge 0$6 to the double-black node and its sibling while adding $r_{ij}\ge 0$7 to the parent; rotations are used only to convert near-child-red configurations into far-child-red configurations that admit one-step elimination of the double-black. This formulation preserves equal black height on all root-to-leaf paths and terminates in $r_{ij}\ge 0$8 time, but its significance in the cited work is chiefly pedagogical: the paper presents it as a simplified method for teaching double-black removal and rebalancing in red-black trees (Ehimwenma et al., 2023).

5. Distributed storage and database rebalancing

In replication-based distributed storage, nodewise rebalancing concerns single-node addition or removal under the constraint that every data bit be replicated exactly $r_{ij}\ge 0$9 times and that node storage remain uniform. For the structurally invariant class of $\sum_{i,j} T_{ij} r_{ij}$0-balanced databases, node addition is handled by a split–send–delete procedure and node removal by coded exchange among the surviving nodes. The optimal loads are

$\sum_{i,j} T_{ij} r_{ij}$1

and the combined optimal rebalancing load for single-node events is

$\sum_{i,j} T_{ij} r_{ij}$2

Node removal achieves the $\sum_{i,j} T_{ij} r_{ij}$3 factor by grouping lost-replica subfiles and transmitting one XOR per participant within each group; node addition is uncoded because the new node must receive its full target storage volume in any case. The same work emphasizes structural invariance: after rebalancing, the database over $\sum_{i,j} T_{ij} r_{ij}$4 nodes has the same essential placement structure as the original (Krishnan et al., 2020).

The decentralized random-placement variant reaches the same asymptotic loads without centralized initial design. Each bit is initially stored on a uniformly random $\sum_{i,j} T_{ij} r_{ij}$5-subset of nodes, yielding a decentralized $\sum_{i,j} T_{ij} r_{ij}$6-balanced database with expected per-node storage fraction $\sum_{i,j} T_{ij} r_{ij}$7. For single-node removal, random binning creates coded packets whose sizes are binomially distributed, and the expected communication load converges to $\sum_{i,j} T_{ij} r_{ij}$8 as $\sum_{i,j} T_{ij} r_{ij}$9; for single-node addition, uncoded transmission yields load $u_{ij}$0, which is again optimal by cut-set reasoning. The post-rebalancing placement remains decentralized and $u_{ij}$1-balanced because the scheme preserves uniformity over $u_{ij}$2-subsets of the surviving or augmented node set (Sree et al., 2020).

Cyclic storage replaces random or factorial-scale placement with a ring structure: packet $u_{ij}$3 is stored at the $u_{ij}$4 consecutive nodes

$u_{ij}$5

This enables explicit nodewise rebalancing rules with only cubic file-size, specifically $u_{ij}$6 bits under the sufficient divisibility condition stated in the paper. For single-node removal, the scheme splits corner and middle packets into carefully sized subpackets, then uses XORs chosen so that each intended receiver knows all but one term. The resulting load is strictly smaller than the uncoded baseline $u_{ij}$7, although the paper does not claim global optimality for removal under cyclic placement. For single-node addition, the scheme is uncoded and optimal, with

$u_{ij}$8

The cited comparison with earlier optimal coded schemes is notable: cyclic placement sacrifices tight optimality guarantees for removal but reduces file-size from exponential to cubic (Vaishya et al., 2022).

6. Range partitions, graph balancing, and payment channels

In range-partitioned P2P systems, nodewise rebalancing preserves key order while restoring bounded load ratios. The non-recursive algorithm uses two primitive operations: NbrAdjust, which transfers load between adjacent nodes while shifting a range boundary, and Reorder, which relocates an empty-range node to split another node’s range. Insertions invoke MinBalance(u) if $u_{ij}$9; deletions invoke Split(u) if $r_{ij}$0. With $r_{ij}$1, the maintained invariant

$r_{ij}$2

yields a max–min load ratio of $r_{ij}$3, and the amortized cost of both updates remains constant. Although the actual movement is nodewise, the algorithm relies on one global min or max query per user update (Chawachat et al., 2012).

The graph-theoretic formulation “node-balancing by edge-increments” abstracts nodewise rebalancing further: choosing an edge $r_{ij}$4 increments both endpoint weights by $r_{ij}$5, and the objective is to reach a common target weight $r_{ij}$6. Feasibility for a fixed $r_{ij}$7 is equivalent to the existence of a perfect $r_{ij}$8-factor with variables $r_{ij}$9 satisfying

$m$0

The universal structural characterization is sharp: every integer assignment is equatable if and only if the graph is connected, has odd order, and, for every $m$1, the induced subgraph $m$2 has fewer than $m$3 isolated vertices. The same work gives a strongly polynomial-time algorithm for finding the minimal feasible $m$4 and a corresponding balancing sequence, while showing that the hypergraph generalization is NP-complete (Eisenbrand et al., 2015).

Payment channel networks provide a different interpretation. Local circular rebalancing is nodewise in the narrow sense that a node chooses a self-payment cycle and moves liquidity among its own channels, but this procedure is limited by private capacities and trial-and-error path search. Hide & Seek replaces such local heuristics by a globally optimal circulation computed from nodewise incident-edge constraints under MPC. The LP maximizes total rebalanced flow subject to per-edge capacities and nodewise conservation,

$m$5

so that no node changes total wealth. The optimal circulation is then decomposed into executable HTLC cycles, and privacy holds if at least one delegate is honest. The paper explicitly notes two limits: the base formulation does not involve transaction fees, and it does not verify that submitted capacities are truthful (Avarikioti et al., 2021).

7. Recurring trade-offs and limitations

The surveyed literature repeatedly places nodewise rebalancing at the intersection of locality and coordination. In AMoD, pricing-only is sufficient to enforce node balance, yet the joint pricing-and-rebalancing problem strictly dominates the individual and sequential methods because pricing and rebalancing interact in both objective and constraints. In payment channel networks, local circular rebalancing is operationally simple but cannot exploit network-wide canceling-out, whereas the global MPC circulation can. This suggests that nodewise control variables do not preclude centralized or jointly optimized planning layers (Wollenstein-Betech et al., 2020, Avarikioti et al., 2021).

A second recurring trade-off is between minimal metadata and structural guarantees. The metadata-free randomized BST schemes achieve expected $m$6 update work and at most two rotations, but simple adversarial insertion sequences still force $m$7 expected average depth. By contrast, top-down AVL uses rank or balance information plus a fixed look-ahead window to secure $m$8 time and $m$9 amortized writes, while grand-children weight-balanced trees use explicit node weights and local inequalities to improve worst-case and average depth. The contrast is not between local and nonlocal methods, but between different local state models and different permissible repair primitives (Brodal, 2024, Jugé, 2024, Jugé, 2024).

A third trade-off concerns coding gain versus subpacketization. Structurally invariant and decentralized $r_{ij}$00-balanced databases achieve information-theoretically optimal single-node rebalancing loads, but prior optimal constructions can require factorial or otherwise very large subpacketization. Cyclic storage reduces the file-size requirement to cubic in the number of nodes and still beats uncoded removal, yet the lower bound for cyclic node removal is not tight enough to certify optimality. In mobility fairness, an analogous tension appears between efficiency and equity: fairness weights lower cross-zone disparity, but the most fairness-oriented configuration reported in the ride-hailing study slightly increases average wait time (Krishnan et al., 2020, Vaishya et al., 2022, Guo et al., 2023).

Taken together, these results show that nodewise rebalancing is best understood not as a single algorithmic template, but as a design principle: enforce balance through operations that are anchored to nodes, preserve a small set of local or incident invariants, and compose into a globally valid state. The precise meaning of “nodewise” then depends on what is being balanced—vehicles, occupancy levels, subtree weights, replication counts, channel liquidity, or vertex weights—and on whether the surrounding optimization is local, sequential, coded, or globally coordinated.