Scheduling Lower Bounds via AND Subset Sum

Given $N$ instances $(X_1,t_1),\ldots,(X_N,t_N)$ of Subset Sum, the AND Subset Sum problem asks to determine whether all of these instances are yes-instances; that is, whether each set of integers $X_i$ has a subset that sums up to the target integer $t_i$. We prove that this problem cannot be solved in time $\tilde{O}((N \cdot t_{max})^{1-\epsilon})$, for $t_{max}=\max_i t_i$ and any $\epsilon>0$, assuming the $\forall \exists$ Strong Exponential Time Hypothesis ($\forall \exists$-SETH). We then use this result to exclude $\tilde{O}(n+P_{max} \cdot n^{1-\epsilon})$-time algorithms for several scheduling problems on $n$ jobs with maximum processing time $P_{max}$, based on $\forall \exists$-SETH. These include classical problems such as $1||\sum w_jU_j$, the problem of minimizing the total weight of tardy jobs on a single machine, and $P_2||\sum U_j$, the problem of minimizing the number of tardy jobs on two identical parallel machines.


Introduction
The Subset Sum problem is one of the most fundamental problems in computer science and mathematics: Given n integers X = {x 1 , . . . , x n } ⊂ N, and a target value t ∈ N, determine whether there is a subset of X that sums 1 to t. This problem appeared in Karp's initial list of 21 NP-complete problems [24], and entire books have been devoted to it and to its closely related variants [25,30]. Most relevant to this paper is the particular role Subset Sum plays in showing hardness for various problems on integers, essentially being the most basic such problem where hardness arises exclusively from the additive nature of the problem. In particular, in areas such as operations research, Subset Sum plays a similar role to that of 3-SAT, serving as the core problem used in the vast majority of reductions (see e.g. [9,11,15,24,28,32]). Many important problems can be shown to be generalizations of Subset Sum (by easy reductions) including scheduling problems, Knapsack, and Bicriteria Shortest Path. The broad goal of this paper is to understand the fine-grained complexity of such important problems, and more specifically whether the complexity of such generalizations is the same as that of Subset Sum or higher. While Subset Sum (and its generalizations) is NP-hard, it is well-known that it can be solved in pseudo-polynomial time O(t · n) with the classical dynamic programming algorithm of Bellman [6]. Much more recently, this upper bound was improved to O(t + n) [7,23,27]; this is a significant improvement in the dense regime of the problem, e.g. if t = O(n 2 ) the new algorithms achieve quadratic as opposed to cubic time. Most recently, in the dense regime the fine-grained complexity of Subset Sum was essentially resolved under the Strong Exponential Time Hypothesis (SETH) by the authors of this paper [1] (the same lower bound was previously known under the incomparable Set Cover Conjecture [12]). SETH [21,22] postulates that there is no O(2 (1−ε)n )-time algorithm for deciding the satisfiability of a k-CNF formula, for some ε > 0 independent of k. Theorem 1.1 (Hardness of Subset Sum [1]). Assuming SETH, there is no ε > 0 and δ < 1 such that Subset Sum on n numbers and target t can be solved in time O(t 1−ε · 2 δn ).
The lower bound given by Theorem 1.1 translates directly to several generalizations of Subset Sum, but does this yield tight lower bounds for the generalizations? Or can we prove higher lower bound for them? To answer this kind of question, the OR Subset Sum problem was introduced in [1]: Given N instances (X 1 , t 1 ), . . . , (X N , t N ) of Subset Sum, determine whether at least one of these instances is a yes-instance; that is, whether there exists an i ∈ {1, . . . , N } such that X i contains a subset that sums up to t i . While it seems natural to assume that no algorithm can solve this problem faster than solving each of the N Subset Sum instances independently, it is not clear how to prove this. In fact, an O(N 1/10 · max i t i ) time algorithm for this problem does not directly break the lower bound for Subset Sum. Nevertheless, one can still show a tight lower bound by taking a somewhat indirect route: SAT does have a reduction to its OR variant, and then Theorem 1.1 allows us to reduce OR SAT to OR Subset Sum. Theorem 1.2 (Hardness of OR Subset Sum [1]). Assuming SETH, there are no ε, δ > 0 such that there is an O(N 1+δ−ε ) time algorithm for the following problem: Given N Subset Sum instances, each with O δ,ε (lg N ) integers and target O(N δ ), determine whether one of these instances is a yes-instances.
Thus, while Subset Sum admits 2 O(n + t)-time algorithms [7,23,27], SETH rules time O(N + t) for OR Subset Sum. For example, when N = O(n) and t = O(n 2 ), Subset Sum can be solved in time O(n 2 ), but OR Subset Sum has a cubic lower bound according to the above theorem. This distinction was used in [1] to show a higher lower bound for a generalization of Subset Sum that is a particularly prominent problem in the operations research community, the Bicriteria Shortest Path problem [19,41]: Given a graph G with edge lengths and edge costs, two vertices s and t, and a budget B, determine whether there is an s, t-path of total length at most B and total cost at most B. While Theorem 1.1 immediately rules out time , it leaves open the possibility of an O(B + n) algorithm (as is known to exist for Subset Sum). As it turns out, Bicriteria Shortest Path can not only encode a single Subset Sum instance, but even several instances, and thus Theorem 1.2 yields an Ω(n + Bn 1−ε ) lower bound under SETH.

