GraphCHiP: Coarsening History in CVRP

• GraphCHiP is a test-time algorithm that exploits neural coarsening history to identify both Rounded and Framed Capacity Inequalities in the Capacitated Vehicle Routing Problem.
• It refines NeuralSEP’s predictions by traversing a hierarchy of coarsened graphs while using stochastic edge selection to boost the diversity of generated cuts.
• Empirical results show that GraphCHiP improves dual gaps and enhances solution quality by expanding the search space for capacity cuts with manageable computational overhead.

Searching arXiv for GraphCHiP and closely related graph coarsening/partitioning papers. Graph Coarsening History-based Partitioning (GraphCHiP) is a test-time algorithm for neural cut separation in the Capacitated Vehicle Routing Problem (CVRP) that exploits the full coarsening history produced by a neural graph coarsening separator. In its original formulation, GraphCHiP is layered on top of NeuralSEP and uses a hierarchy of coarsened support graphs and node maps to recover candidate subsets for Rounded Capacity Inequalities (RCIs) and candidate partitions for Framed Capacity Inequalities (FCIs), thereby increasing both the number and the diversity of cuts generated at inference time (Sim et al., 1 Oct 2025). The exact name is specific to that CVRP setting, although earlier multilevel graph partitioning literature had already treated coarsening histories as structurally meaningful objects during partition projection and refinement (Akhremtsev et al., 2017).

1. Origin, problem setting, and intended scope

GraphCHiP was introduced in the context of the two-index CVRP formulation on an undirected complete graph $G=(V,E)$ with depot $0$, customer set $V_C=V\setminus\{0\}$, customer demands $q_i$, vehicle capacity $Q$, and edge traversal variables $x_{ij}$. In that formulation, the cutting-plane method solves an LP relaxation and iteratively adds violated capacity inequalities. The basic rounded capacity inequality uses

$$r(S) = \left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil$$

and yields

$$x(\delta(S)) \;\ge\; 2\left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil \quad \forall S\subseteq V_C,\ |S|\ge2.$$

GraphCHiP is designed to search for such violated RCIs, and also for FCIs, which strengthen RCIs by using a partition $\Omega=\{S_i:i\in I\}$ of a larger set $H\subseteq V_C$ and the bin-packing quantity $0$0. The corresponding FCI is

$0$1

This places GraphCHiP in the cut-separation layer of CVRP branch-and-cut, not in the role of a general-purpose graph partitioner (Sim et al., 1 Oct 2025).

The immediate motivation was a limitation identified in NeuralSEP. NeuralSEP is a supervised GNN-based separator trained from exact RCI labels; for each parameter $0$2, it maps the support graph to a subset $0$3 intended to approximate an exact violating subset. The analysis reported that NeuralSEP finds far fewer distinct subsets than the exact method, because it is only weakly sensitive to the parameter $0$4. The reported partial derivative of $0$5 with respect to the feature $0$6 is small, cosine similarity between probability vectors for $0$7 and $0$8 is about $0$9, and Jaccard similarity between final subsets $V_C=V\setminus\{0\}$0 and $V_C=V\setminus\{0\}$1 is high, especially for large graphs. GraphCHiP was introduced to exploit the latent combinatorial information already present in the learned coarsening process and thereby enlarge the search space of cuts without retraining the network (Sim et al., 1 Oct 2025).

A common misunderstanding is to treat GraphCHiP as a standalone partitioning objective over arbitrary graphs. In its original form it is instead a test-time search procedure over coarsening histories generated for CVRP support graphs, with the goal of identifying violated capacity inequalities.

2. Coarsening history construction inside NeuralSEP

GraphCHiP inherits its search space from NeuralSEP’s neural graph coarsening pipeline. For a fractional solution $V_C=V\setminus\{0\}$2, the separator operates on the support graph $V_C=V\setminus\{0\}$3 with $V_C=V\setminus\{0\}$4. For a fixed parameter $V_C=V\setminus\{0\}$5, NeuralSEP uses vertex features

$V_C=V\setminus\{0\}$6

and edge features

$V_C=V\setminus\{0\}$7

A graph embedding layer, several message-passing GNN layers, and a final MLP produce vertex scores $V_C=V\setminus\{0\}$8, interpreted as probabilities that customer $V_C=V\setminus\{0\}$9 belongs to the target subset (Sim et al., 1 Oct 2025).

From these scores NeuralSEP defines pairwise contraction probabilities

