Two-Phase Vertex Elimination (TPVE)

• Two-Phase Vertex Elimination (TPVE) is a graph-reduction method in the COLOGR framework that prunes irrelevant vertices while preserving every vertex on the optimal, budget-feasible path.
• It employs two coordinated phases—COGR to eliminate vertices via feasibility and cost-dominance tests, and LOGR to iteratively prune using dual information and multiplier updates.
• Empirical results show that TPVE reduces graph size by roughly 35% and drives the duality gap to zero, enhancing computational efficiency in constrained path-planning.

Two-Phase Vertex Elimination (TPVE) is a graph-reduction method introduced within the COLOGR framework for solving a resource-constrained variant of the Random Disambiguation Path problem, formulated as a Weight-Constrained Shortest Path Problem (WCSPP) with risk-adjusted edge costs. In this setting, an agent must reach a target in a spatial environment with uncertain obstacles, where obstacle disambiguation incurs heterogeneous resource costs under a global budget. TPVE consists of two coordinated reduction stages—COGR and LOGR—that remove vertices deemed irrelevant to the optimal budget-feasible path while preserving every vertex on the true optimum $p^*$. Its function is both algorithmic and structural: it shrinks the graph before and during Lagrangian optimization, tightens primal and dual bounds, and in the reported experiments drives the duality gap to zero in practice (Zhou et al., 8 Jul 2025).

1. Problem formulation and role within COLOGR

TPVE is designed for a Lagrangian-relaxed solver for the WCSPP that arises after reformulating the constrained planning problem over a graph $G_{\rm adj}=(V,E)$. Each edge $e$ is assigned a surrogate traversal cost

$\widetilde{\mathcal C}_e \;=\;\ell_e \;+\;r_e,$

where $\ell_e$ is the Euclidean length and

$r_e=\tfrac12\sum_{x\in X_e}r_x$

is a risk penalty contributed by obstacles intersecting the edge. The same edge also carries a disambiguation weight

$\delta_e \;=\;\tfrac12\sum_{x\in X_e}\delta_x,$

where each obstacle $x$ intersecting $e$ contributes half its disambiguation cost $\delta_x$ (Zhou et al., 8 Jul 2025).

Within this formulation, TPVE targets vertices that cannot lie on any feasible and cost-competitive $G_{\rm adj}=(V,E)$0 path under the budget $G_{\rm adj}=(V,E)$1. The method proceeds in two phases. Phase 1, COGR, performs cost- and obstacle-based graph reduction using extreme values of the Lagrange multiplier. Phase 2, LOGR, continues pruning during Lagrangian relaxation by using current dual information. The defining property is that both phases repeatedly remove irrelevant vertices and their incident edges without discarding any vertex that lies on the true optimal path $G_{\rm adj}=(V,E)$2. This suggests that TPVE should be understood not merely as preprocessing, but as an optimality-preserving reduction mechanism embedded into the search itself.

2. Phase 1: COGR and extreme-point pruning tests

Phase 1 is the Cost- and Obstacle-Based Graph Reduction stage. Its purpose is to eliminate vertices using two complementary tests evaluated at $G_{\rm adj}=(V,E)$3 and $G_{\rm adj}=(V,E)$4, corresponding respectively to pure surrogate-cost minimization and pure disambiguation-weight minimization (Zhou et al., 8 Jul 2025).

The first test is feasibility pruning, also described as the $G_{\rm adj}=(V,E)$5 test. For each vertex $G_{\rm adj}=(V,E)$6, the algorithm computes the minimum-weight $G_{\rm adj}=(V,E)$7 path $G_{\rm adj}=(V,E)$8, with total disambiguation weight

$G_{\rm adj}=(V,E)$9

If

$e$0

then no feasible $e$1 path through $e$2 exists, and $e$3 may be eliminated.

The second test is cost-dominance pruning, or the $e$4 test. For each $e$5, the algorithm computes the minimum-cost path $e$6 through that vertex, and evaluates

$e$7

An incumbent upper bound $e$8 is maintained. If

$e$9

then the upper bound is updated: $\widetilde{\mathcal C}_e \;=\;\ell_e \;+\;r_e,$0 If instead

$\widetilde{\mathcal C}_e \;=\;\ell_e \;+\;r_e,$1

