Lexicographic Minimax Path Optimization

• Lexicographic minimax path optimization is a method that selects video diffusion paths by lexicographically minimizing bottleneck errors to control global degradation.
• It constructs a directed acyclic graph with error-weighted edges and employs dynamic programming to optimize cache scheduling under a fixed computational budget.
• Empirical results show improved video quality metrics and substantial speedups over traditional cache methods by suppressing error spikes during denoising.

Lexicographic Minimax Path Optimization is a path-selection criterion that orders candidate paths by the lexicographically sorted profile of their pathwise bottleneck errors rather than by an additive cost. In contemporary diffusion-based video generation, the term is introduced by "LeMiCa: Lexicographic Minimax Path Caching for Efficient Diffusion-Based Video Generation" (Gao et al., 30 Oct 2025), where cache scheduling is formulated as a directed graph with error-weighted edges and the selected path explicitly bounds the worst-case path error. In that formulation, the objective is to suppress error spikes that can propagate through denoising, thereby improving the consistency of global content and style across generated frames while preserving acceleration gains.

1. Problem formulation in diffusion-based video generation

LeMiCa addresses training-free acceleration of diffusion-based video generation by deciding when to reuse cached model outputs instead of running a full forward denoising computation (Gao et al., 30 Oct 2025). The central observation is that existing cache methods such as TeaCache make local greedy decisions based on adjacent-step differences, while diffusion video generation is temporally heterogeneous: early denoising steps determine global structure and have large downstream influence, whereas later steps mostly refine details and are less globally disruptive.

Under this view, the scheduling problem is global rather than local. The stated problem is: given a diffusion sampling trajectory and a fixed computational budget, choose a schedule of full computation steps and cached segments that maximizes speed while minimizing the final video degradation. A cache segment $(i,j)$ means that full inference is performed at timesteps $i$ and $j$, and all intermediate timesteps $t \in (i,j)$ reuse cached outputs. The goal is to choose such segments under a fixed budget $B$ of model forward steps.

This setup shifts optimization away from local heuristic similarity and toward trajectory-level control. A plausible implication is that the optimization target is not the fidelity of any single denoising transition, but the stability of the final synthesized video under constrained compute.

2. Directed acyclic graph model and global error weights

LeMiCa builds a directed acyclic graph from the sampling trajectory (Gao et al., 30 Oct 2025). Nodes correspond to diffusion timesteps or states along the original denoising path. A directed edge $(i \rightarrow j)$ represents a candidate cache segment from timestep $i$ to timestep $j$; traversing the edge means compute at $i$, reuse cache for intermediate steps, and compute again at $j$. To reduce complexity, the paper imposes a maximum skip length, because long-range reuse tends to incur large errors.

The defining feature of the construction is the edge weight. Each edge is assigned a global outcome-aware error, namely the final-output degradation caused by caching that segment:

$i$0

Here, $i$1 is the output with no caching, $i$2 is the output when segment $i$3 is cached, and $i$4 is the normalization factor shown in the paper. The graph is static: edge errors are averaged across diverse prompts and random seeds, so the graph is offline and reusable.

This graph construction is significant because it encodes downstream impact directly into the edge weight. The paper emphasizes that the relevant error is not merely local approximation error at the skipped steps, but the global degradation observed at the end of the denoising process.

3. Lexicographic minimax objective

The optimization problem is to find a path from source $i$5 to target $i$6 under a step-budget constraint $i$7, while minimizing path error in a lexicographic minimax sense (Gao et al., 30 Oct 2025):

$i$8

In this expression, $i$9 is the set of all paths from $j$0 to $j$1 with exactly $j$2 full steps, $j$3 denotes the cached segments on path $j$4, $j$5 is the error weight of edge $j$6, $j$7 sorts the cached edge weights in descending order, and $j$8 lexicographically minimizes this sorted error vector.

The interpretation given in the paper is exact: the selected path first minimizes the largest edge error on the path, then, if tied, minimizes the second largest error, and so on. The key objective is therefore to control the worst degradation first, then the next worst, and so forth.

The distinction from related path objectives is central. Standard shortest-path optimization minimizes the sum of edge weights,

$j$9

but LeMiCa does not optimize additive cost. Plain minimax path optimization minimizes only the maximum edge weight,

$t \in (i,j)$0

whereas LeMiCa uses a lexicographic ordering of the whole sorted error vector, not just the maximum. The paper also contrasts this with generic multi-objective optimization based on weighted sums, Pareto dominance, or heuristic trade-offs; its lexicographic minimax formulation is presented as a deterministic priority ordering over the ordered error profile. A recurrent misconception, addressed directly by the paper, is that path error can be handled as a sum of local discrepancies. The stated reason this is inappropriate is that cache errors are non-additive and non-Markovian.

4. Dynamic programming solution and schedule construction

The paper gives pseudocode in the appendix under the name "Lexicographic Minimax Path Selection" (Gao et al., 30 Oct 2025). The solver uses dynamic programming over the directed acyclic graph and a budget $t \in (i,j)$1.

The initialization defines $t \in (i,j)$2 as the maximum edge weight on any $t \in (i,j)$3-step path to node $t \in (i,j)$4, together with $t \in (i,j)$5 and $t \in (i,j)$6 for the corresponding path and edge sequences. The initialization is:

• $t \in (i,j)$7
• $t \in (i,j)$8
• $t \in (i,j)$9

The main loop iterates over step counts $B$0 to $B$1, over each reachable node $B$2, and over each neighbor $B$3. If $B$4 is the weight of edge $B$5, it computes $B$6. If $B$7, the algorithm updates $B$8 and the associated path and edge sequences. If $B$9, it appends the new candidate path to maintain ties.

