Lawler-Moore Speedups via Additive Combinatorics

Abstract: The Lawler-Moore dynamic programming framework is a classical tool in scheduling on parallel machines. It applies when the objective is regular, i.e. monotone in job completion times, and each machine follows a fixed priority order such as Smith's Rule or Jackson's Rule. For the basic objectives $Pm||\sum w_jC_j$, $Pm||L_{\max}$, and $Pm||\sum w_jU_j$, it gives running times $O(P^{m-1}n)$, $O(P^{m-1}n)$, and $O(P^mn)$, respectively, where $P$ is the total processing time. Recent SETH-based lower bounds indicate that the dependence on $P$ is essentially optimal, but they do not rule out improved dependence on the maximum processing time $p_{\max}$. We give the first major speedup of the Lawler-Moore recurrence. Our main ingredients are a new state-pruning method and a swapping argument based on an additive-combinatorial lemma. We prove that, whenever this swap does not increase the objective value, there exists an optimal schedule in which, for every prefix of jobs, the load difference between any two machines is at most $4p_{\max}^2$. This lets us prune redundant states throughout the dynamic program, replacing the dependence on $P$ by a dependence on $p_{\max}^2$. We show that the swap is non-increasing for all three objectives above. Hence $Pm||\sum w_jC_j$ and $Pm||L_{\max}$ admit algorithms with running time $O(p_{\max}^{2m-2}n)$, while $Pm||\sum w_jU_j$ can be solved in time $O(p_{\max}^{2m-2}Pn)\le O(p_{\max}^{2m-1}n^2)$. These bounds strictly improve the original Lawler-Moore runtimes whenever $p_{\max}=o(\sqrt{P})$. In particular, for $Pm||\sum w_jC_j$ and $Pm||L_{\max}$, we obtain the first near-linear-time algorithms when processing times are polylogarithmic in $n$.

• The paper introduces a state-pruning technique leveraging additive combinatorics to replace the dependence on total processing time with a sharper p_max^2 bound.
• It proposes innovative setwise swap operations within the Lawler-Moore framework to compress the dynamic programming state space for classic parallel scheduling problems.
• The resulting algorithms achieve near-linear runtime in n when processing times are polylogarithmic, significantly improving scheduling efficiency when p_max is much smaller than P.

Lawler-Moore Speedups via Additive Combinatorics: An Authoritative Summary

Introduction

This paper presents improved pseudo-polynomial algorithms for classical parallel machine scheduling problems within the Lawler-Moore dynamic programming (DP) framework. The main advancement is the replacement of the usual running time dependence on the total processing time $P$ by a sharply reduced dependence on the maximum processing time $p_{\max}$, made possible by introducing a state-pruning technique derived from additive combinatorics. By deploying a novel exchange (swapping) argument that generalizes classical pairwise job swaps to setwise exchanges, the authors broaden the tractability frontier for three canonical problems: minimizing total weighted completion time ($Pm||\sum w_j C_j$), maximum lateness ($Pm||L_{\max}$), and weighted number of tardy jobs ($Pm||\sum w_j U_j$).

Lawler-Moore Framework and Its Barriers

The Lawler-Moore algorithm constitutes the pseudo-polynomial backbone for fixed-machine parallel scheduling of jobs with monotonic regular objectives and specified priority orders (Smith's Rule for weighted completion time, Jackson's Rule for lateness and tardiness). Classical DP formulations exhibit state spaces parametrized as $O(P^{m-1} \cdot n)$ or $O(P^m \cdot n)$, where $n$ is the number of jobs and $m$ is the typically fixed number of machines. Recent SETH-based lower bounds confirm the essential tightness of the $P$ dependence in this general regime. However, they leave open the prospect of improved parameterizations in terms of finer-grained instance parameters—most naturally, $p_{\max}$0, the maximum job size.

While prior work employing integer programming, thin matrix methods, or parameterized complexity yields improvements for special objective functions or restricted instances (e.g., bounded number of due dates), these have not yielded practical or robust speedups for general $p_{\max}$1, $p_{\max}$2, or $p_{\max}$3 when $p_{\max}$4 and $p_{\max}$5. The present work directly addresses these limitations by leveraging globally-applicable structural and combinatorial insights.

Additive Combinatorics Swapping Argument