then even the cheapest feasible path via $\widetilde{\mathcal C}_e \;=\;\ell_e \;+\;r_e,$2 is too expensive, so $\widetilde{\mathcal C}_e \;=\;\ell_e \;+\;r_e,$3 is eliminated.

These feasibility and dominance tests are repeated until no further vertex can be removed. At the end of COGR, either a path $\widetilde{\mathcal C}_e \;=\;\ell_e \;+\;r_e,$4 satisfying $\widetilde{\mathcal C}_e \;=\;\ell_e \;+\;r_e,$5 has already been found, in which case it is optimal and the algorithm stops, or the procedure yields a reduced graph $\widetilde{\mathcal C}_e \;=\;\ell_e \;+\;r_e,$6 together with an upper-bound path $\widetilde{\mathcal C}_e \;=\;\ell_e \;+\;r_e,$7 and a lower-bound path $\widetilde{\mathcal C}_e \;=\;\ell_e \;+\;r_e,$8 for the second phase. A plausible implication is that COGR serves as both a certificate-producing filter and a bound-initialization step.

3. Phase 2: LOGR and dual-guided vertex elimination

Phase 2, Lagrangian Optimization with Graph Reduction, solves the Lagrangian relaxation of the budget-constrained problem while continuing to prune the graph. The relaxed objective is

$\widetilde{\mathcal C}_e \;=\;\ell_e \;+\;r_e,$9

where $\ell_e$0 denotes the set of $\ell_e$1 paths (Zhou et al., 8 Jul 2025).

LOGR maintains two dual-feasible paths $\ell_e$2 and $\ell_e$3 such that

$\ell_e$4

with costs $\ell_e$5 and $\ell_e$6. The multiplier is updated using the breakpoint formula

$\ell_e$7

so that $\ell_e$8 lies between two breakpoints of the piecewise-linear dual function.

For each remaining vertex $\ell_e$9, the algorithm computes the $r_e=\tfrac12\sum_{x\in X_e}r_x$0-relaxed shortest path through that vertex, denoted $r_e=\tfrac12\sum_{x\in X_e}r_x$1, and its vertex-specific relaxed value

$r_e=\tfrac12\sum_{x\in X_e}r_x$2

If

$r_e=\tfrac12\sum_{x\in X_e}r_x$3

then even the relaxed cost through $r_e=\tfrac12\sum_{x\in X_e}r_x$4 exceeds the incumbent feasible cost, so $r_e=\tfrac12\sum_{x\in X_e}r_x$5 cannot contribute to a better solution and is eliminated.

Termination occurs when either

$r_e=\tfrac12\sum_{x\in X_e}r_x$6

where $r_e=\tfrac12\sum_{x\in X_e}r_x$7. At that point, the current $r_e=\tfrac12\sum_{x\in X_e}r_x$8 is optimal. The logic of LOGR is therefore stronger than static bounding: pruning is interwoven with multiplier updates and lower-bound tightening.

4. Unified algorithmic structure

The paper presents TPVE through a unified COLOGR algorithm. The procedure begins by setting $r_e=\tfrac12\sum_{x\in X_e}r_x$9, then computing the unconstrained minimum-cost path $\delta_e \;=\;\tfrac12\sum_{x\in X_e}\delta_x,$0 at $\delta_e \;=\;\tfrac12\sum_{x\in X_e}\delta_x,$1 and the minimum-weight path $\delta_e \;=\;\tfrac12\sum_{x\in X_e}\delta_x,$2 as $\delta_e \;=\;\tfrac12\sum_{x\in X_e}\delta_x,$3. If $\delta_e \;=\;\tfrac12\sum_{x\in X_e}\delta_x,$4, the algorithm returns $\delta_e \;=\;\tfrac12\sum_{x\in X_e}\delta_x,$5. Otherwise, it initializes $\delta_e \;=\;\tfrac12\sum_{x\in X_e}\delta_x,$6 and $\delta_e \;=\;\tfrac12\sum_{x\in X_e}\delta_x,$7 (Zhou et al., 8 Jul 2025).

Phase 1 then iterates over all vertices $\delta_e \;=\;\tfrac12\sum_{x\in X_e}\delta_x,$8, computing $\delta_e \;=\;\tfrac12\sum_{x\in X_e}\delta_x,$9 and $x$0. A vertex is removed if