An Analogue of Theorem 1.2 for AND Subset Sum
While the OR variant in Theorem 1.2 is perfectly suited for showing lower bounds for Bicriteria Shortest Path and other problems of a similar type, there are others, such as the scheduling problems discussed below, whose type can only capture an AND variant: Given N instances of Subset Sum, determine whether all are yes-instances. It is natural to wonder whether there is a fine-grained reduction from SAT to AND Subset Sum (either directly or indirectly, by first reducing to AND SAT). Intuitively, the issue is that SAT, Subset Sum, and their OR variants have an ∃ quantifier type, while AND SAT and AND Subset Sum have a ∀∃ quantifier type. Reducing one type to another seems very challenging, but fortunately, a morally similar challenge had been encountered before in fine-grained complexity and resolved to some extent as follows.
First, we can observe that the reduction we are looking for is impossible under the Nondeterministic Strong Exponential Time Hypothesis (NSETH) [10] which states that no non-deterministic O(2 (1−ε)n )-time algorithm can decide whether a given k-CNF is unsatisfiable, for an ε > 0 independent of k. This hypothesis was introduced to show nonreducibility results. Intuitively, NSETH says that even though SAT is easy for nondeterministic algorithms its complement is not. Therefore, if for a certain problem both it and its complement are easy for nondeterministic algorithms then a reduction from SAT is impossible. Note that AND SAT, AND Subset Sum, and their complements admit efficient nondeterministic algorithms: to prove that the AND is "yes" we can guess a solution in each instance, and (for the complement) to prove that the AND is "no" we can guess the index of the instances that is "no". (Notice that the latter is not possible for the OR variants.) There are already conjectures in fine-grained complexity that can capture problems with a ∀∃ type. In the "n 2 regime", where SAT is faithfully represented by the Orthogonal Vectors (OV) problem 3 which has an ∃ type, Abboud, Vassilevska Williams and Wang [2] introduced a hardness hypothesis about the Hitting Set (HS) problem 4 which is the natural ∀∃ type variant of OV. This hypothesis was used to derive lower bounds that cannot (under NSETH) be based on OV or SETH, e.g. for graph median and radius [2,3,13] and for Earth Mover Distance [35], and was also studied in the context of model checking problems [18]. Going back to the "2 n regime", the analogous hypothesis, which implies the HS hypothesis, is the following.
Hypothesis (∀∃-SETH). There is no 0 < α < 1 and ε > 0 such that for all k ≥ 3 we can decide in time O(2 (1−ε)n ), given a k-CNF formula φ on n variables x 1 , . . . , x n , whether for all assignments to x 1 , . . . , x α·n there exists an assignment to the rest of the variables that satisfies φ, that is, whether: ∀x 1 , . . . , x α·n ∃x α·n +1 , . . . , x n : φ(x 1 , . . . , x n ) = true. 3 Given two sets of n binary vectors of dimension O(log n), decide whether there is a vector in the first set and a vector of the second set that are orthogonal. SETH implies that this problem cannot be solved in time O(n 2−ε ) [40], and essentially all SETH-based n 2 lower bounds go through this problem. 4 Given two sets of n binary vectors of dimension O(log n), decide whether for all vectors in the first set there is an orthogonal vector in the second set. The Hitting Set Hypothesis states that this problem cannot be solved in time O(n 2−ε ) for any ε > 0.