$q_i$0

so that two customers are likely to be contracted when the model predicts that they lie on the same side of the cut. The original separator repeatedly selected the edge with maximal $q_i$1, contracted its endpoints into a supernode, re-ran the GNN on the coarsened graph, and continued until only three vertices remained or all $q_i$2. This procedure produces a sequence of graphs

$q_i$3

with vertex sets $q_i$4, together with node maps

$q_i$5

where $q_i$6 is the set of original vertices merged into supernode $q_i$7 (Sim et al., 1 Oct 2025).

GraphCHiP treats $q_i$8 as a hierarchical partition tree over the original customer set. Its search runs backward through that hierarchy. This design is closely tied to a second modification introduced alongside GraphCHiP: stochastic edge selection. Instead of the purely greedy rule, the paper perturbs each contraction score by

$q_i$9

and chooses

$Q$0

This $Q$1-greedy rule preserves the ranking structure while changing contraction order in near-tie situations, which increases subset diversity across repeated test-time runs (Sim et al., 1 Oct 2025).

3. GraphCHiP for Rounded Capacity Inequalities

GraphCHiP’s RCI procedure starts from the primary subset $Q$2 predicted by NeuralSEP for a given $Q$3, together with the associated coarsening history. It then traverses the hierarchy from level $Q$4 down to level $Q$5, inspecting intermediate supernodes that belong to the current coarse-level version of $Q$6. For each such supernode $Q$7, GraphCHiP constructs the original-vertex subset

$Q$8

and tests whether it violates an RCI by comparing

$Q$9

If $x_{ij}$0, the subset is added to the collection of found cuts and the search stops as soon as a nonempty set of violating subsets is identified (Sim et al., 1 Oct 2025).

The reported pseudocode initializes the search at $x_{ij}$1, decreases $x_{ij}$2 level by level, and returns immediately once at least one violating subset has been found. The text states that if the violation of the original NeuralSEP subset $x_{ij}$3 is non-positive, the search should be attempted; the printed pseudocode condition appears inverted, and the accompanying discussion identifies this as a likely typo. Substantively, the RCI version of GraphCHiP is a refinement mechanism: if the coarse final subset is weak or non-violating, its constituent supernodes at finer levels may still yield strongly violating capacity sets (Sim et al., 1 Oct 2025).

The paper gives an explicit worst-case bound on the number of RCI checks. If the coarsening ratio is $x_{ij}$4, then

$x_{ij}$5

so the worst-case number of RCI checks performed by GraphCHiP is bounded by

$x_{ij}$6

With $x_{ij}$7, this is at most $x_{ij}$8 checks. The significance of this result is that GraphCHiP turns the coarsening tree into a linear-size family of candidate subsets, rather than launching a separate large combinatorial search (Sim et al., 1 Oct 2025).

This RCI mechanism also clarifies the meaning of “history” in GraphCHiP. The algorithm does not merely use the final coarsened subset; it uses the entire contraction genealogy encoded by $x_{ij}$9. A plausible implication is that the quality of GraphCHiP depends not only on the final NeuralSEP prediction, but also on whether intermediate supernodes capture coherent customer groups.

4. GraphCHiP for Framed Capacity Inequalities

The FCI version of GraphCHiP is more elaborate because it must construct a partition $$r(S) = \left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil$$0, not just a single subset. For each level $$r(S) = \left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil$$1 from $$r(S) = \left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil$$2 down to $$r(S) = \left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil$$3, the algorithm initializes an empty partition and inserts every supernode $$r(S) = \left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil$$4 as a block

$$r(S) = \left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil$$5

It then fills the remainder of the customer set with singleton parts. If

$$r(S) = \left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil$$6

then every $$r(S) = \left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil$$7 contributes a singleton $$r(S) = \left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil$$8 to $$r(S) = \left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil$$9. In this construction $$x(\delta(S)) \;\ge\; 2\left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil \quad \forall S\subseteq V_C,\ |S|\ge2.$$0 is always a partition of $$x(\delta(S)) \;\ge\; 2\left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil \quad \forall S\subseteq V_C,\ |S|\ge2.$$1, so the resulting cuts are generalized capacity inequalities with $$x(\delta(S)) \;\ge\; 2\left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil \quad \forall S\subseteq V_C,\ |S|\ge2.$$2 (Sim et al., 1 Oct 2025).

