Scheduling meets n-fold Integer ProgrammingThis research was partially supported by the project 14-10003S of GA ČR and project 1784214 GA UK.

# Scheduling meets n-fold Integer Programming††thanks: This research was partially supported by the project 14-10003S of GA ČR and project 1784214 GA UK.

Dušan Knop Department of Applied Mathematics (KAM),
Charles University in Prague, Czech Republic.
11email: {knop, koutecky}@kam.mff.cuni.cz
Martin Koutecký Department of Applied Mathematics (KAM),
Charles University in Prague, Czech Republic.
11email: {knop, koutecky}@kam.mff.cuni.cz
###### Abstract

Scheduling problems are fundamental in combinatorial optimization. Much work has been done on approximation algorithms for NP-hard cases, but relatively little is known about exact solutions when some part of the input is a fixed parameter. In 2014, Mnich and Wiese initiated a systematic study in this direction.

In this paper we continue this study and show that several additional cases of fundamental scheduling problems are fixed parameter tractable for some natural parameters. Our main tool is -fold integer programming, a recent variable dimension technique which we believe to be highly relevant for the parameterized complexity community. This paper serves to showcase and highlight this technique.

Specifically, we show the following four scheduling problems to be fixed-parameter tractable, where is the maximum processing time of a job and is the maximum weight of a job:

• Makespan minimization on uniformly related machines () parameterized by ,

• Makespan minimization on unrelated machines () parameterized by and the number of kinds of machines (defined later),

• Sum of weighted completion times minimization on unrelated machines () parameterized by and the number of kinds of machines,

• The same problem, , parameterized by the number of distinct job times and the number of machines.

## 1 Introduction

Scheduling problems are one of the fundamental classes of problems in combinatorial optimization since 1960s [1, 24, 30] and many variants of scheduling turn out to be NP-hard. In response to this one can either look for an approximate solution, or restrict the input in a certain way. Approximation algorithms for scheduling have been an established area of research for a long time now [24]. On the other hand, parameterizing the input in order to obtain exact results has not been studied much before. We say that a problem with input of size is fixed-parameter tractable (FPT) with respect to parameter if there exists a computable function which does not depend on and an algorithm solving with running time ; we call an algorithm with this running time FPT algorithm. Regarding scheduling, Mnich and Wiese [27] have recently initiated a systematic study of the relationship of various scheduling problems and their parameterizations, proving both positive and negative results. In this paper we continue in this direction, examining three additional fundamental scheduling problems and their parameterizations, and devising FPT algorithms for them.

However, our goal is not merely to prove new positive results. In their work, Mnich and Wiese rely on mathematical programming techniques in fixed dimension, which have been introduced in 1983 by Lenstra [25] and significantly extended in 2000 by Khachiyan and Porkolab [22]. These techniques are by now well established in the FPT community, even though the power of the latter extension of Khachiyan and Porkolab has not been fully utilized yet, as we will discuss further on. Independently of this, a new theory of variable dimension optimization has been developed in the past 15 years; see Onn’s book [28]. A breakthrough result is an FPT algorithm for the so-called -fold integer programming (-fold IP) by Hemmecke, Onn and Romanchuk [16]. In contrast to the fixed dimension techniques, -fold IP is not yet established as an indispensable part of an FPT researchers toolbox. In this paper we would like to help change that.

Let us now introduce -fold IP. Given -dimensional integer vectors , -fold integer programming (-fold IP) is the following problem in variable dimension :

 min{\boldmathw\boldmathx:A(n)% \boldmathx=\boldmathb, \boldmathl≤\boldmathx≤\boldmathu, \boldmathx∈Znt} , (1)

where

 A(n):=⎛⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜⎝A1A1⋯A1A20⋯00A2⋯0⋮⋮⋱⋮00⋯A2⎞⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟⎠

is an matrix with an matrix and an matrix. Let be the biggest absolute value of a number in . The vector is naturally partitioned into bricks of size , that is, we index it as . As such, -fold IP is best suited for multi-index problems whose IP formulation has variables indexed by for some integers such that are fixed parameters and only is variable.

