Scheduling jobs with a V-shaped time-dependent processing time

In the field of time-dependent scheduling, a job’s processing time is specified by a function of its start time. While monotonic processing time functions are well-known in the literature, this paper introduces non-monotonic functions with a convex, piecewise-linear V-shape similar to the absolute value function. They are minimum at an ideal start time, which is the same for all given jobs. Then, the processing time equals the job’s basic processing time. Earlier or later, it increases linearly with slopes that can be asymmetric and job-specific. The objective is to sequence the given jobs on a single machine and minimize the makespan. This is motivated by production planning of moving car assembly lines, in particular, to sequence a worker’s assembly operations such that the time-dependent walking times to gather materials from the line-side is minimized. This paper characterizes the problem’s computational complexity in several angles. NP-hardness is observed even if the two slopes are the same for all jobs. A fully polynomial time approximation scheme is devised for the more generic case of agreeable ratios of basic processing time and slopes. In the most generic case with job-specific slopes, several polynomial cases are identified.


Introduction
Sequencing a set of jobs on a single machine such that the makespan is minimized is trivial if each job's processing time is constant, because any job sequence is optimal in this case. In contrast, if each job's processing time is a function of its start time, then the job sequence alters the processing times. For example, if a swap of two jobs changes the sum of their processing times, then all succeeding jobs are shifted, which possibly necessitates a reoptimization. Hence, timedependent processing times add a layer of complexity, and already the makespan minimization poses a challenge.