$x$1

If a cheaper feasible path via $x$2 is found, $x$3 is updated. This loop repeats until no vertex is removed.

Phase 2 runs while $x$4. In each iteration, the method computes $x$5 using the breakpoint formula, finds the $x$6-shortest path $x$7, and returns immediately if $x$8. It then checks every remaining vertex using $x$9, removes those with $e$0, and updates the bounds $e$1 and $e$2. When the while-loop ends, the algorithm returns $e$3.

This organization makes clear that TPVE is not an auxiliary heuristic appended to a solver. It is the reduction machinery that enables COLOGR to move from initial extreme-point paths to a certified optimal feasible path through successive elimination and bound refinement.

5. Correctness, optimality preservation, and ambiguity handling

The central correctness claim is optimal-path preservation. Proposition 3.4 states that no vertex of an optimal budget-feasible path $e$4 is ever eliminated in either phase (Zhou et al., 8 Jul 2025). In Phase 1, each vertex $e$5 lies on a feasible path through $e$6 whose cost satisfies

$e$7

In Phase 2, each such vertex attains a dual value obeying

$e$8

Therefore every vertex of $e$9 survives the elimination rules, and $\delta_x$0 remains represented in the reduced graph.

The method also addresses dual ambiguity. Even when multiple paths minimize the relaxed cost, TPVE is reported to ensure identification of $\delta_x$1 via vertex-specific tests, as stated in Propositions 3.6–3.8. One example given is that if $\delta_x$2 is the unique $\delta_x$3-minimizer through some vertex $\delta_x$4, then the check at $\delta_x$5 recovers $\delta_x$6. This is significant because ambiguity in the Lagrangian subproblem often weakens path-based recovery mechanisms; here, vertex-local certification is used to retain identifiability.

The paper further states correctness, feasibility guarantees, and surrogate optimality under mild assumptions. It also states that COLOGR frequently achieves zero duality gap and offers improved computational complexity over prior constrained path-planning methods. Since the detailed comparison targets “prior constrained path-planning methods” without enumerating them in the provided material, the safe conclusion is that the claimed improvement is relative to earlier approaches considered in the paper’s broader analysis.

6. Complexity, empirical performance, and applicability

The worst-case complexity is given explicitly. Let $\delta_x$7 and $\delta_x$8. For Phase 1, each pass uses two Dijkstra runs in

$\delta_x$9

and there can be up to $G_{\rm adj}=(V,E)$00 passes, yielding

$G_{\rm adj}=(V,E)$01

For Phase 2, there are at most

$G_{\rm adj}=(V,E)$02

dual breakpoints; each breakpoint requires a shortest-path computation plus $G_{\rm adj}=(V,E)$03 vertex checks, for total complexity

$G_{\rm adj}=(V,E)$04

The paper adds that in practice Phase 1 massively shrinks the graph, so Phase 2 typically runs much faster than this worst-case bound (Zhou et al., 8 Jul 2025).

The empirical evaluation reported for TPVE uses Monte Carlo tests on a $G_{\rm adj}=(V,E)$05 grid with up to 80 obstacles, comparing TPVE to a “Simple Node Elimination” (SNE) strategy over 1,000 random instances. The final graph size averaged approximately 2,423 vertices for TPVE and approximately 3,745 vertices for SNE. The duality gap at termination was always 0 for TPVE, whereas SNE was nonzero, approximately $G_{\rm adj}=(V,E)$06, in selected cases. Traversal cost matched or improved upon SNE in every case. A graph reduction of approximately $G_{\rm adj}=(V,E)$07 led to average run-time speed-ups of $G_{\rm adj}=(V,E)$08 in the Lagrangian solver. These results are presented as confirmation that TPVE substantially shrinks the search space, closes the duality gap reliably, and reduces computation time while preserving the global optimum.

The reported application scope extends beyond the immediate constrained Random Disambiguation Path setting. The broader framework is described as applicable to stochastic network design, mobility planning, and constrained decision-making under uncertainty. This suggests that TPVE is best viewed as a generic reduction pattern for budgeted shortest-path problems with uncertainty-aware edge models, rather than as a method restricted to a single navigation scenario.