Before invoking bin packing, GraphCHiP applies an RCI filter. If any component $$x(\delta(S)) \;\ge\; 2\left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil \quad \forall S\subseteq V_C,\ |S|\ge2.$$3 already violates

$$x(\delta(S)) \;\ge\; 2\left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil \quad \forall S\subseteq V_C,\ |S|\ge2.$$4

the partition is discarded and the algorithm proceeds to a finer level. The rationale is that such a partition would be dominated by simpler RCIs, whereas GraphCHiP seeks FCIs that capture interactions across multiple components (Sim et al., 1 Oct 2025).

For partitions that pass the filter, GraphCHiP uses a two-stage violation test. First it computes

$$x(\delta(S)) \;\ge\; 2\left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil \quad \forall S\subseteq V_C,\ |S|\ge2.$$5

It then evaluates a cheap lower bound on the true right-hand side,

$$x(\delta(S)) \;\ge\; 2\left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil \quad \forall S\subseteq V_C,\ |S|\ge2.$$6

where $$x(\delta(S)) \;\ge\; 2\left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil \quad \forall S\subseteq V_C,\ |S|\ge2.$$7 is used instead of $$x(\delta(S)) \;\ge\; 2\left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil \quad \forall S\subseteq V_C,\ |S|\ge2.$$8. If $$x(\delta(S)) \;\ge\; 2\left\lceil \frac{\sum_{i\in S} q_i}{Q} \right\rceil \quad \forall S\subseteq V_C,\ |S|\ge2.$$9, the partition is skipped. Otherwise the algorithm computes the exact bin-packing term $\Omega=\{S_i:i\in I\}$0 with the Martello–Toth algorithm and tests

$\Omega=\{S_i:i\in I\}$1

Whenever $\Omega=\{S_i:i\in I\}$2, the corresponding FCI is added to the output (Sim et al., 1 Oct 2025).

The paper gives the worst-case complexity of GraphCHiP for FCIs as

$\Omega=\{S_i:i\in I\}$3

The argument is that there are $\Omega=\{S_i:i\in I\}$4 coarsening levels, each candidate partition can be built in $\Omega=\{S_i:i\in I\}$5, and the Martello–Toth lower bound is $\Omega=\{S_i:i\in I\}$6 for $\Omega=\{S_i:i\in I\}$7 items. This makes the FCI search polynomial and relatively inexpensive compared with exact FCI separation (Sim et al., 1 Oct 2025).

Conceptually, the FCI mechanism is the most distinctive part of GraphCHiP. NeuralSEP’s learned coarsening creates customer groups that are likely to lie on the same side of capacity cuts; GraphCHiP reinterprets those groups as non-singleton components $\Omega=\{S_i:i\in I\}$8 in framed inequalities. This converts a latent hierarchical clustering into a partition-valued cut generator.

5. Empirical behavior, strengths, and limitations

The reported experiments were conducted at the root node of the CVRP cutting-plane method on randomly generated instances with $\Omega=\{S_i:i\in I\}$9, using CPLEX through Julia/JuMP and a PyTorch Geometric implementation for the learning-based methods. The comparison included CVRPSEP, two NeuralSEP implementations, $H\subseteq V_C$0-NeuralSEP$H\subseteq V_C$1, and $H\subseteq V_C$2-NeuralSEP$H\subseteq V_C$3+GC, where “GC” denotes the full GraphCHiP enhancement (Sim et al., 1 Oct 2025).

For large instances, the combined method improved dual gaps over both the classical heuristic separator and the base neural separator. The reported root-node gaps were: at $H\subseteq V_C$4, CVRPSEP $H\subseteq V_C$5, NeuralSEP$H\subseteq V_C$6 $H\subseteq V_C$7, and $H\subseteq V_C$8-NeuralSEP$H\subseteq V_C$9+GC $0$00; at $0$01, $0$02, $0$03, and $0$04; at $0$05, $0$06, $0$07, and $0$08; and at $0$09, $0$10, $0$11, and $0$12, respectively. The time per iteration increased relative to plain NeuralSEP$0$13, but the stronger cuts improved the lower bound within the same one-hour limit (Sim et al., 1 Oct 2025).

The $0$14-greedy perturbation alone increased the number of RCI cuts for all tested sizes except $0$15 and reduced gaps by up to about $0$16 percentage points. GraphCHiP’s RCI phase then added a further $0$17–$0$18 RCIs over $0$19-NeuralSEP$0$20 for $0$21, with gap improvements of about $0$22–$0$23 percentage points and winning ratios against NeuralSEP$0$24 in the $0$25–$0$26 range for sizes up to $0$27 (Sim et al., 1 Oct 2025).