Hemmecke, Onn and Romanchuk [16] prove that there is an FPT algorithm solving problem (1) with parameters and . We will state and extend their result together with further observations in Section 2.1

### 1.1 Our contribution

We consider three non-preemptive scheduling models of increasing generality: parallel identical, uniformly related and unrelated machines (in the standard notation [24] denoted by and , respectively), and the two most common objective functions: minimizing makespan and sum of weighted completion times (denoted and , respectively).

For identical machines, the problem consists of a set of jobs and machines , and each job has a processing time . For uniformly related machines, we additionally have for each machine its speed , such that processing job on machine takes time . For unrelated machines, we have for each job an -dimensional vector , for all , such that processing job on machine takes time (in case , cannot be executed on ). We also consider a restricted variant of the unrelated machines model where there are kinds of machines and the vector of processing times for a job is given with respect to kinds of machines: , such that processing on machine of kind takes time . Additionally, for the sum of weighted completion times objective, we are given for each job its weight .

A schedule is an assignment of jobs to machines and times, such that every machine is executing at most one job at any time. For a job we denote by its completion time, that is, the time finishes. In makespan minimization, the goal is to minimize . When minimizing the sum of weighted completion times, the goal is to minimize . For example, the problem of minimizing makespan in the identical machines model is denoted .

The parameters we consider are the following:

• : the maximum processing time of any job,

• : the maximum weight of any job,

• : the number of machines,

• : the number of distinct job processing times and weights (in case of the objective); note that generalizes parameter ,

• : the number of kinds of machines (defined above).

In all of the cases we consider, we use such a combination of parameters that the number of distinct job types is bounded, where jobs of a given type are indistinguishable from each other. This means that the set of jobs on input can be given compactly by specifying integers with , such that denotes the number of jobs of type that are to be scheduled. Modeling our terminology after Onn [29], we call a problem huge when the numbers on input are given in binary. For example, the Cutting Stock problem can be seen as the huge variant of the Bin Packing problem. All of our results work for the huge variant.

We show that:

###### Theorem 1.1

The following scheduling problems are FPT with respect to parameter as defined below and solvable in time , where

1. :

2. :

3. :

###### Theorem 1.2

is FPT parameterized by and solvable in time .

Note that part (1) of Theorem 1.1 for the easier problem was already shown by Mnich and Wiese [27]. However, our approach is substantially different and more straightforward, as demonstrated by the immediate extension to . Also, our result only has a single-exponential dependence on the parameter, unlike the double-exponential dependence of Mnich and Wiese. Thus, Theorem 1.1 serves to highlight the usefulness of -fold integer programming in parameterized complexity. Theorem 1.2 differs as it is proved using the well known fixed dimension techniques of Khachiyan and Porkolab [22].

In order to prove part (3) of Theorem 1.1 we use an -fold IP formulation and optimize a separable convex function over it. However, the algorithm of Hemmecke et al. [16] only works for linear and certain restricted separable convex objectives. Thus, using the ideas of Hemmecke, Köppe and Weismantel [15], we extend the previous result to optimizing any separable convex function.

We complement our positive findings by two hardness results:

###### Theorem 1.3

and is W[1]-hard when parameterized by , even when job processing times and weights are given in unary.

### 1.2 Related work

We give a brief summary of known results related to scheduling and parameterized complexity. Many more results can be found in surveys on this topic (e.g. [24]). Note that these surveys focus on NP-hardness results and polynomial and approximation algorithms. There were several attempts to introduce scheduling problems to the FPT community. It started with the pioneering work of Bodlaender and Fellows [8] for the precedence constrained scheduling and continued (after nearly 10 years) with the first FPT algorithm of Fellows and McCartin [11]. A recent result of van Bevern et al. [3] resolves a question of Mnich and Wiese by showing that makespan minimization with precedence constraints is W[2]-hard. Marx [10, 26] also highlighted the importance of scheduling in the parameterized setting.