Final selection is performed among the candidate paths that reach $(i \rightarrow j)$0 with budget $(i \rightarrow j)$1:

$(i \rightarrow j)$2

The algorithmic intuition is explicit. The dynamic-programming stage propagates paths by their current worst edge, and the final tie-break uses the full sorted edge list to enforce lexicographic minimax. Because the graph is a DAG and offline-computed, the search is efficient and does not incur runtime overhead during inference.

The resulting path is a complete static cache schedule. Each path corresponds to a schedule of which segments are cached and which timesteps receive full computation. The budget $(i \rightarrow j)$3 controls the number of full forward steps, so the scheduler trades off speed and fidelity. The paper instantiates this as two configurations: LeMiCa-slow, described as fidelity-focused with larger $(i \rightarrow j)$4, and LeMiCa-fast, described as speed-focused with smaller $(i \rightarrow j)$5. The appendix reports the following model forward steps: Open-Sora 1.2, original 30, slow 19, fast 11; Latte, original 50, slow 27, fast 14; CogVideoX, original 50, slow 27, fast 16.

5. Theoretical motivation, practical guarantees, and empirical behavior

The key theoretical claim is that the lexicographic minimax criterion explicitly bounds the worst-case path error (Gao et al., 30 Oct 2025). The motivation is that early cache errors are amplified during denoising, local greedy methods can make a seemingly safe local choice that causes large downstream degradation, and minimizing the maximum edge error suppresses those error spikes. The practical guarantee stated in the paper is that minimizing the largest segment error first reduces the chance that a single bad cache decision ruins the whole trajectory.

On this basis, the paper argues for better preservation of global content, improved style consistency, and fewer visible artifacts from accumulated error. This is especially important because the diffusion process is not additive: errors made early can propagate and magnify, so controlling the peak error improves the final video much more than only reducing average local differences.

The reported experiments provide the concrete performance profile. On Open-Sora, LeMiCa-slow achieves LPIPS $(i \rightarrow j)$6, SSIM $(i \rightarrow j)$7, and PSNR $(i \rightarrow j)$8, while TeaCache-slow reports LPIPS $(i \rightarrow j)$9, SSIM $i$0, and PSNR $i$1. On Latte, LeMiCa-slow reports LPIPS $i$2, compared with TeaCache-slow at LPIPS $i$3. On CogVideoX, LeMiCa-slow reports LPIPS $i$4, compared with TeaCache-slow at LPIPS $i$5. For acceleration, LeMiCa-fast achieves $i$6 speedup on Open-Sora, $i$7 on Latte, and $i$8 on CogVideoX. The abstract highlights a $i$9 speedup on the Latte model and an LPIPS score of $j$0 on Open-Sora.

A dedicated comparison also reports the effect of path strategy. The paper gives: Original with VBench $j$1; Shortest Path with VBench $j$2, LPIPS $j$3, SSIM $j$4, and PSNR $j$5; MiniMax Path with VBench $j$6, LPIPS $j$7, SSIM $j$8, and PSNR $j$9. The paper states that this directly supports the claim that minimax-style path selection is better than shortest-path because edge errors are not independent and cannot simply be summed.

The offline procedure is reported as inexpensive: edge weight estimation is about $i$0 min / prompt, graph construction is $i$1 sec, and path optimization is $i$2 sec. The stated conclusion is that the optimization improves inference while adding negligible runtime overhead.

6. Relation to broader lexicographic minimization and minimax path theory

Lexicographic minimax is not unique to diffusion-video cache scheduling. In graph orientation, "Strongly connected orientation with minimum lexicographic order of indegrees" proves that SC-PATH-REVERSAL finds a strongly connected orientation that minimizes the lexicographic order of the indegrees (Zhou et al., 2021). There the lexicographic objective is defined on the indegree sequence sorted in non-increasing order, and the optimization is characterized as minimizing the largest indegree, and among all such orientations minimizing the second-largest indegree, and so on. This establishes that lexicographic minimization refines a plain minimax objective rather than replacing it with an unrelated criterion.

In symbolic dynamics, "Symbol ratio minimax sequences in the lexicographic order" studies maximal sequences with prescribed asymptotic proportions and defines the $i$3-infimax as $i$4 and the $i$5-minimax when that infimum is attained (Boyland et al., 2013). The paper proves

$i$6

and states that the infimax is a minimax if and only if $i$7. This use of lexicographic minimization is not a path problem in the graph-theoretic sense, but it shows that lexicographic minimax methods also arise as constraint-sensitive optimization over ordered symbolic objects.

By contrast, "An efficient implementation for solving the all pairs minimax path problem in an undirected dense graph" addresses the all-pairs minimax path problem or widest path problem in an undirected dense graph, with an $i$8 implementation for the APPD matrix (Liu, 2024). That paper defines the minimax path distance as the smallest possible value of the maximum edge weight among all paths between two vertices, and it states that the path between any two nodes in a minimum spanning tree is a minimax path. However, it also states that the paper itself does not develop lexicographic minimax path optimization explicitly. Its relevance is therefore narrower: it shows that bottleneck-style path optimization can be computed efficiently, which suggests that efficient minimax primitives may support more complex lexicographic path objectives, but it does not itself solve the lexicographic variant.

Taken together, these works clarify a frequent source of confusion. Minimum maximum cost, widest path, lexicographic minimax, and additive shortest path are related but distinct objectives. Lexicographic minimax path optimization is the strictest of these in the LeMiCa setting: it minimizes the worst cached error, then the second worst, and so on, under a fixed computation budget and with edge weights that encode final-output degradation rather than local stepwise discrepancy.