4:4 Scheduling Lower Bounds via AND Subset Sum
Note that this hypothesis may also be thought of as the Π 2 -SETH, where Π 2 is the second level of the polynomial hierarchy, and one can also think of higher levels of the polynomial hierarchy. Indeed, Bringmann and Chaudhury [8] recently proposed such a version, called Quantified-SETH, in which we can have any constant number q ≥ 1 of alternating quantifier blocks, with a constant fraction of the variables in each block 5 . Non-trivial algorithms for Quantified-SAT exist [37], but none of them can refute even the stronger of these hypotheses.
It is important to note that while ∀∃-SAT is a strictly harder problem than SAT (as adding more quantifiers can only make the problem harder), in the restricted setting of ∀∃-SETH, where there is a constant fraction of the variables in each quantifier block, the situation is the opposite! A faster algorithm for SAT does imply a faster algorithm for ∀∃-SAT: exhaustively search over all assignments to the universally quantified αn variables and for each assignment solve SAT on (1 − α)n variables. A reduction in the other direction is impossible under NSETH 6 . Therefore, ∀∃-SETH is a stronger assumption than SETH, which explains why it is helpful for proving more lower bounds, yet it seems equally plausible (to us). In particular, it gives us a tight lower bound for AND Subset Sum which we will use to show higher lower bounds for scheduling problems. Note that in comparison with the OR Subset Sum case (Theorem 1.2), the size of our instances is polynomial O(N ε ) instead of logarithmic O δ,ε (log N ). We leave it as an open problem whether this is inherent or Theorem 1.3 can be improved.
It follows from Theorem 1.3 that AND Subset Sum on N instances, each on at most s integers and with target at most t, cannot be solved in time O(N s + t(N s) 1−ε ). We show that the same holds for the Partition problem, which is the special case of Subset Sum where the target is half of the total input sum. This is the starting point for our reductions in the next section.

Scheduling lower bounds
To exemplify the power of Theorem 1.3, we use it to show strong lower bounds for several non-preemptive scheduling problems that generalize Subset Sum. These problems include some of the most basic ones such as minimizing the total weight of tardy jobs on a single machine, or minimizing the number of tardy jobs on two parallel machines. Theorem 1.5 below lists all of these problems; they are formally defined in Section 3 and each requires a different reduction. To describe the significance of our new lower bounds more clearly, let us focus on only one of these problems, P 2 || U j , for the rest of this section. The input to this problem is a set of n jobs, where each job J j has a processing time p j and a due date d j , and the goal is to schedule all jobs on two parallel machines so that the number of jobs exceeding their due dates is minimal. Let P = j p j and P max = max j p j denote the sum of processing times and maximum processing time of the input jobs. Observe that P ≤ P max · n.
The standard dynamic programming algorithm for this problem runs in O(P · n) = O(P max · n 2 ) time [29], and it is not known whether this running time is the best possible. Nevertheless, there is a well-known easy reduction from Subset Sum on numbers x 1 , . . . , x n to P 2 || U j that generates an instance with total processing time P = Thus, using Theorem 1.1, we can rule out P 1−ε · 2 o(n) -time and P 1−ε max · 2 o(n) -time algorithms for P 2 || U j . However, this leaves open the possibility of O(P max + n)-time algorithms, which would be near-linear as opposed to the currently known cubic algorithm in a setting where P max = Θ(n) and P = Θ(n 2 ). One approach for excluding such an upper bound is to first prove the impossibility of an algorithm for Subset Sum with running time O(max x∈X x + n). However, such a result has been elusive and is perhaps the most interesting open question in this context [4,16,17,27,33]. Instead, taking an indirect route, we are able to exclude such algorithms with an Ω(n + P max n 1−ε ) lower bound under ∀∃-SETH by showing that P 2 || U j can actually encode the AND of several Subset Sum instances. In particular, in the above regime we improve the lower bound from linear to quadratic.
All problems listed in this theorem are direct generalizations of Subset Sum, and each one admits a O(P · n) = O(P max · n 2 )-time algorithm via dynamic programming [29,36,38].
We note that the distinction between running times depending on P versus P max and n relates to instances with low or high variance in their job processing times. In several experimental studies, it has been reported by researchers that the ability of scheduling algorithms to solve NP-hard problems deteriorates when the variance in job processing time increases (see e.g. [26,31,34]). Our results provide theoretical evidence for this claim by showing tighter lower bounds on the time complexity of several scheduling problems based on the maximum processing time P max .