Many other settings are now popular in the scheduling community. These include Open Shop, where we are given for each job a bunch of tasks with associated machines to be completed in the natural order (that is has to finish before starts to be processed) – see related work of van Bevern and Pyatkin [6] and Kononov et al. [23]. In Two agent scheduling there are two agents competing for one machine to schedule their respective jobs within each agents budget. Hermelin et al. [17] showed that if one agent has only jobs and the other agent has jobs with unit processing times then the problem admits an FPT algorithm with parameter . Halldórsson and Karlsson [14], followed by work of van Bevern et al. [4, 5] investigate interval scheduling (or job interval selection) in which each job has several time slots in which it may be processed and the task is to schedule as many jobs as possible.

We now turn our attention towards more classical models of scheduling. A summary of what follows can be found in Table 1.

#### Makespan and identical machines – P||Cmax

Most importantly, Mnich and Wiese [27] show that there is an FPT algorithm for this problem when parameterized by . A remarkable result of Jansen et al. [21] shows that the Unary Bin Packing problem is W[1]-hard when parameterized by the number of bins. This immediately implies the W[1]-hardness of parameterized by even when is given in unary, and with some effort also implies the hardness of with parameter when and are given in unary, as we show in Section 3.

#### Makespan and unrelated machines – R||Cmax

Asahiro et al. [2] show that the problem is strongly NP-hard already for restricted assignment when there is a number for each job such that for each machine and all and for every job there are exactly two machines where it can run. Mnich and Wiese [27] proved that the problem is in FPT with parameters and .

#### Sum of weighted completion times and unrelated machines – R||∑wjCj

Surprisingly, in the unweighted case, turns out to be solvable in polynomial time [9, 20]. Preemption () makes the problem strongly NP-hard [31]. The weighted case is strongly NP-hard [12, Problem SS13].

## 2 Preliminaries

For a positive integer , we denote and the length of binary encoding of . We write vectors in bold such as . By we denote the length of encoding of which is ; similarly for matrices. Let . A function is separable convex if it can be written as such that is univariate convex for all . Given a function , a comparison oracle, queried on two vectors , asserts whether or not . Time complexity measures the number of arithmetic operations and oracle queries.

### 2.1 N-fold Integer Programming

Recall the definition of the -fold IP problem (1). Observe that in an -fold IP, every equality of is of one of two kinds. Either corresponds to a certain row of repeated times, meaning that for all ; we call this equality globally uniform. Or, , corresponding to zeros, a certain row of , and zeros, such that there also must exist other equalities of this form which have the same coefficients on the remaining bricks and zeros elsewhere. We call this kind of constraint locally uniform. Thus, given an IP in dimension , we can prove that it is an -fold IP by showing that every equality is either globally uniform or locally uniform.

Let be the length of the input. The first key result we use is the following:

###### Theorem 2.1

([16, Theorem 6.1]) For any fixed and , there is an algorithm that, given , , , matrices and of appropriate dimensions with all entries bounded by in absolute value, , and , solves problem (1) in time .

In other words, if and are parameters and are input, the -Fold IP problem can be solved in FPT time.

### 2.2 Separable convex minimization

We also need a result regarding minimization of separable convex function. Given a separable convex function , we consider integer programs of the form:

 min{f(\boldmathx):A(n)% \boldmathx=\boldmathb, \boldmathl≤\boldmathx≤\boldmathu, \boldmathx∈Znt}. (2)

Hemmecke, Onn and Romanchuk prove that:

###### Theorem 2.2

([16, Theorem 4.1]) For matrices and of appropriate dimensions, there is an algorithm that, given , , separable convex function presented by a comparison oracle, and a feasible point in the program (2), either asserts that is optimal or finds an augmenting step for which satisfies in linear time .

In particular, if we are able to find an initial solution and guarantee that the optimum is near, that is, for some , applying Theorem 2.2 at most times will reach the optimum.