Processing time function
In time-dependent scheduling, the classic effect of a job's start time on its basic processing time is additive. Here, a B Helmut A. Sedding helmut.sedding@zhaw.ch 1 Institute of Theoretical Computer Science, Ulm University, Ulm, Germany 2 Institute of Data Analysis and Process Design, ZHAW Zurich University of Applied Sciences, Winterthur, Switzerland penalty function j of start time t is added to the basic processing time j ≥ 0 of a job j to obtain the processing time p j (t) = j + j (t) (1) of job j. Then, the job is completed at Consequently, the completion time of a sequence of several jobs equals the composition of their completion time functions. For example, consider job sequence (1, 3, 2): If it is started at time t, then it completes at C 2 (C 3 (C 1 (t))).
Although existing literature studies many variations of j , they are largely restricted to monotonic, i.e., nondecreasing or nonincreasing forms (Gawiejnowicz 2008(Gawiejnowicz , 2020aStrusevich and Rustogi 2017). A present practical case, arising in the context of moving assembly lines, requires a non-monotonic penalty function (Sedding 2020b), joining research lines on monotonic forms.
In particular, we explore the job-specific, non-monotonic, piecewise-linear V-shaped penalty function (3) Fig. 1 Given an example instance of the studied problem P with the global start time t min = 0, the common ideal start time τ = 10, eight jobs, and for job j = 1, . . . , 7, the basic processing time j = j and the two common slopes a j = 0.1, b j = 0.2. Depicted is the only one job sequence that provides the minimum makespan for this instance. It arranges job 2 as the straddler job χ, and partitions the other jobs into set A = {4, 3, 1} and set B = {5, 6, 7}. Please observe that the jobs of A and B are sequenced in opposite orders, and that in this example, the straddler job χ is not the job with the smallest basic processing time It joins two linear pieces at one certain point, the so-called common ideal start time τ , which is the same for all jobs. Each linear piece is described by a job-specific slope, namely 1 ≥ a j ≥ 0 and b j ≥ 0. Note that all numbers are rational. We observe that the domains of a j and b j ensure a nondecreasing completion time function C j . Thus, delaying a job by inserting idle time does not reduce its completion time.

Problem setting
For a set of jobs of the described time-dependent processing times (1) with the additive V-shaped penalty functions (3), let us define the scheduling problem P. Several rational numbers define an instance of P: a start time t min for the first job, a common ideal start time τ , and for each job j, a basic processing time j ≥ 0 and slopes 1 ≥ a j ≥ 0, b j ≥ 0. A permutation of the jobs (a so-called job sequence) determines the order in which to successively execute the jobs starting from t min on a single machine without idle time, completing at C max . Then, the objective in P is to find a job sequence that minimizes the makespan φ = C max − t min . Such a sequence is called optimal, and solves the P instance. For sequencing a given set of jobs, one needs to decide -which jobs should complete before the common ideal start time τ (denoted by job set A), and -which job should be the first job that starts before or at τ and that as well completes at or after τ (this job is called the straddler job χ ) if it exists; -then, the remaining jobs (excluding the straddler job, if it exists) all start at or after τ (job set B).
Once this decision is made, the corresponding job sequence can be constructed in polynomial time by sorting set A and set B, and linking them, if applicable, with the straddler job χ in between. Thus, the main computational effort to find an optimal job sequence resides in choosing a suitable partition into the two sets. Figure 1 visualizes an optimal job sequence and the described parts of an example instance.

Fig. 2
The studied problem P models a moving assembly line planning problem, in which a worker's walking time to a material supply point and back depends on the current position of the worker's continuously moving work piece. The supply point is passed by the work piece at a certain point in time, τ , at which the incurred walking time is minimum. Earlier or later, is increases linearly with asymmetric slopes, which relate the back-and-forth walking velocities to the work piece's velocity Let us mention special cases of P: • Case P agreeable asserts i a j ≤ j a i ⇐⇒ i b j ≤ j b i for any pair i, j of jobs, which we call agreeable ratios of basic processing time and slopes. • This property is also fulfilled by the special case of related slopes, which scales common basic slopes 1 ≥ a ≥ 0, b ≥ 0 by a job-specific rational scale factor 1 ≥ v j ≥ 0 to a j = av j and b j = bv j for each job j. • Special cases of related slopes are monotonic slopes where either a j = 0 for each job j, which yields a nondecreasing p j , or b j = 0 for each job j, which yields a nonincreasing p j , and • common slopes a j = a, b j = b (case P common ).
Our practical motivation for the described scheduling problem is to minimize costly walking time of workers at a moving automobile assembly line. This is attained by minimizing the makespan of each worker independently. A worker needs to complete a set of assembly operations (jobs) in any order at a his or her work piece, which is continuously transported by a conveyor belt. Each assembly operation consists of a constant assembly time and, before that, a timedependent walking time to gather material from a central supply point at the line-side (see also Fig. 2).
The resulting assembly operation times can be adequately modeled by the described time-dependent processing times (Sedding 2020b). By permuting the operations, it is possible to minimize the total walking time, or equivalently, the worker's makespan.

Summary of results and organization
The results presented in this paper can be summarized as follows: • Identification of three polynomial cases: first, if t min ≥ τ ; second, if a certain job sequence starts each job before or at τ ; third, if each basic processing time is zero.
• Proof that the studied problem is NP-hard already for the special case P common of common slopes. This is shown by reduction from Even-Odd Partition. See Table 2 for an overview. • Introduction of a fully polynomial time approximation scheme (FPTAS) for the case P agreeable of agreeable ratios of basic processing time and slopes. This approach can be also be used in the common slope case and known monotonic slope cases, see Table 3 for an overview. Notably, the underlying dynamic program is not pseudopolynomial, which is exceptional (Garey and Johnson 1979, p. 140). Because the objective value can be exponential in input length and input values, please note that the existence of an FPTAS neither implies the existence of a pseudopolynomial algorithm, nor rules out NPhardness in the strong sense.
This paper is structured as follows. In Sect. 3, relevant literature is reviewed and the practical motivation of the study is described. In Sect. 4, our notation for job sequences is given, and properties of the makespan calculation are presented. Polynomial cases are identified in Sect. 5. A symmetry property in optimal job sequences is described in Sect. 6. In Sect. 7, it is shown that P common is NP-hard. In Sect. 8, a dynamic program is introduced for P agreeable , which is used to construct an FPTAS in Sect. 9.

Literature review
The studied non-monotonic penalty function (3) covers monotonic special cases in the literature, because it allows all-zero a j (or b j ) slopes. A similar generalization occurred within the scheduling literature on constant processing times, which is summarized in the first subsection. We then continue with a review of relevant time-dependent literature. Finally, we describe the practical application that prompted the presented non-monotonic case.

Literature with constant processing times
From a historical point of view, a shift from (a) proportional to (b) monotonic piecewise-linear, then to (c) non-monotonic piecewise-linear measures similarly occurred before in the classic scheduling theory in terms of weighted completion costs, namely from the total weighted completion time criterion to the total weighted tardiness criterion with a common due date, then to the total weighted earliness and tardiness criterion with a restrictive common due date.
(a) j w j C j A basic scheduling problem is to minimize the monotonic total weighted completion time j w j C j with a given job-weight w j for each job j, achieved by sorting the jobs by nonincreasing ratio w j / p j (Smith 1956). (b) j w j T j A harder problem is to minimize the piecewise-linear monotonic total weighted tardiness j w j T j with job-tardiness T j = max{0, C j −d} for a given common due date d; it requires equal weights w j = w for a polynomial-time algorithm (Lawler and Moore 1969). Optimal job sequences can be divided into a set A of jobs completing before d, a straddler job starting before d and completing at or after d, and a set B of jobs starting at or after d. The order of jobs in A is arbitrary; set B is sorted according to Smith (1956). Therefore, an algorithm mainly needs to decide on a straddler job and partition the remaining jobs into sets A and B (Lawler and Moore 1969). For job-specific weights, the latter decision is NP-hard, as shown in Yuan (1992) by reduction from Partition. A pseudopolynomial-time dynamic programming algorithm is devised in Lawler and Moore (1969), a strongly polynomial FPTAS in Kacem (2010) for a given straddler job, see Kianfar and Moslehi (2013). (c) j w j (E j + T j ) A further complexity increase is caused by the piecewise-linear nonmonotonic total weighted earliness and tardiness criterion j w j (E j + T j ) with job-earliness E j = max{d − C j , 0} and a so-called restrictive common due date d < j p j . In optimal job sequences, the jobs are arranged in opposing orders around d: nondecreasingly by w j / p j before d and nonincreasingly by w j / p j after d. Again, it necessitates to decide on the straddler job and job set A and B. This problem is NP-hard already for common weights w j = w, which is shown by reduction from Even-Odd-Partition, and permits a pseudopolynomial-time dynamic programming algorithm (Hall et al. 1991;Hoogeveen and van de Velde 1991). Kellerer and Strusevich (2010) show that the problem admits a strongly polynomial FPTAS by adopting an FPTAS for Symmetric Quadratic Knapsack.
An overview of complexity results for these classic scheduling problems is given in Table 1.

Literature on time-dependent scheduling
Time-dependent scheduling with the objective of minimizing the makespan is a research stream that dates back to Shafransky (1978); Melnikov and Shafransky (1979). The latter study job-uniform monotonic penalty functions = j ; hence, is nondecreasing or nonincreasing. For this generic model, they show that an optimal job sequence is found in polynomial time by sorting the jobs with respect to j .
Turning to job-specific penalty functions j , an interesting special case arises for all-zero basic processing times j = 0, which means that p j = j . This case is consid-  (Yuan 1992) • Strongly polynomial FPTAS (Kacem 2010) j w j E j + T j • NP-hard (Hall et al. 1991;Hoogeveen and van de Velde 1991) • Strongly polynomial FPTAS (Kellerer and Strusevich 2010) ered in the following three studies. Mosheiov (1994) studies the proportionally increasing penalty function j (t) = b j t for b j ≥ 0 and a positive global start time t min > 0, and shows that any job sequence yields the same makespan and is optimal. Kawase et al. (2018) analyze monotonic piecewiselinear penalty functions equivalent to j (t) = min{0, (b j − 1) · t + c j } for b j ≥ 0, and show that an optimal job sequence is computed in polynomial time by sorting the jobs. Kononov (1998) considers non-monotonic penalty functions j (t) = b j ·h(t) with a common convex or concave function h where, for any t, t with t ≥ t ≥ t min and each job j, there holds h(t min ) > 0 and t Note that the second condition on b j and h is equivalent to restricting job j's completion time to be nondecreasing for any start time t ≥ t min . Kononov (1998) shows that the minimum makespan is attained by sequencing the jobs in nondecreasing order with respect to b j (or nonincreasing for concave h), see also Gawiejnowicz (2008,Theorem 6.43) for a description.
With nonnegative basic processing times j ≥ 0, finding a job sequence with a minimum makespan is computationally more involved. The categorization for the classic scheduling models in Sect. 3.1 can be translated to (a) proportional penalty functions j , (b) monotonic piecewise-linear j , and (c) non-monotonic piecewise-linear j . This categorization is elaborated below and visualized in Fig. 3. An overview of the complexity results is given in Table 2, a runtime comparison of the FPTASs in Table 3.
(a) Proportional j The proportional increasing penalty function j (t) = b j t with b j ≥ 0 is independently studied in Shafransky (1978), Wajs (1986), Gupta and Gupta (1988), Browne and Yechiali (1990), and Gawiejnowicz and Pankowska (1995). They show that an optimal sequence sorts the jobs nondecreasingly with respect to j /b j and so that all jobs with b j = 0 are last. Gawiejnowicz (2008), Theorem 6.24 summarizes multiple ways for proving this: by partial order relations (Gawiejnowicz and Pankowska 1995), by a job interchange argument (Wajs 1986;Gupta and Gupta 1988), and by its formalized concept, the so-called priority-generating function (Shafransky 1978); for the latter also see Tanaev et al. (1984Tanaev et al. ( , 1994, chapter 3, section 1.2).
The symmetric case with proportional decreasing penalty functions j (t) = −a j t with 0 ≤ a j < 1 is considered first in Ho et al. (1993). Here, the jobs need to be nonincreasingly ordered by j /a j while jobs with a j = 0 are last (Ho et al. 1993;Gordon et al. 2008). (b) Monotonic piecewise-linear j Adding a point in time until which the processing time is constant results in the piecewise-linear, job-specific, nondecreasing penalty function j (t) = max{0, b j (t −τ )} for a given common τ . Then, the decision version of the scheduling problem is NP-hard, as shown in Kononov (1997) by reduction from Subset Sum, and in Kubiak and van de Velde (1998) by reduction from Partition. Kubiak and van de Velde (1998) also present a pseudopolynomial-time algorithm. FPTASs are described in Cai et al. (1998), Kovalyov and Kubiak (1998). Woeginger (2000), Kovalyov and Kubiak (2012), and Halman (2019) build upon Kovalyov and Kubiak (1998). Our independently devised FPTAS also applies. Retrospectively, it is most similar to Cai et al. (1998). All approaches use techniques for trimming-thestate-space as Ibarra and Kim (1975) except for Halman (2019) with K -approximation sets. All rely on the problem's property of allowing for the same order of jobs before and after τ : nondecreasingly by j /b j . Moreover, Kovalyov and Kubiak (1998) require that a straddler job χ completes at an integer valued completion time C χ in order to repeat the calculation for a polynomial number of possible C χ . A symmetric problem exhibits similar properties and is introduced in Cheng et al. (2003) by the nonincreasing penalty function j (t) = max{−a j (t − τ ), 0} for 0 < a j < 1 and j > a j min{τ, k = j k }. Cheng et al. (2003) prove NP-hardness by reduction from Partition, and introduce a pseudopolynomial-time algorithm. Later, Ji and Cheng (2007) devise an FPTAS for it by utilizing methods from Kovalyov and Kubiak (1998) and by relying on the same order of the job sets before and after τ : nonincreasingly with respect to j /a j . Moreover, they utilize the problem's property that the value of a straddler job's completion time only linearly influences the makespan because the processing times of the jobs that start at or after τ are constant.
Time-dependent scheduling models for processing times p j = j + j (t) with an additive penalty function j are mostly restricted to monotonic piecewise-linear j in the literature, like (a) . These models are unified in this paper with (c) Table 2 Complexity results on single machine time-dependent scheduling with processing time p j (t) = j + j (t) for an additive penalty function (Melnikov and Shafransky 1979) a 0 • polynomial (Melnikov and Shafransky 1979) 0 b j • NP-hard (Kononov 1997;Kubiak and van de Velde 1998) • polynomial if τ ≤ 0 (Lemma 4; Shafransky 1978; Wajs 1986; Gupta and Gupta 1988;Browne and Yechiali 1990;Gawiejnowicz and Pankowska 1995;Tanaev et al. 1984Tanaev et al. , 1994 • FPTAS (Theorem 2; Cai et al. 1998;Kovalyov and Kubiak 1998;Woeginger 2000;Halman 2019) a j 0 • NP-hard (Cheng et al. 2003) • polynomial if a j /a j -sorted sequence where the smaller j is first for ties starts all jobs before or at τ (Lemma 5) • FPTAS (Corollary 10; Ji and Cheng 2007) Ho et al. 1993) • polynomial if ordering the jobs nondecreasingly by j starts each job before or at τ (Lemma 5) • FPTAS (Corollary 9) Ho et al. 1993) • polynomial if a j /a j -sorted sequence with smaller j first (in the case of ties) starts all jobs before or at τ (Lemma 5) • polynomial if j = 0 (Lemma 6) • FPTAS for agreeable ratios of j and the slopes (Theorem 2) • Marks results devised or confirmed in this work, • Marks results from the literature Table 3 Comparison of FPTASs' worst-case runtime for P agreeable with n jobs and error ε ∈ (0, 1] in different settings of slopes, where max denotes the maximum l j , and b max denotes the maximum b j a j b j FPTAS runtime in the agreeable ratios of basic processing time and slopes case P agreeable Kubiak (1998, 2012) For a common ground, let j and b j be natural numbers. For runtimes given in the literature, we rather state 1 + b max instead of just b max to avoid adverse effects of zero log b max if b max = 1. As it is common, log k x = (log x) k • Marks results devised in this work, • Marks results from the literature (c) Non-monotonic piecewise-linear j The described forms are extended by the non-monotonic piecewiselinear penalty function j (t) = max{−a j (t−τ ), b j (t− τ ))} in P, which has, to the best of our knowledge, not been studied up to now. The following studies lie closest. Farahani and Hosseini (2013) study the special case of such a penalty function with symmetric, common (allequal) slopes 0 < a < 1, a = a j = b j , while treating the global start time t min as a decision variable with the objective of minimizing the cycle time C max − t min . Then, an optimal schedule exhibits the following properties: one job χ starts exactly at τ , the set A of jobs that complete before and at τ are sorted nonincreasingly by j , and the set {χ }∪B of jobs starting at or after τ are sorted nondecreasingly by j . An exact polynomial time algorithm sets χ = argmin j j and assigns the other jobs iteratively to A and B. They describe a practical application of their problem setting related to scheduling a vehicle for delivery of commodities between two rush hours in an urban setting, assuming added travel time first decreases, then rises back up later on. A similar non-monotonic time-dependent effect is considered in Jaehn and Sedding (2016). However, the model measures a job's middle time, instead of its start time for determining the processing time of a job j. In particular, it is stated by p j = j +a·|m − M| with slope 0 < a < 2, ideal middle time M, and the job's middle time m, which is related to the job's start time t by m = t + p j /2, and specifies the point in time when exactly half of the job has been processed. Solving m for p j and t yields the processing time function This function is not expressible in terms of the j penalty function because (a) the start time-dependent processing time function has a job-specific minimum at M − j /2 instead of one common minimum at some common ideal start time τ , and (b) the basic processing time j is scaled by two different factors, depending on the start either before or at and after M − j /2. Although this model seems rather unconventional, its convincing advantage is that it allows to study a perfectly symmetric job prolongation before and after M. This symmetry around M allows for a polynomial reduc-tion from Even-Odd Partition and prove the NP-hardness of the considered problem. A much more generic problem is studied in Kawase et al. (2018) with the optimal composition ordering of convex or concave piecewise-linear functions. An interesting remark is that the minimization problem with functions C j (t) can be transformed to the maximization problem withC j (t) = −C j (−t), and vice-versa. One of the studied cases is the maximum composition ordering of the concaveC Their result on this case is a NP-hardness proof by reduction from Partition. From this, we infer that the convex minimization counterpart is also NP-hard. We observe that a special case is problem P with parameters a j = 1 − a j (unless a j = 1), Of course, as it is a special case, the hardness of P can, however, not be inferred from the more generic problem setting.
In addition, let us note that preliminary results of our paper are presented in Sedding (2017Sedding ( , 2020a on the FPTAS, in Sedding (2018a, b) on the NP-hardness, and on both of them in Sedding (2020c) for the common slopes case P common .
A comprehensive treatise on the variety of time-dependent scheduling models is provided in Gawiejnowicz (2008Gawiejnowicz ( , 2020a. A recent review is given in Gawiejnowicz (2020b). Further reviews are in Alidaee and Womer (1999)

Practical application in automobile production planning
The studied time-dependent scheduling problem P arises in production planning of moving assembly lines. A major German car manufacturer spends about 10-15% of working time at the moving final assembly line with fetching supplies from the line side (Scholl et al. 2013). This time expense incurs a high cost, and any reduction offers a high return. This walking time mainly occurs before the start of each assembly operation (job). There, the assembly worker needs to leave the continuously moving work piece, then walk along the assembly line to a nonmoving material supply point, and return to the same work piece (which continued to move during the worker's absence). See Figure 2 for a visualization of this scenario. A worker's walking time is minimized by essentially two approaches. One is to reposition the supplies (Klampfl et al. 2006;Sedding 2020b); another is to resequence the worker's assembly operations (Sedding and Jaehn 2014;Jaehn and Sedding 2016). We focus on the operation (re)sequencing approach, which avoids a physical reconfiguration of the assembly line; thus offers much faster reaction times on short term changes. The worker's operations are usually independent from each other. Hence, we can assume that any job sequence is feasible. The high number of possible job sequences raises the need for an algorithmic decision support (Sedding 2020c).
A special case is portrayed in Jaehn and Sedding (2016), where walking time occurs in the middle of an operation, which then exhibits a perfect symmetric processing time function (4). We need to deviate from this symmetry to consider a walking time that occurs at the start of each operation as in Klampfl et al. (2006) and Sedding (2020b).
We model the time-dependent walking time like in Sedding (2020b). Then, the walking time is proportional to the distance between the static supply point and the moving work piece. Hence, the walking time depends on the time that the worker starts to walk: the walking time is minimum when the working point just passes by the supply point. This is the ideal walking start time, which corresponds to τ in j . Earlier or later, the walking time increases linearly.
Sedding (2020b) elaborates how conveyor and worker velocities are translated to asymmetric slopes 0 < a < 1 and b > 0. The slopes' domains originate from an assembly line velocity that is generally lower than the worker velocity. Their asymmetry arises from the continuous conveyor movement, which is divided in two cases. While it moves the work piece towards the supply point, the walking time shortens. While it moves the work piece away, the walking time increases.
Sometimes, properties of the carried material such as its weight can influence the walking velocity for some operations (Klampfl et al. 2006). In this case, job-specific slopes can be set, which typically yields a P agreeable instance.

Preliminaries
In this section, our notation is introduced, and the makespan calculation is expressed in closed formulae.

Notation of sequences
We specify our notation of (job) sequences, and denote two sequence sort criteria.
The start time t and completion time C of a sequence corresponds to the start time of the first job and the completion time of the last job in the sequence. Then, the makespan of a sequence is C − t.
We say a sequence S of a set of jobs J is holds for any two jobs j, k ∈ J at positions S −1 ( j) < S −1 (k), respectively.

Remark 1
For the set of all jobs in a P agreeable instance, there exists a j /a j -sorted sequence such that its reversed sequence is j /b j -sorted.

Makespan calculation
For a sequence S of a (sub)set J of n jobs of a P instance, the completion time is given in a recursive form by for the sequence's start time t. This recursive equation can be difficult to handle. However, it is possible to transform the calculation to a closed form, as we show in this subsection. Then, we state the derivatives of the sequence's completion time with respect to its start time if the sequence either starts at or after the ideal start time τ , or completes before or at τ . First, we substitute p j and f j in C j (see (2), (1), (3)) to Then, we define the functions For common a j = a or b j = b, respectively, they collapse to with n jobs in sequence S.
We use the functions α S and β S to calculate the completion time of a given sequence S with a closed formula, where we distinguish three cases.

Lemma 1 If a sequence S with n jobs starts at t < τ and there is α S (t) ≤ τ + S(n) , then it completes at α S (t).
Proof Let C be the completion time of S and its last job S(n). We renumber the jobs such that S = (1, . . . , n). Then, let us show α S (t 1 ) = C by induction: We begin with n = 1, starting job 1 at t 1 = t ≤ τ . By (5), job 1 completes at

Lemma 2 If a sequence S starts at t ≥ τ , then it completes at β S (t).
Proof Shown similar to Lemma 1 by induction from t 1 = t ≥ τ to β S (t 1 ).

Corollary 1 If a sequence S with n jobs starts at t < τ and there is α S (t) > τ + S(n) , then it completes at
The effect of changing a sequence's start time t can be observed by considering the derivatives of α S and β S .
Corollary 2 Let a sequence S of a set of jobs J start at t.
Thus, increasing a sequence's start time t does not decrease the sequence's completion time C. In other words, C does not increase if t is decreased.

Corollary 3 Inserting idle time in front of any job does not decrease a sequence's makespan, for any fixed start time.
Hence, it is not necessary to consider idle times in P.

Polynomial cases of P
In this section, we analyze properties of job (sub)sets of P instances, which lead to three polynomial cases of P: if the ideal start time τ is early (τ ≤ t min ), if the ideal start time is late (τ ≥ α S (t min )− S(n) given a j /a j -sorted sequence S with all n jobs), or if all basic processing times are zero.

Early ideal start time
If the start time t of a sequence is not less than the ideal start time τ (as in Lemma 2) and τ = 0, then all jobs start at or after τ . This corresponds to the known monotonic scheduling problem with proportional penalty functions j (t) = b j t. Here, j /b j -sorted sequences yield the minimum makespan, which is observed in Shafransky (1978), Tanaev et al. (1984Tanaev et al. ( , 1994, chapter 3, section 1.2), Wajs (1986), Gupta and Gupta (1988), Browne and Yechiali (1990), and Gawiejnowicz and Pankowska (1995). Please note that the special case with all-zero basic processing times is solved for any sequence S of a set of jobs J : its completion time β S (t) = t · j∈J (1 + b j ) is independent of the order of jobs, which corresponds to the problem in Mosheiov (1994).
An instance with ideal start time τ = 0 can be transformed to an instance with a zero ideal start time by performing a time-shift of −τ . Then, the result for τ = 0 applies as well.

Proposition 1 A sequence S that is started at or after τ provides the minimum makespan if and only if S is
Corollary 4 A P instance of n jobs with t min ≥ τ is solved in O(n log n) time by any j /b j -sorted sequence.

Late ideal start time
Similarly, if t ≤ τ = 0, then a sequence might start each job before or at τ (like in Lemma 1). Such a case corresponds to the penalty function j (t) = −a j t, in which a j /a jsorted sequence provides a minimum makespan (Ho et al. 1993). It follows that in P, if a j /a j -sorted sequence starts each job (or equivalently, the last job) before or at τ , then it provides the minimum makespan.
In the special case of all-zero basic processing times and t ≤ τ = 0, any sequence S of a set of jobs J attains the same completion time α S (t) = t · j∈J (1 − a j ) ≤ 0.
Again, it is possible to convert an instance with τ = 0 by a time-shift of −τ to an instance with a zero ideal start time.

Proposition 2 If a sequence S starts its last job before or at τ , then S provides the minimum makespan if and only if S is j /a j -sorted.
Proposition 2 is only applicable to sequences that start each job at or before τ . But this may apply only for some of several existing j /a j -sorted sequences. However, one can strengthen the sorting criterion such that for any two jobs j, k in sequence S at positions S −1 ( j) < S −1 (k), there is j a k > k a j ∨ j a k = k a j ∧ j ≤ k .
If there are multiple possible last jobs, this criterion assigns the one with the longest basic processing time to the last position. This minimizes the start time at the last position without changing the sequence's completion time.

Corollary 5 For a P instance of n jobs with t min ≤ τ , a sequence S respecting (10) is constructed in O(n log n) time.
If α S (t min ) ≤ τ + S(n) , then S is optimal.

Zero basic processing times
The combination of the aforementioned special cases of allzero basic processing times j = 0 is valid for any ideal start time τ and any start time t min . This generalizes the result on instances with t min > τ = 0 in Mosheiov (1994).

Lemma 3 If j = 0 for each job j in a set J, then any sequence of J provides the minimum makespan for any start time t, and completes at
Corollary 6 A P instance with j = 0 for each job j is solved by an arbitrary sequence; it is returned in O(n) time.

Symmetry in optimal sequences for P
Even if none of the described polynomial cases of P applies, they allow to observe a central property of optimal sequences: the symmetric sorting of the jobs before and after τ .

Proposition 3 If a P sequence provides the minimum make span, then
(a) all jobs that complete before or at τ are j /a j -sorted, (b) all jobs that start at or after τ are j /b j -sorted.
Proof Given a sequence S, split S into S 1 S 0 S 2 such that S 1 completes before or at τ , and S 2 starts at or after τ . Assume S 1 is not j /a j -sorted. Then, the completion time of S 1 is not minimal: it decreases by re-ordering S 1 as a j /a j -sorted sequence. Then, all jobs still complete (and start) before or at τ , and by Corollary 2, the ensuing sequence S 0 S 2 starts earlier. Hence, S does not provide a minimum makespan if S 1 is not j /a j -sorted (Proposition 2). An analogous observation holds for S 2 : it has to be j /b j -sorted (Proposition 1).
Remark 2 (Implications for P agreeable ) According to Remark 1, a P agreeable instance permits a job sequence that is j /a j -sorted and, in reversed order, j /b j -sorted. Let (1, . . . , n) denote such a sequence by renumbering the given jobs accordingly. Now, consider an optimum sequence S and two jobs j, k with 1 ≤ j < k ≤ n. If both jobs complete before or at τ , then their positions are S −1 ( j) < S −1 (k). If both start at or after τ , then S −1 ( j) > S −1 (k).
Remark 3 (On the choice of the straddler job) Please note that Proposition 3 excludes a statement about a potential straddler job. Indeed in optimal solutions, the straddler job (if it exists) is neither necessarily the job with the shortest basic processing time j , nor with highest a j and b j value; see Figure 1 for an example of this. In the polynomial cases above however, the straddler job (if it exists) can be chosen according to the respective sorting criterion.
Remark 4 (On the existence of the straddler job) A straddler job exists in all optimal sequences if and only if t min ≤ τ and a sequence sorted according to (10) that is started at t min yields C max ≥ τ . If a straddler job exists in an optimal sequence, then it also exists in any other sequence of the same job set starting at t for t min ≤ t ≤ τ because its completion time is not less than the minimum completion time.

Computational complexity of P, P agreeable , P common
In this section, a reduction from the NP-complete Even-Odd Partition problem shows that already the common slopes case P common is NP-hard. Thus, the more general problems P, P agreeable are also NP-hard. Let us outline the proof, but beforehand, state the NP-complete Even-Odd Partition problem.
Definition 1 (Even-Odd Partition (Garey et al. 1988)) Given a set of n = 2h natural numbers X = {x 1 , . . . , x n } where x j−1 < x j for j = 2, . . . , n, does there exist a partition of X into subsets X 1 and X 2 such that x∈X 1 x = x∈X 2 x and such that for each i = 1, . . . , h, set X 1 (and hence X 2 ) contains exactly one of {x 2i−1 , x 2i }?
NP-hardness of P common is shown by proving the NPhardness of its decision version, which asks, for a given rational-valued threshold Φ, if there exists a sequence S of the given jobs that is started at t min and yields makespan φ ≤ Φ.
The major steps of the proof are outlined as follows. The first trick is to choose slopes a and b such that assignment 'costs' are the same for the same ordinal position away from the ideal start time. Hence, a job's impact on the makespan no longer depends on its deviation from the ideal start time. Furthermore, the impact is the same on either side of τ within each Even-Odd pair. Then, the assignment decision of jobs to a side represents the partitioning problem. The second major step is to use a polynomial number of filler jobs that take up the time between the early jobs (if they complete too early) and τ , such that a No-instance is correctly recognized.
Theorem 1 P common is NP-hard.
Proof Given an arbitrary instance of Even-Odd Partition, let us first define a corresponding instance of the decision version of P common . Then, we show it has a solution if and only if there exists a solution for the Even-Odd Partition instance.
Assume that a given corresponding instance possesses a sequence S with makespan φ ≤ Φ. Then, S either already has a certain format, or it can be aligned to this format in polynomial time without increasing the makespan as follows.
First, we assume that job 2n + 1 is the last job in S. Else, let t 2n+1 denote this job's start time. If t 2n+1 ≥ 0, by sorting the jobs in S starting after 0 according to Proposition 1 in polynomial time, job 2n + 1 can take the last position without increasing the sequence's completion time. Otherwise if job 2n+1 starts at t 2n+1 < 0, then it completes after 0 because 2n+1 > τ. In this case, repeatedly swap it with its successor job j and sort all other jobs starting before 0 according to Proposition 2. This does not increase the sequence's completion time either, because j < 2n+1 and, with (5), Second, the jobs that complete before or at 0 can be ordered according to Proposition 2, while the jobs with zero basic processing time j = 0 are the last that complete before or at 0, in any order (Lemma 3). Analogously, let the jobs starting at or after 0 adhere to Proposition 1, while the jobs with j = 0 are the first, in any order (again according to Lemma 3). Then, Proposition 3 holds. Now, sequence S can be narrowed down to attain either of the following two forms: (i) Either, the sequence can be split into S = S 1 S 0 S 2 such that partial sequence S 1 contains the jobs completing before or at 0, while S 0 contains all the jobs that start and complete at 0, and S 2 contains the jobs starting at or after 0.
(ii) Otherwise, it can be split into S = S 1 S 01 S χ S 02 S 2 such that S 01 and S 02 together contain all the jobs with j = 0, while sequence S χ = (χ ) consists of the straddler job χ that starts strictly before 0 and completes strictly after 0, partial sequence S 1 contains the jobs completing before or at 0, and S 2 the remaining jobs.
While form (i) is the desired form, let us rule out form (ii). Consider sequences S 01 and S 02 . They contain all n jobs with zero basic processing time j = 0. Let v denote the number of jobs in S 02 . Then, S 01 contains n−v jobs. Sequence S 01 starts at some time t < 0. According to (8), it completes at t/2 n−v , which equals t χ , the start time of the straddler job. Then, the straddler job χ completes at C χ = t χ /2 + χ . Sequence S 02 starts at C χ , hence it completes according to (9) at C = C χ ·2 v . Together, the completion time of S 01 S χ S 02 starting at t is Its first and second derivatives are The completion time C has an extremum at a v with d dv C = 0. As t < 0, the second derivative at the same v is d 2 dv 2 C < 0. Therefore, this v value maximizes C. It follows that C is minimized either for v = 0 or for v = n with 0 ≤ v ≤ n. Therefore, the jobs with zero basic processing time can be moved altogether to either S 01 or S 02 without increasing C.
Assume that the zero basic processing time jobs {n + 1, . . . , 2n} all start at or after 0. Hence, they are either in sequence S 0 for case (i), or they are in sequence S 02 while S 01 is empty for case (ii) in the following elaboration; the opposite case where they are in S 01 while S 02 is empty is performed analogously. With this assumption, iff S adheres to form (i), sequence S 1 completes at time 0, denoted byĈ. Otherwise for form (ii), the straddler job χ completes at a time strictly after 0, denoted byĈ as well. Thus,Ĉ ≥ 0 in sequence S. Lett specify the start time of S 2 . Hence, sequence S 0 in case (i), or S 02 in case (ii), starts atĈ and completes att =Ĉ·2 n .
Define h 1 as the number of jobs in S 1 , and define h 2 = n − h 1 . GivenĈ ≥ 0, and the inverse of α S in (8), which is Sequence S 2 starts att =Ĉ·2 n . It consists of h 2 + 1 jobs. With the closed form (9), it completes at C max = β S 2 (t). Then, Because h 1 ≤ n and h 2 ≥ 0, we have d > 0. Then, Sequence S satisfies the inequality since its makespan φ = C max − t min ≤ Φ. Let us show that the minimum ofḡ is 2q, which means thatĈ = 0 in the inequality.
For any i, j ∈ {1, 2} such that i = j, if g i (k) = 0 for some k while g j (k + 1) > 0, then sequence S does not provide a minimum forḡ: it decreases by resequencing the jobs such that g i (k) > 0 and g j (k + 1) = 0 because 2 k < 2 k+1 .
Therefore, a solution to the Even-Odd Partition instance allows us to solve the corresponding P common decision instance and vice versa. As the reduction is polynomial, it follows that P common is NP-hard.
Problem P common is a special case of P agreeable , which in turn is a special case of P.
Corollary 7 P and P agreeable are both NP-hard.
The latter hardness result can also be inferred from the monotonic special cases in P agreeable (where either a j = 0 or b j = 0, and the nonzero slopes are job-specific), which are NP-hard following the results in Kononov (1997), van de Velde (1998), andCheng et al. (2003).

Dynamic programming algorithm for P agreeable
In this section, we describe a dynamic programming algorithm for P agreeable , and analyze its runtime. This algorithm is employed later (in Sect. 9) for constructing a fully polynomial time approximation scheme. We explicitly exclude instances that already correspond to a polynomial case in Corollary 4 or Corollary 5 in the following consideration. Hence, we can assume that the straddler job exists (see Remark 4).
Denote by J the set of all given jobs. Let n = |J |−1 where |J | is the number of jobs in J . Then, the following algorithm runs repeatedly, once for each possible straddler job χ ∈ J . In each run, renumber the jobs to {1, . . . , n, n + 1} such that χ = n + 1 and such that j a k ≥ k a j and j b k ≥ k b j for 1 ≤ j < k ≤ n. Such a numbering exists (Remark 1), and implies that sequence (1, . . . , n) is j /a j -sorted, and (n, . . . , 1) is j /b j -sorted. Please remember the according symmetry around τ in an optimal sequence (Remark 2).
The dynamic programming algorithm solving P agreeable for a straddler job χ = n + 1 consists of n stages. Stage j = 1, . . . , n is represented by a set V j of partial solutions. A partial solution can be imagined as a pair (S 1 , S 2 ) of two partial sequences that respect the following invariant: S 1 and S 2 represent a partition of jobs {1, . . . , j} into sets A, B while -sequence S 1 of job set A is j /a j -sorted, to start at t min and guaranteed to complete before τ , and -sequence S 2 of job set B is j /b j -sorted, to start at τ .
In the j'th stage, job j is inserted into all partial solutions V j−1 of the preceding stage j − 1. We consider two possible ways of inserting job j to the sequences, which respects the above invariant. First, inserting j as the last job in sequence S 1 unless this yields a completion time after τ . This has no effect on the start times of the other jobs in S 1 . Second, inserting job j as the first job in S 2 . Then, job j starts exactly at τ , which postpones all other jobs in S 2 by job j's processing time p j (τ ) = j .
The dynamic program does, to save memory, not explicitly store the partial sequences S 1 and S 2 . Instead, a partial solution is represented by a three-dimensional vector [x, y, z] of nonnegative rational numbers, described as follows: -The first component, x, denotes sequence S 1 's completion time, hence, x = α S 1 (t min ), see Lemma 1. -The y component describes the proportional increase of sequence S 2 's makespan if increasing its start time t≥ τ , hence, y = d dt β S 2 (t) = d dt β S 2 (τ ), see Corollary 2(b). -Lastly, z represents sequence S 2 's makespan if starting it at τ , hence, z = β S 2 (τ ) − τ , see Lemma 2. Fig. 4 The dynamic programming algorithm for P agreeable with a certain straddler job χ stores a vector [x, y, z] to represent a state, where x denotes the completion time of sequence S 1 starting at t min , z denotes the makespan of sequence S 2 starting at τ , and y denotes the derivative value of z on changing the start time of S 2 . In each iteration j = 1, . . . , n, at most two new vectors are generated from each state [x, y, z]: (a) vector [C j (x), y, z] that appends job j to x as long as C j (x)<τ , and (b) a vector [x, (1 + b j ) y, z + y j ] that prepends job j to S 2 and modifies y accordingly. After the last iteration, the straddler job χ is appended to S 1 , after which S 2 is then started, increasing its makespan accordingly After stage n, the straddler job χ is appended to sequence S 1 , after which S 2 continues. Figure 4 displays the partial solution of such an intermediate state, and shows the two successor states that emerge from adding the next job to either sequence S 1 or sequence S 2 .
Algorithm 1 (Dynamic Programming for P agreeable with straddler job χ ) Initialize state set For job j = 1, . . . , n, generate state set The resulting sequence S = S 1 S 2 is reconstructed in O(n) time by recording for stage j = 1, . . . , n and each state in V j from which state in V j−1 it originates. With this information, one can determine a backwards path from the final state in V n to the initial state in V 0 . Then, the sequence is built by following the path from j = 1 to n. Begin with empty partial sequences S 1 and S 2 . If the path's state in V k was generated in (13b), append job k to S 1 . If instead, it was generated in (13c), then prepend job k to S 2 . In (13d), χ is appended to S 1 , and S 2 is started at max{C χ (x), τ }. If the state was invalid in the sense that job χ completes at C χ (x) < τ, this inserts idle time before S 2 such that it starts at τ ; then the result is dominated by a solution from running the algorithm for another straddler job.
Proposition 4 For a P agreeable instance, repeatedly running Algorithm 1 for each possible straddler job χ ∈ J returns the minimum makespan φ * .
Proof Given an instance of P agreeable , the algorithm is run as follows for each possible χ .
Consider stage j = 1, . . . , n. In V j , there is at least one vector for each possible subset of jobs A ⊆ {1, . . . , j} where each job k ∈ A completes before τ , and B = {1, . . . , j} \ A. Each vector [x, y, z] ∈ V j stems from a source vector [x , y , z ]. Two cases are distinguished: -If the vector is generated in (13b), job j is in set A. The value x describes the start time of job j, completing at x. If x = t min , job j is the first job in set A and it starts at the global start time t min . As j−1 a j ≥ j a j−1 , the makespan x of the jobs in set A is minimum, see Proposition 2. The condition C j (x )<τ ensures that j does not turn into the straddler job. As the set B is unchanged, y = y and z = z remain the same. -Else, if the vector is generated in (13c), job j is instead in set B. For this, j is (for now) started at τ . Then, j completes at C j (τ ). If z = 0, job j is the first job in set B. Then, z = C j (τ ) − τ = j . If z > 0, job j is prepended to the jobs B = B \ { j}. Then, they start later, by C j (τ ) − τ = j . As of Corollary 2(b), their completion time increases by y· j∈B 1 + b j . Each job that is inserted in set B multiplies the previous y by 1 + b j . Therefore, y = j∈B 1 + b j . Then, z expresses the sum of processing times of all jobs in set B when started at τ . Moreover, the jobs are sequenced as S B = ( j, . . . , min B). Thus, z = β S B (τ ) − τ . As j ≤ j−1 , this makespan is minimum for the jobs in set B if started at or after τ .
In the last step, the straddler job χ is appended to the early jobs in each source vector [x , y , z ].
For this, χ starts at time x , and completes at x = C χ (x ). To return a correct C χ max , two cases are treated in (13d): Case x ≥ τ : Then, the jobs in set B start at x. In (13d), their completion time τ + z is correctly increased by (x − τ ) · y , according to Corollary 2(b), with time difference x − τ and slope y = j∈B 1 + b j . Therefore, the return value correctly calculates C χ max corresponding to [x , y , z ]. Case x < τ: In this case, idle time is inserted from x to τ .
Then, the first job in set B, k = max B, is scheduled at the common ideal start time: t k = τ . The resulting C χ max in (13d) is dominated by C k max for k as the straddler job.
It is assumed that an optimal sequence has a straddler job, else the instance corresponds to a polynomial case in Sect. 5 for which the algorithm stops upfront. Therefore, the repeated execution of the algorithm to obtain C χ max for each χ ∈ J yields φ * = min χ ∈J C χ max .
The total number of states in Algorithm 1 is O(2 n ), which corresponds to the number of branchings.
Corollary 8 A P agreeable instance with n jobs is solved by a n times repeated call of Algorithm 1 in O(n · 2 n ) time total.
The runtime still is non-polynomial (i.e., not pseudopolynomial) if measured in terms of input length and values, or similarly, in terms of unary encoded input length.

Proposition 5 Algorithm 1 is not pseudopolynomial.
Proof The fundamental theorem of arithmetic states that any natural number greater than 1 can be expressed by a unique product of a nonempty multiset of prime numbers up to the order of the factors (Hardy and Wright 2008, chapter 1). Conversely, the product of any nonempty multiset of prime numbers is unique. Thus, all the 2 n distinct subsets of the set of the first n primes yield 2 n distinct products.
Let P i for i ≥ 1 denote the i'th prime number. Create a P agreeable instance with τ = 0, some straddler job, and an arbitrary number of jobs {1, . . . ,n} where j = 1, a j = 0, and b j = P j −1 for j = 1, . . . , n. Then, Algorithm 1 creates vectors where the y component corresponds to a product of a subset of the first n prime numbers. Hence, at least 2 n distinct values (and states) are created.
The sum of the first n primes is polynomial in n (see, e.g., Axler 2019). Respectively, a unary encoded input of the stated instance has a length that is polynomial in n, but Algorithm 1 remains exponential in unary encoded input length. Thus, Algorithm 1 is not pseudopolynomial.
Since Algorithm 1 is not pseudopolynomial, it does not settle the question whether P agreeable is NP-hard in the strong sense.
It is interesting to observe that despite this result, Algorithm 1 is suited for constructing an FPTAS, as it is shown below. This is unusual and counter-intuitive because commonly, an FPTAS is derived from a pseudopolynomial exact algorithm (Garey and Johnson 1979, p. 140 An FPTAS is an algorithm that, given a problem's input and any approximation factor ε ∈ (0, 1], runs in polynomial time of input length and 1/ε to return a solution with objective value φ ε ≤ (1 + ε) · φ * , where φ * denotes the minimum objective value.
The following FPTAS for P agreeable is based on Algorithm 1. It is based on the idea of trimming-the-state-space as described in Ibarra and Kim (1975), combined with the interval partition technique described in Woeginger (2000). The latter technique defines For an approximation factor ε ∈ (0, 1] and corresponding Δ and h, let us define, similar to Algorithm 1, with the same preconditions and a given straddler job χ : Algorithm 2 (FPTAS for P agreeable with straddler job χ and ε) Initialize For job j = 1, . . . , n, generate state set and trimmed state set The algorithm's approximation guarantee and its worstcase runtime is shown in the remainder of this section.
For j = 1, . . . , n, there are two cases, corresponding to (14b) and (14c): -The first case applies if x < τ, i.e., the job j is appended to S 1 such that it completes before τ . Consider vector [x , y , z ] ∈ V j−1 where C j (x ) = x, y = y, z = z as generated in (14b). Then, by induction, the corresponding vector [x # , y # , . Although, after the trimming operation in (14d) this vector may not be in Let us show the induction hypothesis for this vector. Remember that C j (t) is an nondecreasing function. Thus, -In the second case corresponding to (14c), consider vector [x , y , z ] ∈ V j−1 where x = x, 1 + b j y = y, and z + y j = y. By induction hypothesis, the corresponding vector [x # , y # , z # ] ∈ V # j−1 with x # ≤ x , y # = y · Δ j−1 , and z # ≤ z · Δ j−1 exists. Then, the algorithm created a corresponding vector [x ,ỹ ,z ] = [x # , 1 + b j y # , z # + y # j ] ∈Ṽ # j in (14c). Even though, by trimming, this vector may not be in set V # j , there must exist some vec- Let us show the induction hypothesis. For (15a): Lemma 5 For 0 < ε ≤ 1 and a P agreeable instance with straddler job χ and minimum makespan φ * , Algorithm 2 yields C χε max such that Proof Let χ be the straddler job and [x, y, z] ∈ V n be the vector that corresponds to φ * = C χ max − t min in Algorithm 1.
For a worst-case runtime analysis, let us bound the number of states in each stage to a polynomial number. This uses the respective logarithm of ratio = max j k = 1, . . . , n min j > 0 j = 1, . . . , n , b max = max b j j = 1, . . . , n .
Proof Starting with |V # 0 | = 1, let us analyze state set V # j for j = 1, . . . , n in the following. Consider a vector [x, y, z] ∈ V # j . For each y and z value, there is one x value. Thus, |V # j | is bounded by the product of the number of possible y and z values, which is bounded in the following. Let The z value represents the makespan of the sequence that starts at the ideal start time. For z > 0, it is bounded by min ≤ z ≤ j =1,..., j j k= j +1,..., j (1 + b k ) The trimming step in (14d) ensures that there is at most a single y and z value for the same h(y) and h(z) value, respectively. Moreover, the rounded values are bounded by 1 ≤ h(y) ≤ h(Y j ) and by h( It follows from the definition of h that the number of distinct h(y) values is at most which uses the inequality ln Δ ≥ (Δ − 1)/Δ (Woeginger 2000, Proposition 3.1). Similarly, the number of distinct h(z) values for z > 0 is at most In summary, there are at most O n 2 log (1 + b max )/ε distinct y values, and there are at most O(n · (log ratio +log (1/b max )+n log (1 + b max ))/ε) distinct z values. Both upper bounds are polynomial in input length in a binary encoding. This includes rational numbers because they can be encoded as a division of two integers. The product of both bounds yields O(n 3 ·log (1 + b max )·(log ratio +log(1/b max ) + n log(1 + b max ))/ε 2 ), which is not more than the upper bound stated above.
Algorithm 2 is repeatedly started for each possible straddler job, hence n + 1 times, and has at most n stages, each with a polynomial number of states (Lemma 6). Furthermore, as of Lemma 5, the resulting makespan is guaranteed to be at most (1 + ε) times the minimum makespan φ * . This leads to the conclusion.
This runtime is polynomial, hence Algorithm 2 is an FPTAS for P agreeable . With a common slope b j = b, the y component of a state can attain at most j different values in each stage j∈ {1, . . . , n}. Then, there are only O(n 2 ·(log ratio + log(1/b)+n log (1 + b))/ε) states in each of the O n 2 stages.
Corollary 9 For instances with a common slope b j = b for each given job j, the runtime given in Theorem 2 is reduced to O(n 4 · (log max{ max , 1/b} + n log (1 + b))/ε).
In the monotonic case b j = 0, the y component equals 1 at all times, and z is bounded by the sum of basic processing times. Then, the number of distinct z values is bounded by O( ratio · n), and there are only O(n · log( ratio n)/ε) states per stage.
Corollary 10 For instances with b j = 0 for each given job j, the runtime in Theorem 2 is reduced to O n 3 · log( ratio n)/ε .
If each job j has the same j = , then ratio = 1. If in addition max{b j , 1/b j } is smaller than a constant, then the FPTAS finishes in strongly polynomial O n 5 /ε 2 time. For b j = 0, it takes only O n 3 log n/ε time, although this particular case is even easier to solve optimally by sorting the jobs with respect to nondecreasing a j values (Cheng et al. 2003).
Remark 5 (Implications on P agreeable 's computational complexity) Garey and Johnson (1978, Theorem 1) state that if, for all instances, the optimal objective value of a minimization problem is upper bounded by a polynomial in input length and input values, then the existence of an FPTAS implies that a pseudopolynomial algorithm exists. In P agreeable , the makespan can be exponential in input length and input values: e.g., for t min = τ , b j = b, and j ≥ 1 for j = 1, . . . , n, the makespan is not less than (1 + b) n−1 . Therefore, the existence of an FPTAS for P agreeable does, in this particular case, not imply the existence of a pseudopolynomial algorithm. Hence, it remains open whether a pseudopolynomial algorithm exists for P agreeable , and whether P agreeable is NP-hard in the strong sense.