Quantified SETH Hardness of AND Subset Sum
In the following we provide a proof for Theorem 1.3, the main technical result of the paper. For this, we present a reduction from Quantified k-SAT to AND Subset Sum which consists of two main steps. The first step uses a tool presented in [1] which takes a (non-quantified) k-SAT instance and reduces it to subexponentially many Subset Sum instances that have relatively small targets. The second step is a new tool, which we develop in Section 2.2, that takes many Subset Sum instances and reduces them to a single instance with only a relatively small increase of the output target.

Main construction
The following two theorems formally state the two main tools that are used in our construction.
Note that for our purpose, the important property here is the manageable increase of the output target in both theorems. The proof of Theorem 2.1 can be found in [1], while the proof of Theorem 2.2 is given in Section 2.2.  1]). For any ε > 0 and k ≥ 3, given a k-SAT formula φ on n variables, we can in time 2 εn · n O(1) construct 2 εn Subset Sum instances, each with O(n) integers and target at most 2 (1+ε)n , such that φ is satisfiable if and only if at least one of the Subset Sum instances is a yes-instance.

I C
Using the two results above, the proof of Theorem 1.3 follows by combining both constructions given by the theorems: Proof of Theorem 1.3. Let φ be a k-SAT formula on n variables and let 0 < α < 1. We write n 1 = α · n and n 2 = n − n 1 , so that n 1 ≤ αn and n 2 ≤ (1 − α)n + 1. Our goal is to We enumerate all assignments ∂ of the variables x 1 , . . . , x n1 , and let φ ∂ be the resulting k-SAT formula on n 2 variables after applying ∂. Note that there are 2 n1 formulas φ ∂ .
For each formula φ ∂ , we run the reduction from Theorem 2.1 with parameter ε 0 , resulting in a set I ∂ of at most 2 ε0n2 Subset Sum instances such that φ ∂ is satisfiable if and only if at least one of the instances in I ∂ is a yes-instance. Note that each Subset Sum instance in I ∂ consists of O(n 2 ) = O(n) integers and has target at most t = 2 (1+ε0)n2 . Moreover, running this reduction for all formulas φ ∂ takes time 2 n1+ε0n2 n O (1) .
Next, using Theorem 2.2, we reduce I ∂ to a single Subset Sum instance (X ∂ , t ∂ ) such that (X ∂ , t ∂ ) is yes-instance if and only if φ ∂ is a yes-instance, and so φ is a yes-instance if and only if all (X ∂ , t ∂ ) are yes-instances. Note that we have |X ∂ | = O(n · 2 ε0n2 ) and t ∂ = O(2 (1+ε0)n2 · (n · 2 ε0n2 ) γ ) for some constant γ > 0 that replaces a hidden constant in Theorem 2.2. Moreover, running this step for all formulas φ ∂ takes time O(2 n1 · (n2 ε0n2 ) γ ), where again γ > 0 replaces a hidden constant in Theorem 2.2.
Proof of Corollary 1.4. Fix any δ > 0, and let ε > 0 to be chosen later. For given Subset Sum instances (X 1 , t 1 ), . . . , (X N , t N ), each with O(N ε ) integers and target O(N δ ), our goal is to determine whether all of these instances are yes-instances.
For each i, we construct a Partition instance (X * i , t * i ) by setting It is easy to see that the Partition instance (X * i , t * i ) is equivalent to the Subset Sum instance (X i , t i ). Indeed, the two additional items cannot be put on the same side of the partition, as their sum is too large. Putting them on different sides of the partition, it remains to split X i into a subset Y i ⊆ X i summing to t i and the remainder X i \ Y i summing to ( x∈Xi x) − t i , to obtain a balanced partition.
Observe that |X . Now assume that we can solve AND Partition on N instances, each with at most s integers and target at most t, in time O(N s + t(N s) 1−ε0 ) for some ε 0 > 0. On the instances (X * 1 , t * 1 ), . . . , (X * n , t * N ), this algorithm would run in time Finally, we pick ε := min{δ/2, ε 0 /3} to bound this running time by O(N 1+δ−ε ). This violates Theorem 1.3.