Under suitable assumptions on the function , the continuous optimum of Problem 2 can be found in polynomial time using the ellipsoid method or an interior point method. The key insight of Hemmecke, Köppe and Weismantel [15] is adapting a proximity technique of Hochbaum and Shantikumar [19] for the context of Graver bases:

###### Theorem 2.3

([15, Theorem 3.14]) Let be an optimal solution of the continuous relaxation of (2),

 min{f(\boldmathx):A(n)% \boldmathx=\boldmathb, \boldmathl≤\boldmathx≤\boldmathu, \boldmathx∈Rnt}.

Then there exists an optimal solution of the integer optimization problem (2) with

 ||^\boldmathx−\boldmathx∗||∞≤n⋅max{||v||∞∣v∈G(A)}.

Here, is the Graver basis of the bimatrix , and the quantity is bounded by a ([28, Lemma 3.20]). Hence, applications of Theorem 2.2 (with ) reach the integer optimum:

###### Theorem 2.4

For any fixed and , there is an algorithm that, given , , , matrices and of appropriate dimensions with all entries bounded by in absolute value, , and , solves problem (2) in time .

### 2.3 Convex minimization in fixed dimension

To prove Theorem 1.2 we formulate an integer linear program in fixed dimension and minimize a convex function over it:

###### Theorem 2.5

(Khachiyan and Porkolab [22]) Minimizing a quasiconvex function over a semialgebraic convex set defined by polynomials in dimension is FPT with respect to and .

In order not to delve into unnecessary details, let us say that a quasiconvex function is a generalization of a convex function, and semialgebraic convex sets are a generalization of convex sets, containing e.g. the feasible regions of semidefinite programs (SDPs); see the book by Blekherman et al. [7]. There are less general variants of this result which attain better running times, e.g. by Hildebrand and Köppe [18]. Since our aim is to simply prove fixed-parameter tractability, we choose to state the most general result.

Note that we are not aware of an application of Theorem 2.5 which would use the fact that one can optimize over a region more general than the integer hull of a polyhedron (i.e., a region given by non-linear convex constraints). There is a “linearization trick” which is widely used (including by Mnich and Wiese): a convex constraint whose domain is bounded by some number given in unary can be rewritten as linear constraints describing the piecewise linear approximation of which is exact on the integers of its domain. Then, the feasible region is the integer hull of a polyhedron. To the best of our knowledge, there is no result whose feasible region is given by a set of constraints that cannot be “linearized” as described above. So both us and Mnich and Wiese [27] only need this result because of its generality in terms of the objective function, not the feasible region. It is an interesting open problem to find an application of Theorem 2.5 whose feasible region is given by, for example, a semidefinite program in fixed dimension.

### 2.4 Smith’s rule – structure of solutions when minimizing ∑wjCj

Here we make a few basic observations about the structure of (optimal) solutions in the problem . To do so, we utilize a useful way of visualizing the objective function called two-dimensional Gantt charts (2D Gantt charts), which was introduced by Goemans and Williamson [13].

Let us first introduce the following notation. Fix a machine and assume that the set of jobs scheduled to run on is given, denoted . Whenever the index of a machine is clear from context, we omit it. For any set of jobs let and . A 2D Gantt chart starts at point and ends at . Each job is represented by a rectangle of length and height whose position is defined by a startpoint and an endpoint. The startpoint of a job is the endpoint of a previous job (or for the first job) while its endpoint is . The value is then simply the area beneath the upper sides of the rectangles; see Figure 1.

For minimization on one machine with no precedence constraints (no restrictions on the order of the jobs) there is a simple observation about the structure of an optimal schedule:

###### Lemma 1

(Smith’s rule [13]) Given a set of jobs , a schedule minimizing is given by ordering the jobs by non-increasing .

Since the ratios correspond to slopes of the rectangles in a 2D Gantt chart, Smith’s rule implies that the chart of an optimal schedule will have slopes which form a piecewise linear convex function. Goemans and Williams then go on to observe that for such a chart there is an alternate way of computing its area based on splitting it into triangles; see Figure 2. That leads us to this lemma:

###### Lemma 2

