Graph Theory Trip-Vehicle Matching

• The paper introduces a graph theory-based matching mechanism that models ride-pooling as a combinatorial optimization problem using shareability hypergraphs.
• It leverages two polynomial-time algorithms—LSLPR and MMO—to approximate integer programming solutions with proven approximation guarantees.
• Empirical results on real-world data demonstrate scalability, near-optimal performance, and effective handling of heterogeneous fleet and stochastic demands.

A graph theory-based trip–vehicle matching mechanism is a combinatorial optimization framework that models the assignment of transportation requests (trips) to vehicles via the formalism of graphs or hypergraphs, enabling mathematically rigorous and scalable solutions to ride-pooling, ride-sharing, and mobility assignment problems. This paradigm is central to the design of high-capacity shared mobility systems and mixed fleets, allowing the systematic encoding of spatio-temporal, operational, and user-type constraints, as well as algorithmic exploitation of structural sparsity and approximation regimes.

1. Shareability Hypergraph Model

At the core of advanced ride-pooling assignment is the shareability hypergraph. In this model:

• Vertex sets are partitioned into supply vertices (vehicles, S) and demand vertices (trip requests, D). Vehicles themselves are further divided into classes: Sₐ (“augmented,” e.g., costly automated vehicles) and S_b (“basis,” e.g., low-cost or zero-cost vehicles).
• Hyperedges represent feasible pooled trips; each hyperedge $e = \{i\} \cup J$ corresponds to a vehicle $i$ assigned to trip subset $J \subset D$, with $|J| \leq C_i$ (vehicle capacity). The hyperedge cardinality $|e|$ is bounded by $p = 1+\max_i C_i$.
• Feasibility is strictly enforced. A hyperedge exists only if, for some passenger ordering $t$, the vehicle can reach all pickups within their waiting-time bounds $\omega_j$, deliver all dropoffs within their detour limits $r_j$, and meet vehicle-type/customer-type preferences and penalties.

This hypergraph structure compactly encodes all combinatorially allowed vehicle–trip groupings, and is essential for capturing the high-dimensional constraints of ride-pooling at scale.

2. Integer Programming Formulation of the Assignment Problem

The assignment problem is formally modeled as a two-stage stochastic integer program over the shareability hypergraph:

• First stage: Select up to $K$ augmented vehicles $y_i \in \{0,1\}$, with $\sum_{i \in S_\alpha} y_i \leq K$.
• Second stage (scenario-based): Given revealed trip requests $D(\xi)$ and their induced hyperedges $E(\xi)$ in scenario $\xi$, solve

$Q(y, \xi) = \max_{x} \sum_{e \in E(\xi)} v_e x_e$

subject to: - Each trip is matched at most once: $\sum_{e \ni j} x_e \leq 1$, $\forall j \in D(\xi)$ - Supply constraints: $\sum_{e \ni i} x_e \leq y_i$ for $i \in S_\alpha$, $\leq 1$ for $i \in S_b$ - $x_e \in \{0,1\}$.

• Hyperedge utility $v_e$ aggregates fares, bonuses/penalties for vehicle-type, and routing/travel costs.
• The optimization maximizes the expectation over scenarios, replaced in practice with a sample-average approximation (SAA) over $N$ sampled demand instances:

$$\max_{y} \frac{1}{N} \sum_{\ell=1}^N Q(y, \xi_\ell)$$

This formulation is an instance of the Generalized Assignment Problem (GAP) on a hypergraph, where shareability constraints, vehicle heterogeneity, and operational cost structures are incorporated exactly.

3. Approximation Algorithms for Polynomial-Time Assignment

Solving the above integer program directly is computationally infeasible for realistic $p$ and $|S|$, demanding scalable approximation algorithms. Two polynomial-time schemes are developed:

3.1 Local-Search LP-Relaxation (LSLPR) for Mid-Capacity Vehicles