From OR Subset Sum to Subset Sum
We next provide a proof of Theorem 2.2, the second tool used in our reduction from Quantified k-SAT to Subset Sum. We will use the notion of average-free sets. s 1 , . . . , s m+1 ∈ S we have:  t 1 ), . . . , (X N , t N ) be N given Subset Sum instances, and write t = max i t i and n = max i |X i |. We begin by slightly modifying these instances. First, let t * = (n + 1)t, and add to each X i the integer t * − t i . Clearly, there is a subset of X i which sums up to t i if and only if there is a subset of X i ∪ {t * − t i } that sums up to t * . Next, we add at most 2(n + 1) copies of 0 to each instance, ensuring that all instances have the

4:8
Scheduling Lower Bounds via AND Subset Sum same number of integers 2(n + 1), and that any instance which has a solution also has one which includes exactly n + 1 integers. Note that these modifications only change n by a constant factor, and t by a factor O(n), which are negligible for the theorem statement. Therefore, with slight abuse of notation, henceforth we assume that we are given N Subset Sum instances (X 1 , t 1 ), . . . , (X N , t N ) with t 1 = . . . = t N = t and |X 1 | = . . . = |X N | = 2n. Moreover, for any i if there exists a subset Y i ⊆ X i that sums up to t then we can assume without loss of generality that |Y i | = n.
We are now ready to describe our construction of (X 0 , t 0 ). It will be convenient to view the integers in (X 0 , t 0 ) as binary encoded numbers, or binary strings, and to describe how they are constructed in terms of blocks of consecutive bits. Each integer will consist of seven blocks of fixed sizes. Starting with the least significant bit, the first block has lg t bits and is referred to as the encoding block, the third block has lg n bits and is referred to as the counting block, the fifth block has log(n · S max ) = O(log(nN )) bits and is referred to as the verification block, and the last block consists of a single bit. In between these blocks are blocks containing log(2nN ) bits of value 0, whose sole purpose is to avoid overflows.
For each integer x i,j ∈ X i , we construct a corresponding integer x 0 i,j ∈ X 0 as follows (here the "|"-characters are used only to differentiate between blocks, and have no other meaning): Additionally, for each i ∈ {1, . . . , N } we construct an integer x 0 i ∈ X 0 associated with the instance (X i , t i ) as The two sets of integers described above constitute X 0 . To complete the construction of the output instance, we construct the target integer t 0 as (1) , as required by the theorem statement. Furthermore, the time required to construct (X 0 , t 0 ) is (nN log t) O (1) . We next argue that (X 0 , t 0 ) is a yes-instance if and only if (X i , t i ) is a yes-instance for some i ∈ {1, . . . , N }. Suppose that there exists some i ∈ {1, . . . , N } and some Y i ⊆ X i for which xi,j ∈Yi x i,j = t. By the discussion at the beginning of this proof, we can assume that Indeed, by construction, the bits in the encoding block of these integers sum up to xi,j ∈Yi x i,j = t, the bits in the counting block sum up to n, the bits in the verification block sum up to n · S max , and the last bit sums up to 1.
Conversely, assume that there is some subset and let x i1,j1 , . . . , x im,jm ∈ X 1 ∪ · · · ∪ X M denote the integers that appear in the encoding blocks of y 1 , . . . , y m . Observe that as m ≤ 2nM , by our construction the highest bit in each overflow block of Σ(Y 0 ) must be 0. It follows that we can argue in each of the encoding block, counting block, verification block, and last block separately. This yields: x i ,j = t, since if this sum is greater than t then the second block of Σ(Y 0 ) would not be all zeros, and if x i ,j < t then the encoding block of Σ(Y 0 ) would not be t. m = n, by a similar argument in the counting block.
There is exactly one integer of the form x 0 i * in Y 0 , for some i * ∈ {1, . . . , N }, as otherwise the most significant bit of Σ(Y 0 ) would not be 1.
i * = i 1 = · · · = i n : Note that x 0 i * contributes n · (S max − s i * ) to the verification block of Σ(Y 0 ), and so the remaining n integers in Y 0 need to contribute together exactly n · s i * to this block, since the value of this block is n · S max in t 0 . Since S is an n-average-free set, the only way for this to occur is if all of these integers have s i * encoded in their verification blocks, implying that i * = i 1 = · · · = i n . Let i = i * be the index in the last point above. Then x i,j = t by the first point above, and so the subset {x i,j1 , . . . , x i,jn } is a solution for the instance (X i , t i ).