Given jobs scheduled to run on machine such that for all , the optimal schedule has value

 l∑j=1(12p({J1,…,Jj})2(ρ(j)−ρ(j+1))+12wjpj).
###### Proof

Given the set , the optimal schedule on the machine is determined according to Smith’s rule. It is possible to divide the area as can be seen on Figure 2. Note that the gray area is determined by the set of jobs and in fact can be computed just from the knowledge of as for each job This results in the linear term in the statement.

It remains to compute the area under the bold line (orange area in color printing) of Figure 2 – i.e. the area under the piecewise linear function (again determined by the observed structure of the solution). We divide the area into triangles and compute the total area as a sum of those.

For a job we compute the contribution of the job as the associated area. The total area can be expressed as a difference of area of two impedance triangles – see Figure 3 for illustration. The length of the common ordinate parallel to processing time axis is so it remains to establish the height of the two triangles. We express it with the help of a tangent rule as (and )

It is straightforward to express the total area contribution of the job as

 Jj=12p({J1,…,Jj})⋅(b′−b)=12p({J1,…,Jj})⋅p({J1,…,Jj})(ρ(j)−ρ(j+1))=12p({J1,…,Jj})2(ρ(j)−ρ(j+1)). (3)

Summing over all jobs in finishes the proof.

In our setup the set will be given by integers representing how many jobs of each type are scheduled to run on machine . Observe that for each type jobs of type have identical slope and thus correspond to a single triangle in the chart. We have the following corollary:

###### Corollary 1

Given integers representing numbers of jobs of each type scheduled to run on machine and a permutation such that for all , the optimal schedule has value where .

## 3 W[1]-hardness of unary P||Cmax and P||∑wjCj

The Bin Packing problem asks whether bins of size suffice to contain a set of items represented by integers . It is straightforward from the 2-Partition problem that this is NP-complete when are large numbers given in binary. Remarkably, Jansen et al. [21] prove that even when the numbers are given in unary (i.e., assume ), there is likely no algorithm as the problem is W[1]-hard parameterized by . This hardness obviously translates to makespan minimization: deciding whether there is a schedule of jobs on machines with is equivalent to deciding the aforementioned Unary Bin Packing problem.

To the best of our knowledge, the analogous question regarding the complexity of parameterized by the number of machines was not yet considered. We prove that it is W[1]-hard by once again reducing Unary Bin Packing to it.

Jansen et al. note that their hardness result stands even for tight instances of Unary Bin Packing, that is, instances where . Given a tight instance of Unary Bin Packing, construct an instance of consisting of machines and jobs with for . Let and for denote the set of jobs scheduled on machine and the completion time of machine , respectively. Because the ratio is identical for all jobs, the ordering of jobs on a each machine is irrelevant. Thus, the contribution of a machine to the objective function is

 12^C2ℓ+∑j∈Jℓp2j2.

Summing over all machines, we get

 (∑j∈Jℓp2j2)+(k∑ℓ=112^C2ℓ).

We argue that a schedule with cost exists if and only if the original Unary Bin Packing instance is a “yes” instance. Observe that there is only one schedule of this cost, namely one where for all . Let for all . Disregarding the term which is independent of the schedule, the contribution becomes

 k∑ℓ=112(B+Δℓ)2=k∑ℓ=112(B2+2ΔℓB+Δ2ℓ).

Since , . Thus exactly when for all , that is, when for all . That concludes the proof of Theorem 1.3.

## 4 Fpt results

### 4.1 Warmup: P||Cmax and Q||Cmax parameterized by pmax

In this section we show that and its generalization is FPT parameterized by .

Denote . We say that a job of length is of type . On input we have jobs of at most types, given as numbers encoding the number of jobs of given type (in binary). For every machine we have variables ; in the solution the interpretation of is “how many jobs of type are scheduled on machine ”. Let us fix a time ; the IP we will formulate will be feasible if there is a schedule with .

To assure that each job is scheduled on some machine, we state these globally uniform constraints:

 m∑i=1xij=nj∀1≤j≤Θ. (4)