• Algorithmic steps:
  • Arbitrary initialization of $K$-vehicle subset $S_R$.
  • Iteratively swap an included vehicle $i^-$ for an excluded $i^+$ if the LP-relaxed objective $\hat{v}(S')$ increases by more than an $\varepsilon$-fraction.
  • Solve the LP relaxation for each candidate $S'$:

  $$\hat{v}(S_R) = \frac{1}{N} \sum_{\ell=1}^N \text{LP-solution for scenario } \xi_\ell$$ - Iterate until local optimality. - For each scenario, apply a simple greedy $1/p$-rounding of the relaxed solution $x$ to yield an integral matching of value at least $(1/p)\hat{v}(S_R)$.

• Approximation guarantee: This method achieves a $\frac1{p^2}$-approximation ratio, i.e., $\hat{v}(S_R_{\text{final}}) \geq \frac{1}{p^2}$ of optimal.

3.2 Max–Min Online (MMO) for High-Capacity Vehicles

• Algorithmic steps:
  • The objective is converted to a covering LP with row-sparsity $p$,

  $$\hat{v}(S_R) = \min_{u \geq 0} \sum_{\xi}\sum_{g \in G} u_{g, \xi}$$

  subject to $\sum_{g \in e} u_{g, \xi} \geq v_e/N$ for all $e \in E(\xi)$. - A greedy max–min dual process selects $K$ blocks (vehicles) to maximize the covering value, using an $O(\log p)$-competitive online covering update. - Rounding via the Feige–Jain–Mirrokni max–min greedy achieves an approximation ratio $\approx \frac{e-1}{(2e + o(1)) p \ln p}$.

Complexity: Both algorithms scale polynomially in the fleet and demand sizes, number of scenarios $M$, hypergraph width $p$, and $1/\varepsilon$.

4. Computational Complexity and Empirical Performance

Let $n_\alpha=|S_\alpha|$, $n_b=|S_b|$, $m=|D|$, $M=$ number of scenarios, $E$ = number of hyperedges per scenario, $p=$ maximum edge size.

• LSLPR: $O((n_\alpha-K)KMT_{LP} \cdot \#\text{iter})$, with $T_{LP}$ polynomial in $E$ and $p$; iteration count $O(p K^2 \log (v_{max}/v_{min})/\varepsilon)$.
• MMO: $O(K n_\alpha M E\, \text{polylog}(p))$.

Empirical evaluation (NYC taxi data, mixed automation, rolling-horizon batches 15 min, $p \approx 10$ high-capacity) demonstrates:

• Both LSLPR and MMO solve in seconds, compared to hours for exact MIP.
• Optimality gap for high capacity is $<1\%$; for mid-capacity ($p \leq 4$), $<0.1\%$ and speedup $>10\times$ versus exact methods.
• Gaps are stable across $p$, sample size, and cost distributions.

5. Extensions to Mixed and Partitioned Fleets

The mechanism naturally handles heterogeneous fleets:

• Vehicle classes: Divided into Sₐ and S_b, with possible further subdivisions when more types exist. Partition/matroid constraints $\sum_{i \in S_\alpha^t} y_i \leq K_t$ for each type $t$.
• Hyperedge utility: $v_e$ captures type-based customer preferences, different speeds, and operational zone restrictions (e.g., AV-only regions).
• The algorithmic framework and approximation ratios extend without substantive loss with these constraints, preserving polynomial-time tractability.

6. Practical Implementation and Deployment Considerations

For deployment in city-scale mobility platforms:

• Hypergraph construction may involve millions of candidate pooling sets; implementation must leverage problem sparsity, stateful subgraph enumeration, and per-scenario batching.
• LP-relaxation and rounding are efficiently handled for $p \leq 5$; dual-based covering algorithms scale to larger $p$ given streaming or parallelized update regimes.
• Scenario-based sample average approximation replaces stochastic expectations, making the solver responsive to real-time forecasted demand data.
• Fleet activation decisions are made at slow (pre-shift or hourly) horizons, while assignment and rounding occur on rolling, sub-minute windows.

Key empirical findings: The two-stage, hypergraph-based approach delivers near-optimal, operationally feasible trip–vehicle assignments with strict adherence to ride-pooling constraints, while scaling to demand and fleet sizes that are otherwise intractable with monolithic integer programming.

7. References and Theoretical Underpinnings

The local search LP relaxation leverages the techniques of Arkin–Hassin (1998) and Fleischer–Goemans–Mirrokni–Sviridenko (2006), while the online covering/primal–dual tools derive from Buchbinder–Naor (2009, 2014). The max–min block selection argument is grounded in Feige–Jain–Mirrokni (2007) and Gupta–Nagarajan–Ravi (2015) for partitioned generalizations.

These methodologies constitute a unified, rigorously analyzable, and implementation-ready description of the hypergraph construction, two-stage stochastic matching, algorithmic approximations, runtime guarantees, and empirical system performance in complex, dynamic mobility assignments.