Scheduling Lower Bounds
We next show how to apply Corollary 1.4 to obtain Ω(n + P max · n 1−ε ) lower bounds for several scheduling problems. In particular, we provide a complete proof of Theorem 1.5 in a sequence of lemmas below, each exhibiting a reduction from AND Subset Sum (or rather AND Partition) to the scheduling problem at hand. In each reduction, we start with N Partition instances (X 1 , t 1 ), . . . , (X N , t N ); these are Subset Sum instances with t i = 1 2 x∈Xi x. We write s = max i |X i | and t = max i t i . We present reductions that transform these given instances into an instance I of a certain scheduling problem, such that I is a yes-instance if and only if (X i , t i ) is a yes-instance for all i. The constructed instance I will consist of n = O(N s) jobs with maximum processing time P max = O(t). Since Corollary 1.4 rules out time O(N s + t(N s) 1−ε ) for AND Partition, it follows that the scheduling problem is not in time O(n + P max · n 1−ε ), for any ε > 0 assuming ∀∃-SETH.
For an instance (X i , t i ), we let x i,j denote the j-th integer in X i .

Scheduling Notation and Terminology
In all scheduling problems considered in this paper, we are given a set of jobs J 1 , . . . , J n to be scheduled non-preemptively on one or two identical parallel machines. Each job J j has a processing time p j , and according to the specific problem at hand, it may also have a due date d j , a release date r j , and a weight w j . We always use the same subscript for the job and its parameters. A schedule consists of assigning each job J j a machine M (J j ) and a starting time S j ∈ N ≥0 . The completion time of job j in a given schedule is C j = S j + p j , and the makespan of the schedule is its maximum completion time C max = max j C j . A schedule is feasible if no two distinct jobs overlap on the same machine; that is, for any pair of distinct jobs J j and J k with M (J j ) = M (J k ) and S j ≤ S k we have S k / ∈ [S j , C j ). Furthermore, when release dates are present, we require that S j ≥ r j for each job J j .
A job J j is said to be tardy in a given schedule if C j > d j , and otherwise it is said to be early. For each job J j , we let U j ∈ {0, 1} denote a Boolean variable with U j = 1 if J j is tardy and otherwise U j = 0. In this way, U j denotes the number of tardy jobs in a given schedule, and w j U j denote their total weight. We let T j denote the tardiness of a job J j defined by T j = max{0, C j − d j }, and we let T max = max j T j denote the maximum tardiness of the schedule. Below we use the standard three field notation α|β|γ introduced by Graham et al. [20] to denote the various problems, where α denotes the machine model, β denotes the constrains on the problem, and γ is the objective function. Readers unfamiliar with the area of scheduling are also referred to [32] for additional background.

Problems on Two Machines
We begin by considering scheduling problems on two parallel identical machines, as here our reductions are simpler to describe. Recall that in this setting, a schedule consists of assigning a starting-time S j and a machine M (J j ) to each input job J j .