To assure that, for every machine , , the lengths of jobs scheduled on sum up to at most , we state a locally uniform constraint:

 Θ∑j=1jxij≤T (5)

(Note here that using inequalities instead of equations does not cause problems: we can simply introduce a slack variable for every inequality: ; it is also possible to add a suitable number of unit-processing time jobs and work with equalities directly; similarly in the following.)

Clearly if this program is feasible, then there exists a schedule with . Finding minimum can be then done in polynomially many steps by binary search. Thus we want to show that checking feasibility is FPT by applying Theorem 2.1.

To apply Theorem 2.1, we need to bound the values and . Clearly the brick size is , the number of globally uniform constraints is and the number of locally uniform constraints per brick is . Finally, the largest coefficient is .

#### Q||Cmax

Now we are given speeds for every machine, such that executing a job with processing time takes time . The globally uniform constraints (4) are the same, but the locally uniform constraints (5) now become:

 Θ∑j=1jxij≤siT. (6)

Observe that only the right hand side differs for every machine. This finishes the proof of part (1) of Theorem 1.1.

### 4.2 R||Cmax parameterized by pmax and K

Now we turn to the unrelated machines model. Observe that with parameters and the number of kinds of machines , there are at most possible vectors of processing times with respect to kinds of machines, which we call types, and each job is of a certain type. The input is then again given (in binary) by integers specifying the number of jobs of each type.

As before, we will describe an -fold IP solving the problem. We have variables with the same interpretation as above. The globally uniform constraints are the same as before, (4).

In the previous examples the locally uniform constraints were used to specify that the jobs assigned to each machine finish by time However, now we need to specify a different constraint for each kind of machine, which might seem hard to do “uniformly”. Fortunately, because the number of kinds of machines is bounded, we can actually specify all constraints simultaneously and make all but “the right one” irrelevant by differing right hand side.

Formally, let be some number bigger than , then for machine which is of kind we have locally uniform constraints

 Θ∑j=1pk′jxk′j ≤B ∀1≤k′≠k≤K, Θ∑j=1pkjxkj ≤T.

In the above constraints whenever we replace it by zero and forbid the job to be run on this kind of machine by specifying appropriate upper bounds:

 xij ≤nj ∀1≤k≤K,pkj∈[pmax] (7) xij ≤0 ∀1≤k≤K,pkj=∞, (8) xij ≥0 ∀i,j. (9)

Observe that the constraints above are indeed locally uniform – they are identical for every machine up to the right hand side. Thus we have defined an -fold IP, which is feasible if there is a schedule with . It remains to observe that all of and are bounded by our choice of parameters and : clearly , , and . Using Theorem 2.1 concludes the proof of part (2) of Theorem 1.1.

### 4.3 R||∑wjCj parameterized by pmax+wmax and K

Here we turn our attention to the objective.

Recall what follows from Corollary 1: we have shown that, given integers representing numbers of jobs of each type to be scheduled on machine , the contribution of to the objective function is where and is a permutation such that for all . Observe that is separable convex and thus also Our goal now is to once again formulate an -fold IP, however this time we need to introduce new variables , for and For a machine of kind , we want so that we can use the formulation of which we just stated. Notice that we are introducing many “unnecessary” variables for kinds . This is in order to have a uniform set of local constraints.

The globally uniform constraints (4) stay the same. The locally uniform constraints serve to project the brick to the variables with permutations as defined above:

 j∑l=1xilpiπk(l)=zij,k∀j∈[Θ],∀k∈[K],∀i∈[m].

It is in the objective function where we distinguish which are relevant for which machine. In the following, let if machine is of kind :

 f(\boldmathx,\boldmathz%\boldmath$z$)=m∑i=1Θ∑j=1(12(zij)2(ρi(j)−ρi(j+1))+12xijpijwj).

Lower and upper bounds (7)-(9) stay as before. Applying Theorem 2.4 concludes the proof of part (3) of Theorem 1.1.

### 4.4 R||∑wjCj parameterized by m and θ