The FCI results were more selective. On random instances up to size $0$28, GraphCHiP did not find FCIs, and the paper notes that FCIs are rare and highly instance-dependent. The strongest evidence came from the CVRPLIB instance X-n153-k22. There, the lower bound/gap values were: CVRPSEP RCI only, $0$29 / $0$30; $0$31-NeuralSEP$0$32 RCI only, $0$33 / $0$34; CVRPSEP RCI + CVRPSEP FCI, $0$35 / $0$36 with $0$37 FCI cuts; and $0$38-NeuralSEP$0$39 RCI + GraphCHiP FCI, $0$40 / $0$41 with $0$42 FCIs. The paper also reports a concrete FCI example on that instance with $0$43, $0$44, $0$45, $0$46, $0$47, $0$48, $0$49, $0$50, and violation $0$51, while neither $0$52 nor $0$53 individually violated an RCI (Sim et al., 1 Oct 2025).

These results delimit the method’s strengths and limits. GraphCHiP is effective when coarsening history exposes meaningful customer groups that the final NeuralSEP subset alone fails to exploit. At the same time, the method was evaluated only at the root node, and the paper leaves full branch-and-cut or branch-price-and-cut integration as future work. A further source of ambiguity is that FCI discovery appears highly instance dependent: the random-instance study showed no FCIs, whereas X-n153-k22 yielded a large number.

6. Relation to earlier coarsening-history partitioning ideas

Although the exact algorithm named GraphCHiP is specific to CVRP cut separation, its organizing idea—using coarsening history as an object of inference rather than merely a transient implementation detail—has clear antecedents across graph partitioning and coarsening research. Earlier multilevel shared-memory partitioning work described the hierarchy

$0$54

as a stored sequence of clusterings, and explicitly interpreted this hierarchy as a “history of aggregation decisions” that constrains partition projection and local search during uncoarsening (Akhremtsev et al., 2017). Closely related size-constrained clustering methods likewise used label propagation both for coarsening and for refinement, and in later V-cycles constrained new clusterings to respect previous partitions so that cut edges were never contracted; this is an explicit history-based mechanism, even though the name GraphCHiP was not used there (Meyerhenke et al., 2014).

A different line of work made the term itself appear as a hypothetical extension. In distributed dynamic GNN training, DGC introduced partitioning by graph chunks through weighted label-propagation coarsening on a space-time supergraph, then suggested a “Graph Coarsening History-based Partitioning (GraphCHiP)” variant that would augment static model-based weights with temporal frequency, recency, historical communication, and workload imbalance. In that formulation, history-awareness meant moving averages such as

$0$55

for per-edge communication cost, and analogous averages for chunk workloads $0$56, followed by periodic re-coarsening or re-labeling (Chen et al., 2023). This use of the name is conceptually related to the 2025 CVRP method but operationally different: DGC’s proposal concerns dynamic graph partitioning for distributed training, whereas the CVRP GraphCHiP is a test-time search over a fixed coarsening tree.

Other recent multilevel systems provide adjacent design patterns. Deep multilevel graph partitioning with GraphSAGE and heavy-edge matching used coarsening hierarchies, interpolation maps, and saved fine-level features as the backbone of learned normalized-cut minimization, showing how coarsening histories can be embedded directly into differentiable models (Gatti et al., 2021). PASCO, by contrast, generated many independent coarsenings, clustered each coarsened graph in parallel, lifted the resulting partitions, and combined them with an optimal-transport barycenter; this suggests an alternative sense in which a “history-based” partitioner may aggregate multiple coarse views rather than traverse a single hierarchy (Lasalle et al., 2024).

Taken together, these lines of work suggest that “coarsening history” has acquired two distinct meanings. In classical multilevel partitioning it denotes the hierarchy used to project and refine partitions; in DGC-like proposals it denotes time-accumulated runtime statistics that should influence future coarsening; and in the exact 2025 GraphCHiP algorithm it denotes a learned contraction genealogy over CVRP support graphs, exploited backward to generate RCIs and FCIs. The shared principle is that coarsening decisions need not be discarded after graph reduction: they can become explicit combinatorial features for subsequent inference (Sim et al., 1 Oct 2025).