P 2 |level-order |C max
Perhaps the easiest application of Theorem 1.3 is makespan minimization on two parallel machines when level-order precedence constraints are present [14,39]. In this problem, jobs only have processing-times, and they are partitioned into classes J 1 , . . . , J k such that all jobs in any class J i must be scheduled after all jobs in J i−1 are completed. The goal is to find a feasible schedule with minimum makespan C max = max j C j . Lemma 3.1. P 2 |level-order|C max has no O(n + P max · n 1−ε )-time algorithm, for any ε > 0, unless ∀∃-SETH is false.
Proof. First recall that a single Partition instance (X, t) easily reduces to an instance of P 2 ||C max (i.e. without precedence constraints on the jobs) by creating a job with processing time x for each x ∈ X, and then setting the required makespan C to be C = t. For reducing multiple Partition instances we can use the precedence constraints: For each instance (X i , t i ) of Partition, we create a class of jobs J i which includes a job J i,j for each x i,j ∈ X i with processing time p i,j = x i,j . Then since all jobs in class J i must be processed after all jobs in J 1 , . . . , J i−1 are completed, it is easy to see that the P 2 |level-order|C max instance has a feasible schedule with makespan at most C = i t i if and only if each Partition instance is a yes-instance.
Indeed, if each X i has a subset Y i ⊂ X i which sums up to t i = 1 2 · j x i,j , then we can schedule all jobs J i,j associated with elements x i,j ∈ Y i on the first machine (following all jobs associated with elements in Y 1 , . . . , Y i−1 ), and all jobs J i,j associated with elements x i,j / ∈ Y i on the second machine. This gives a feasible schedule with makespan at most C. Conversely, a schedule with makespan at most C must have the last job in J i complete no later than i0≤i t i0 , for each i ∈ {1, . . . , N }. This in turn can only be done if each X i can be partitioned into two sets that sum up to t i , which implies that each (X i , t i ) is a yes-instance.
Starting from N Partition instances (X 1 , t 1 ), . . . , (X N , t N ), each with at most s integers and target at most t, our reduction constructs n ≤ N s jobs with maximum processing time P max ≤ t. Therefore, any O(n + P max · n 1−ε )-time algorithm for P 2 |level-order|C max would yield an O(N s + t(N s) 1−ε )-time algorithm for AND Partition, which contradicts Corollary 1.4, assuming ∀∃-SETH.

P 2 ||T max and P 2 || U j
We next consider the P 2 ||T max and P 2 || U j problems, where jobs also have due dates, and the goal is to minimize the maximum tardiness and the total number of tardy jobs, respectively. The reduction here is very similar to the previous reduction. We create for each i ∈ {1, . . . , N }, and each x i,j ∈ X i , a job J i,j with processing time p i,j = x i,j and due date Observe

P 2 |r j ≥ 0|C max
Our final dual machine example is the problem of minimizing makespan when release dates are present, the classical P 2 |r j ≥ 0|C max problem. Lemma 3.3. P 2 |r j ≥ 0|C max has no O(n + P max · n 1−ε )-time algorithm, for any ε > 0, unless ∀∃-SETH is false. t 1 ), . . . , (X N , t N ) be N instances of Partition. For each element x i,j ∈ X i we create a job J i,j with processing time p i,j = x i,j and release date r i,j = <i t . Note that there is a schedule for this instance with makespan N i=1 t i , where each job is scheduled no earlier than its release date, if and only if each Partition instance is a yes-instance. Also note that the resulting instance has maximum processing time P max = max i t i and total number of jobs n ≤ N · max i |X i |. As before, using Corollary 1.4 we can now rule out time O(n + P max · n 1−ε ), assuming ∀∃-SETH.

Problems on One Machine
We next consider single machine problems. Obviously, a schedule in this case only needs to specify a starting time S j for each job J j , and in case there are no release dates, a schedule can be simply thought of as a permutation of the jobs.