Finally, we examine the same scenario as before, but this time we restrict the number of machines to be a parameter, but, in turn, relax the restriction from to . We use the same ILP formulation which Mnich and Wiese used to show that is FPT with respect to and . However, the careful analysis in Corollary 1 was needed to show that the objective function is convex in order to apply Theorem 2.5.

Let be the number of distinct types of jobs. We have variables , and permutations with the same meaning as above. Notice that the following can be seen as a subset of the previous -fold IP:

 minimize f(\boldmathx,\boldmathz)=m∑i=1Θ∑j=1(12(zij)2(ρi(j) − ρi(j+1))+12xijpijwj) subject to m∑i=1xij=nj ∀ j∈[Θ] j∑l=1xilpiπi(l)=zij ∀ j∈[Θ],∀i∈[m]

In order to apply Theorem 2.5, we observe that both the number of variables and the number of constraints are fixed parameters, and that the objective function is convex as shown in the previous subsection. This concludes the proof of Theorem 1.2.

## 5 Conclusions

Although much is known about approximating scheduling problem, little is known from the parameterized complexity point of view about the most basic problems. The purpose of this paper is twofold. The first is to show new FPT algorithms for some scheduling problems. The second is to demonstrate the use of -fold integer programming, a recent and powerful variable dimension technique. We hope to encourage research in both directions. To facilitate this research, we point out the following open problems:

• Minimizing weighted flow time parameterized by .

• parameterized by instead of .

• parameterized by and ; this is justified by the problem being strongly NP-hard [31], so parameterizing by is not enough.

• parameterized by with both and given in binary; this might be possible using the recently developed result for huge -fold IPs due to Onn and Sarrabezolles [29].

• Multi-agent scheduling was studied by Hermelin et al. [17]; what results can be obtained by applying -fold IP?

• Turning our attention to developing the techniques we use, we ask if -block -fold IP (a generalization of -fold IP) is FPT or W[1]-hard; only an XP algorithm is known so far [15].

• We are also interested in further applications of -fold IP and quasiconvex minimization over convex sets in fixed dimension.

#### Acknowledgements.

We would like to thank René van Bevern for pointing us to much related work.

## References