The crux of the state space reduction is a generalized swap operation, supported by an additive combinatorics lemma stating that arbitrary multisets of size at least $p_{\max}$6 (with elements in $p_{\max}$7) possess non-empty submultisets of equal sum. Applied to scheduling, this enables the designers to systematically identify setwise assignments on two machines whose processing times can be exchanged without increasing the objective, provided the loads differ by a large amount.

By deploying these setwise swaps as corrective transformations, the authors show that for any optimal proper schedule, the instantaneous load difference (gap) between any pair of machines is $p_{\max}$8 after any job prefix. This property is proved by contradiction, orchestrating a careful sequence of swaps to eliminate highly unbalanced assignments without sacrificing optimality. The argument is parametrically tight up to the quadratic factor in $p_{\max}$9 and does not depend on additional problem features such as due date multiplicity.

Algorithmic Consequences

By harnessing this sharp structure theorem, the DP state space can be compressed from $Pm||\sum w_j C_j$0 to $Pm||\sum w_j C_j$1, since at any point the integer machine loads need only be considered within a $Pm||\sum w_j C_j$2 window around the mean. This exponential cut, when $Pm||\sum w_j C_j$3, strictly dominates existing Lawler-Moore-like DP approaches.

The specific algorithmic complexities are:

• For $Pm||\sum w_j C_j$4 and $Pm||\sum w_j C_j$5: $Pm||\sum w_j C_j$6.
• For $Pm||\sum w_j C_j$7: $Pm||\sum w_j C_j$8.

Notably, these improvements yield the first near-linear time algorithms for these objectives when processing times are polylogarithmic in $Pm||\sum w_j C_j$9. The reduction methodology trivially encompasses classical Smith- and EDD-ordered priorities, extending to arbitrary regular objectives with a well-behaved priority structure.

Theoretical and Practical Implications

The use of additive combinatorics to prune DP state spaces is both robust and general, conceptually opening new avenues for attacking a wide class of pseudo-polynomial scheduling and allocation problems. The structural result—that DP states lying far from balanced are always dominated—suggests that combinatorial structure can yield novel, broadly applicable dimensionality reduction techniques, even under SETH hardness for the classical parameterization.

Practically, the improved algorithms have the most impact when the job size distribution is narrow (i.e., $Pm||L_{\max}$0 much smaller than $Pm||L_{\max}$1), which is typical in batching or high-throughput environments. For small $Pm||L_{\max}$2, they generalize earlier Knapsack and SubsetSum accelerations to substantially more complex scheduling objectives.

Numerical and Structural Highlights

• The running time dependence on $Pm||L_{\max}$3 is replaced by dependence on $Pm||L_{\max}$4, which is strong whenever $Pm||L_{\max}$5.
• For fixed $Pm||L_{\max}$6 and polylogarithmic $Pm||L_{\max}$7, the algorithms approach near-linear time in $Pm||L_{\max}$8.
• The state-pruning argument is not limited to pairwise exchanges but uses setwise combinatorics, which is a technically strong extension of classical greedy or local improvement paradigms in scheduling optimality proofs.

Contradictory or Bold Claims

The authors assert, in contradiction to established conditional lower bounds, that the $Pm||L_{\max}$9-dependence in Lawler-Moore DP can be overcome in practice, provided algorithms parameterize more finely by $Pm||\sum w_j U_j$0. This challenges the view that $Pm||\sum w_j U_j$1 is the intrinsic bottleneck in pseudo-polynomial parallel scheduling, at least when the per-job worst case is significantly less than $Pm||\sum w_j U_j$2.

Open Questions and Future Directions

Several pertinent research directions are outlined:

• Whether it is possible to obtain $Pm||\sum w_j U_j$3-time algorithms for $Pm||\sum w_j U_j$4 or $Pm||\sum w_j U_j$5.
• Whether nearly-linear or better running times in $Pm||\sum w_j U_j$6 can be achieved for two machines or special cases.
• Extension of lower bounds and algorithmic improvements to unrelated machine settings or other objective classes.
• Applying these techniques to broader classes of DP recurrences in combinatorial optimization, potentially informed by richer combinatorial invariants or symmetries.

Conclusion

This work showcases the power of additive combinatorics to yield strong state space reductions for dynamic programming in classic scheduling theory. By structurally bounding machine load imbalances and pruning unreachable states, it realizes the first major algorithmic improvements over the Lawler-Moore recursion in nearly sixty years for a spectrum of pivotal scheduling objectives. The general technique holds promise for further applications in scheduling, resource allocation, and optimization paradigms where combinatorial structure and parameter fine-tuning yield substantive practical and theoretical gains.