1|| w j U j
One of the most classical single-machine scheduling problems which already appeared in Karp's initial list of 21 NP-complete problems [24] is the problem of minimizing the total weight of tardy jobs. Here each job J j has a due date d j and weight w j , and the goal is to minimize w j U j .
Proof. Let (X 1 , t 1 ), . . . , (X N , t N ) be N instances of Partition. For each i ∈ {1, . . . , N }, and for each x i,j ∈ X i , we create a job J i,j with the following parameters: We argue that there is a schedule for all jobs J i,j with total weight of tardy jobs at most . . , N }, and let E = i E i and T = i T i . Then any schedule of the form E 1 , . . . , E N , T , where the order inside each subset of jobs is arbitrary, schedules all jobs in E early, and so the total weight of tardy jobs of such a schedule is at most the total weight of T which is w( Conversely, suppose there is a schedule for the jobs J i,j where the total weight of tardy jobs is at most W . Let E i denote the set of early jobs in the schedule with due date d i , for i = {1, . . . , N }, and let E = E i . Then as the total weight of all jobs is 2W , we have w(E) ≥ W = i (N − i + 1) · t i . By our construction, this can only happen if we have w(E i ) ≥ (N − i + 1) · t i for each i ∈ {1, . . . , N }, which in turn can only happen if p(E i ) ≥ t i . Since all jobs in each E i are early, we have p(E i ) ≤ t i , and so p(E i ) = t i . It follows that for each i ∈ {1, . . . , N }, the set Y i = {x i,j : J i,j ∈ E i } = {p i,j : J i,j ∈ E i } sums up to t i . Thus we have found a solution for each Subset Sum instance (X i , t i ), and so the lemma follows.

1|Rej ≤ R| U j and 1|Rej ≤ R|T max
In scheduling with rejection problems [38], jobs J j are allowed not to be scheduled (i.e. rejected) at the cost of w j . Here we consider the case where the total cost of rejected jobs cannot exceed some prespecified bound R. Under this constraint, the 1|Rej ≤ R| U j and 1|Rej ≤ R|T max problems focus on minimizing the number of tardy jobs U j and the maximum tardiness of any job T max , respectively.
Note that there is a direct reduction from the 1|| w j U j problem to the 1|Rej ≤ R| U j and 1|Rej ≤ R|T max problems: An instance of 1|| w j U j has a schedule with total weight at most W if and only if there are jobs of total weight R = W that can be rejected so that all remaining jobs can be scheduled early. Thus, the lemma below immediately follows from Lemma 3.4 above.

1|r j ≥ 0, Rej ≤ R|C max
In this problem, each job J j has a processing time p j , a release date r j , and a weight w j , and the goal is to find a schedule that rejects jobs with total weight at most R and minimizes the makespan of the remaining non-rejected jobs. Lemma 3.6. There is no O(n + P max · n 1−ε )-time algorithm for 1|r j ≥ 0, Rej ≤ R|C max , for any ε > 0, unless ∀∃-SETH is false.
Proof. Let (X 1 , t 1 ), . . . , (X N , t N ) be N instances of Partition. For each i ∈ {1, . . . , N }, and for each x i,j ∈ X i , we create a job J i,j with: processing time p i,j = x i,j , weight w i,j = i · x i,j , and release date r i,j = r i = i−1 =1 t . We argue that there is a schedule for all jobs J i,j with makespan at most C = i t i that rejects jobs with cost at most R = i i · t i if and only if each Partition instance (X i , t i ) is a yes-instance.
Suppose that each X i has a subset Y i ⊆ X i which sums up to t i . Let , . . . , N }, and let E = i E i and T = i T i . Then any schedule of the form E 1 , . . . , E N , where the jobs in T are rejected, respects all release dates of jobs in E, and has makespan C max = i t i = C. Moreover, the total cost of the rejected jobs is w( Conversely, suppose there is schedule for the jobs J i,j that respects all release dates, rejects jobs with weight at most R, and has makespan at most C. Let E i denote the set of non-rejected jobs with release date r i , for i = {1, . . . , N }, and let E = E i . Then as the total weight of all jobs is 2R, we have w(E) ≤ R = i i · t i . By our construction, this can only happen if we have w(E i ) ≥ i · t i for each i ∈ {1, . . . , N }, which in turn can only happen if p(E i ) ≥ t i . On the other hand, the release date r i+1 of jobs in E i+1 can be respected only if p(E i ) ≤ r i+1 = i =1 t , and so p(E i ) = t i . It follows that for each i ∈ {1, . . . , N }, the set Y i = {x i,j : J i,j ∈ E i } = {p i,j : J i,j ∈ E i } sums up to t i . Thus, we have found a solution for each Subset Sum instance (X i , t i ), and so the lemma follows.