• [1] Allahverdi, A.: The third comprehensive survey on scheduling problems with setup times/costs. European Journal of Operational Research 246(2), 345–378 (2015).
• [2] Asahiro, Y., Jansson, J., Miyano, E., Ono, H., Zenmyo, K.: Approximation algorithms for the graph orientation minimizing the maximum weighted outdegree. In: M.Y. Kao, X.Y. Li (eds.) AAIM, LNCS, vol. 4508, pp. 167–177. Springer (2007).
• [3] van Bevern, R., Bredereck, R., Bulteau, L., Komusiewicz, C., Talmon, N., Woeginger, G.J.: Precedence-constrained scheduling problems parameterized by partial order width. CoRR abs/1605.00901 (2016).
• [4] van Bevern, R., Mnich, M., Niedermeier, R., Weller, M.: Interval scheduling and colorful independent sets. J. Scheduling 18(5), 449–469 (2015).
• [5] van Bevern, R., Niedermeier, R., Suchý, O.: A parameterized complexity view on non-preemptively scheduling interval-constrained jobs: few machines, small looseness, and small slack. CoRR abs/1508.01657 (2015).
• [6] van Bevern, R., Pyatkin, A.V.: Completing partial schedules for open shop with unit processing times and routing. In: CSR 2016, pp. 73–87 (2016).
• [7] Blekherman, G., Parrilo, P.A., Thomas, R.R.: Semidefinite Optimization and Convex Algebraic Geometry. SIAM (2012)
• [8] Bodlaender, H.L., Fellows, M.R.: W[2]-hardness of precedence constrained k-processor scheduling. Oper. Res. Lett. 18(2), 93–97 (1995).
• [9] Bruno, J., Coffman Jr., E.G., Sethi, R.: Scheduling independent tasks to reduce mean finishing time. Commun. ACM 17(7), 382–387 (1974).
• [10] Demaine, E.D., Hajiaghayi, M., Marx, D. (eds.): Parameterized complexity and approximation algorithms, 13.12. - 17.12.2009, Dagstuhl Seminar Proceedings, vol. 09511. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, Germany (2009).
• [11] Fellows, M.R., McCartin, C.: On the parametric complexity of schedules to minimize tardy tasks. Theor. Comput. Sci. 2(298), 317–324 (2003).
• [12] Garey, M.R., Johnson, D.S.: Computers and intractability: A guide to the theory of np-completeness (1979)
• [13] Goemans, M., Williamson, D.P.: Two-dimensional Gantt charts and a scheduling algorithm of Lawler. SIAM Journal on Disc. Mat. 13(3), 281–294 (2000).
• [14] Halldórsson, M.M., Karlsson, R.K.: Strip graphs: Recognition and scheduling. In: WG 2006, pp. 137–146 (2006).
• [15] Hemmecke, R., Köppe, M., Weismantel, R.: Graver basis and proximity techniques for block-structured separable convex integer minimization problems. Math. Program 145(1-2), 1–18 (2014).
• [16] Hemmecke, R., Onn, S., Romanchuk, L.: n-fold integer programming in cubic time. Math. Program 137(1-2), 325–341 (2013).
• [17] Hermelin, D., Kubitza, J., Shabtay, D., Talmon, N., Woeginger, G.J.: Scheduling two competing agents when one agent has significantly fewer jobs. In: IPEC 2015, pp. 55–65 (2015).
• [18] Hildebrand, R., Köppe, M.: A new Lenstra-type algorithm for quasiconvex polynomial integer minimization with complexity . Discrete Optimization 10(1), 69–84 (2013)
• [19] Hochbaum, Shanthikumar: Convex separable optimization is not much harder than linear optimization. JACM: Journal of the ACM 37 (1990)
• [20] Horn, W.A.: Technical Note—Minimizing Average Flow Time with Parallel Machines. Operations Research 21(3), 846–847 (1973).
• [21] Jansen, K., Kratsch, S., Marx, D., Schlotter, I.: Bin packing with fixed number of bins revisited. Journal of Computer and System Sciences 79(1), 39–49 (2013).
• [22] Khachiyan, L., Porkolab, L.: Integer Optimization on Convex Semialgebraic Sets. Discrete & Computational Geometry 23(2), 207–224 (2000)
• [23] Kononov, A.V., Sevastyanov, S., Sviridenko, M.: A complete 4-parametric complexity classification of short shop scheduling problems. J. Scheduling 15(4), 427–446 (2012).
• [24] Lawler, E.L., Lenstra, J.K., Kan, A.H.R., Shmoys, D.B.: Sequencing and scheduling: Algorithms and complexity. Handbooks in operations research and management science 4, 445–522 (1993)
• [25] Lenstra Jr., H.W.: Integer programming with a fixed number of variables. Mathematics of Operations Research 8(4), 538–548 (1983)
• [26] Marx, D.: Packing and scheduling algorithms for information and communication services (dagstuhl seminar 11091). Dagstuhl Reports 1(2), 67–93 (2011).
• [27] Mnich, M., Wiese, A.: Scheduling and fixed-parameter tractability. Mathematical Programming 154(1), 533–562 (2014).
• [28] Onn, S.: Nonlinear discrete optimization. Zurich Lectures in Advanced Mathematics, European Mathematical Society (2010)
• [29] Onn, S., Sarrabezolles, P.: Huge unimodular -fold programs. SIAM Journal on Discrete Mathematics 29(4), 2277–2283 (2015).
• [30] Potts, C.N., Strusevich, V.A.: Fifty years of scheduling: a survey of milestones. JORS 60(S1) (2009).
• [31] Sitters, R.: Complexity of preemptive minsum scheduling on unrelated parallel machines. J. Algorithms 57(1), 37–48 (2005).
You are adding the first comment!
How to quickly get a good reply:
• Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
• Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
• Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters