20240717/2005.03552v2.json

{
    "title": "Online Algorithms to Schedule a Proportionate Flexible Flow Shop of Batching Machines",
    "abstract": "This paper is the first to consider online algorithms to schedule a proportionate flexible flow shop of batching machines (PFFB). The scheduling model is motivated by manufacturing processes of individualized medicaments, which are used in modern medicine to treat some serious illnesses.\nWe provide two different online algorithms, proving also lower bounds for the offline problem to compute their competitive ratios.\nThe first algorithm is an easy-to-implement, general local scheduling heuristic. It is 2-competitive for PFFBs with an arbitrary number of stages and for several natural scheduling objectives. We also show that for total/average flow time, no deterministic algorithm with better competitive ratio exists.\nFor the special case with two stages and the makespan or total completion time objective, we describe an improved algorithm that achieves the best possible competitive ratio , the golden ratio.\nAll our results also hold for proportionate (non-flexible) flow shops of batching machines (PFB) for which this is also the first paper to study online algorithms.",
    "sections": [
        {
            "section_id": "1",
            "parent_section_id": null,
            "section_name": "Introduction",
            "text": "In modern pharmacy, in order to treat various serious illnesses, individualized medicaments are produced to order for a specific patient. These production processes often take place in a complex production line, consisting of many different steps.\nAs long as each step of the process is still performed manually, for example by a laboratory worker, usually at each step only one patient can be handled at a time.\nHowever, once the process is scaled to industrial production levels, instead, for some steps, machines, like pipetting robots, are used.\nIndeed, at that point, in order to scale up production, usually several machines are used in parallel at each step.\nWhat is more, these types of machines can often handle multiple patients simultaneously.\nIf scheduled efficiently, this special feature can drastically increase the throughput of the production line.\nClearly, in such an environment efficient operative planning is crucial in order to optimize the performance of the manufacturing process and treat as many patients as possible as quickly as possible.\nIn a practical setting, the producer of the individualized drug knows nothing about the patient until the medicine is actually ordered. This naturally creates an online scheduling scenario, for which efficient, computable and, if possible, easy-to-understand scheduling rules are needed. Therefore, in this paper, we specifically deal with the online version of the problem, although some of our findings are interesting in terms of offline scheduling as well.\nFormally, the manufacturing process studied in this paper is structured in a flexible flow shop manner (also called hybrid flow shop in the literature).\nA job , , representing the production of a drug for a specific patient, has to be processed in  stages  in order of their numbering. At each stage  there are available  identical,\nparallel machines  to process the jobs. If each stage consists of only one machine, we may drop the machine index and instead identify each stage  with its single machine .\nEach job  has a release date , denoting the time at which the job  is available for processing at the first stage . We assume that jobs are indexed in earliest release date order.\nFurthermore, a job is only available for processing at stage , , when it has finished processing at the previous stage .\nProcessing times are only dependent on the stage, not on the job or the specific machine where the job is processed (recall that machines at each stage are identical). This means that each stage , , is associated with a fixed processing time , which is the same for every job when processed at that stage on any machine.\nIn the literature, a (flexible) flow shop with such job-independent processing times is sometimes called a proportionate flow shop, see, e.g., Panwalkar et al. (2013  ###reference_b20###).\nRecall that, as a special feature from our application, each machine in the flexible flow shop can potentially handle multiple jobs at the same time.\nThese kind of machines are called (parallel) batching machines and a set of jobs processed at the same time on some machine is called a batch on that machine (Brucker, 2007  ###reference_b4###, Chapter 8).\nAll jobs in one batch on some machine  of stage  have to start processing on  at the same time.\nIn particular, all jobs in one batch at stage  have to be available for processing at , before the batch can be started.\nThe processing time of a batch on  remains , no matter how many jobs are included in this batch.\nAt each stage , , machines have a common maximum batch size (or batch capacity) , which is the maximum number of jobs a batch on machines of stage  may contain.\nGiven a feasible schedule , we denote by  the completion time of job  at stage . For the completion time of job  on the last machine we also write . If there is no confusion which schedule is considered, we may omit the reference to the schedule and simply write  and .\nAs optimization criteria, we study the four objective functions makespan ,\ntotal completion time , maximum flow time  and total flow time , where . Note that the total flow time (or average flow time, if divided by the number of jobs) measures the average time a patient has to wait for his or her medicament, after the production is ordered. As short waiting times are essential in the treatment of life threatening illnesses, this objective is particularly relevant in practice. For more considerations about meaningful performance measures in applications, we refer to Ackermann et al. (2020  ###reference_b1###).\nUsing the standard three-field notation for scheduling problems (Graham et al., 1979  ###reference_b10###; Pinedo, 2012  ###reference_b21###),\nour problem is denoted as\nwhere  is one of the four objective functions from above. We refer to the described scheduling model as proportionate flexible flow shop of batching machines and abbreviate it by PFFB. If we consider the special case where each stage consists of only one machine, we call this the usual proportionate flow shop of batching machines and abbreviate it by PFB.\nIn this paper we deal with the online problem to schedule a PFFB where each job is unknown until its release date. In particular, this means that the total number  of jobs remains unknown until the end of the scheduling process.\nThroughout this paper, we write  for the golden ratio.\nNext, we provide an (offline) example in order to illustrate the problem setting.\nConsider an instance of PFFB with  stages,  machine at stage  and  machines at , maximum batch sizes  and , processing times  and , as well as,  jobs with release dates , , and . Fig. 1  ###reference_### illustrates a feasible schedule for the instance as job-oriented Gantt chart.\nEach rectangle labeled by a machine represents a batch of jobs processed together on this machine. The black area indicates that the respective jobs have not been released at this time yet. Note that in this example none of the batches can be started earlier, since either a job of the batch has just arrived when the batch is started, or the machine is occupied before. Still, the schedule does not minimize the makespan, since the schedule shown in Fig. 2  ###reference_### is feasible as well and has a makespan of 11 instead of 12.\nThe improvement in the makespan was achieved by reducing the size of the first batch on  from three to two, which allows to start it one time step earlier. Observe that no job can arrive at  before time step 3. Moreover, one of the two machines at  has to process at least two batches in order to complete all five jobs. This takes at least 8 time units. Thus, 11 is the optimal makespan and no further improvement is possible."
        },
        {
            "section_id": "1.1",
            "parent_section_id": "1",
            "section_name": "Our Results",
            "text": "This is the first study of P(F)FBs from an online perspective. We concentrate our research on the four practically highly relevant objective functions makespan, total completion time, maximum flow time and total flow time. An overview of our results can be found in Table 1  ###reference_###.\n###table_1### Concerning lower bounds on the competitive ratio, we observe that previously known bounds of  for one-stage PFFBs to minimize makespan or maximum flow time by Zhang et al. (2003  ###reference_b27###) and Jiao et al. (2014  ###reference_b13###), respectively, carry over to arbitrarily many stages by introducing stages with negligible processing times. In addition, we show that  is also a lower bound with respect to total completion time, while for total flow time even a lower bound of  can be achieved.\nConcerning upper bounds on the competitive ratio, we provide two algorithms. We first introduce the Never-Wait strategy, where machines are only idle if not enough patients are available for processing (see Section 6  ###reference_### for details). This strategy is easy to implement and applicable for all four considered objective functions and very general machine environments, even with large number of stages and/or large numbers of machines per stage. We prove that the Never-Wait strategy achieves a competitive ratio of  for any such instance and all four considered objectives. In particular, this is best-possible with respect to total flow time.\nWe also show that the \u201copposite\u201d strategy, where we always wait until a full batch can be started, is not an -approximation algorithm (and, in particular, not -competitive) for any .\nFor the specific scenario of  stages, we also introduce the -Switch strategy, where the first stage is scheduled in such a way, that as many jobs as possible are available at the second stage at some time ; at the second stage, waiting is allowed until time  and afterwards the stage is scheduled as in the Never-Wait strategy (see Section 7  ###reference_### for details). Choosing  correctly yields an improved competitive ratio with respect to makespan and total completion time from  to , which is also best possible for these problems."
        },
        {
            "section_id": "1.2",
            "parent_section_id": "1",
            "section_name": "Overview of this Paper",
            "text": "The remainder of this paper is structured as follows. In Section 2  ###reference_###, we give an overview of related literature. In Section 3  ###reference_### we provide lower bounds for the competitive ratio in PFFBs for the four objective functions we consider. Sections 4  ###reference_### and 5  ###reference_### are dedicated to establishing the structural results needed in order to prove competitiveness of the online algorithms we provide in the subsequent sections: in Section 4  ###reference_### we prove that permutation schedules with jobs ordered by release dates are optimal for all of our four objective functions and in Section 5  ###reference_### we show lower bounds for completion times of jobs in such permutation schedules. The latter are needed to prove competitiveness of our algorithms.\nSections 6  ###reference_### and 7  ###reference_### deal with the general Never-Wait and the more specialized t-Switch algorithm, respectively.\nFinally, in Section 8  ###reference_### we present conclusions and some further thoughts."
        },
        {
            "section_id": "2",
            "parent_section_id": null,
            "section_name": "Literature",
            "text": "To the best of our knowledge, neither the online PFFB problem, nor its special case, the online PFB problem, have been studied before. A practical study specific to the application introduced in the beginning can be found in Ackermann et al. (2020  ###reference_b1###). Some of the concepts investigated in this paper in general have already been introduced in an application specific sense in that paper.\nEven for the offline PFFB problem, little is known. Previous work has been focused on (usually non-proportionate) NP-hard generalizations motivated by applications in various manufacturing industries. Common techniques include mixed-integer programming models or application-specific heuristics. See, e.g., Amin-Naseri and Beheshti-Nia (2009  ###reference_b3###); Luo et al. (2011  ###reference_b18###); Li et al. (2015  ###reference_b14###); Tan et al. (2018  ###reference_b24###).\nIn the special case of offline PFBs, with only one machine per stage, proportionate versions have been studied explicitly. Sung et al. (2000  ###reference_b23###) propose heuristic approaches to minimize the makespan and the total completion time in a PFB. However, they do not establish any complexity result.\nFor the special case of two stages, Ahmadi et al. (1992  ###reference_b2###), as well as, Sung and Yoon (1997  ###reference_b22###) present polynomial time algorithms. In a previous paper (Hertrich et al., 2020  ###reference_b12###), we present a dynamic program that can be used to minimize several traditional objective functions (including the four objectives studied in this paper) in polynomial time for any fixed number  of stages. For the case of  being part of the input, the complexity status of offline PFBs is open. Significant hardness results have, to the best of our knowledge, not been achieved at all. See also (Hertrich et al., 2020  ###reference_b12###), for an in-depth literature review for offline PFBs.\nAlthough the PFFB problem itself has not been investigated from an online or offline perspective before, there are several helpful results for related online problems in the literature. For our purposes, the most interesting family of related problems is online scheduling of single and parallel batching machines. With job-independent processing times, these problems can be viewed as the one-stage versions of P(F)FBs. We refer to Tian et al. (2014  ###reference_b25###) for a survey.\nConcerning online makespan minimization for a single batching machine with identical processing times, Zhang et al. (2001  ###reference_b26###) and Deng et al. (2003  ###reference_b8###) show that no deterministic online algorithm can achieve a competitive ratio better than the golden ratio . Fang et al. (2011  ###reference_b9###) provide a deterministic online algorithm matching this bound, even in a slightly more general setting, where processing times are not assumed to be identical, but only grouped, that is, differing by a factor of at most  from each other. Moreover, Zhang et al. (2003  ###reference_b27###) show that  is also the precise competitive ratio for makespan minimization on parallel batching machines with identical processing times, that is, a one-stage PFFB. Li and Chai (2018  ###reference_b16###) extend this result to minimizing the maximum weighted completion time.\nConcerning the total completion time objective, Cao et al. (2011  ###reference_b5###) present a 2-competitive online algorithm for parallel batching machines with identical processing times, which even works in the presence of precedence constraints. For the generalization where jobs are allowed to have unequal processing times and the total weighted completion time objective, -competitive algorithms are known (Chen et al., 2004  ###reference_b7###; Ma et al., 2014  ###reference_b19###).\nResearch on scheduling parallel batching machines to minimize maximum flow time started with the case where batches may have unbounded size (Li and Yuan, 2011  ###reference_b15###). For the bounded batch model, as we consider it in this paper, Jiao et al. (2014  ###reference_b13###) provide a -competitive deterministic online algorithm to minimize maximum flow time on parallel batching machines with identical processing times, i.e., a one-stage PFFB, and prove that this is best possible. Hence, the competitive ratio for makespan minimization by Zhang et al. (2003  ###reference_b27###) carries over to maximum flow time. Recently, it has been shown that the competitive ratio of  for maximum flow time remains also valid for maximum weighted flow time (Chai et al., 2019  ###reference_b6###) or maximum flow time with delivery times (Lin et al., 2019  ###reference_b17###).\nAlthough total flow time seems to be a very reasonable objective function from a practical perspective, we are not aware of any previous research about competitive algorithms for bounded p-batching problems on single or parallel machines to minimize total flow time."
        },
        {
            "section_id": "3",
            "parent_section_id": null,
            "section_name": "Lower Bounds for the Competitive Ratio",
            "text": "In this section we provide lower bounds on the competitiveness of deterministic online algorithms for PFFB problems with our considered objective functions , , , and .\nBefore we start, note that lower bounds on PFFBs with only one stage naturally extend to PFFBs with arbitrarily many stages by choosing negligible processing times for all stages but the first one. Therefore, in the following, we focus on such instances with .\nFor the makespan objective, Zhang et al. (2003  ###reference_b27###) prove that the golden ratio  is a lower bound on parallel batching machines with identical processing times, i.e., a one-stage PFFB. Furthermore, Jiao et al. (2014  ###reference_b13###) prove the same bound of  for the maximum flow time objective.\nThere are no deterministic online algorithms to minimize the makespan or maximum flow time in a PFFB with a competitive ratio less than . This result holds even if no stage has maximum batch size larger than .\nBy using constructions similar to Zhang et al. (2003  ###reference_b27###) and Jiao et al. (2014  ###reference_b13###), we also obtain lower bounds on the competitive ratio for the total completion and flow time objectives. We first show that the golden ratio  is also a lower bound for the competitiveness for the total completion time objective.\nThere are no deterministic online algorithms to minimize the total completion time in a PFFB with a competitive ratio less than .\nConsider a PFFB instance with , ,  and a fixed batch size . Suppose the first job  is released at time . We distinguish two possible behaviors of a deterministic online algorithm.\nCase 1: The algorithm starts a batch consisting of only  at a point in time . In this case, suppose  further jobs are released at time  for some small . Since these jobs can only be started after  is finished, the schedule produced by the algorithm has a total completion time of at least . An optimal schedule would instead process all jobs in a single batch, resulting in a total completion time of . If  tends to zero, this results in a competitive ratio of at least .\nCase 2: The algorithm does not start a batch before time . In this case, suppose no further job is released and  is the only job of the whole instance. The schedule produced by the algorithm has a total completion time of at least . An optimal schedule would start processing  immediately at time , resulting in a total completion time of . Hence, also in this case, the competitive ratio is at least . \u220e\nFinally, for the total flow time, we can obtain a lower bound of . The construction is very similar to the last proof, but instead of using \nas the border between the two cases, this time we use .\nThere are no deterministic online algorithms to minimize the total flow time in a PFFB with competitive ratio less than .\nAs in the proof of Theorem 3.2  ###reference_theorem2###, consider a PFFB instance with , ,  and a fixed batch size . Again, we distinguish two cases, dependent on the start time of the first batch.\nCase 1: The algorithm starts a batch consisting of only  at a point in time . In this case, suppose  further jobs are released at time  for some small . Since these jobs can only be started after  is finished, the schedule produced by the algorithm has a total flow time of at least . An optimal schedule would instead process all jobs in a single batch, resulting in a total flow time of . If  tends to zero, this results in a competitive ratio of at least .\nCase 2: The algorithm does not start a batch before time . In this case, suppose no further job is released and  is the only job of the whole instance. The schedule produced by the algorithm has a total flow time of at least , while an optimal schedule could have started processing  immediately at time , resulting in a total flow time of . Hence, also in this case, the competitive ratio is at least . \u220e"
        },
        {
            "section_id": "4",
            "parent_section_id": null,
            "section_name": "Optimality of Permutation Schedules",
            "text": "In a permutation schedule the order of the jobs is the same on all stages of the flexible flow shop. This means there exists a permutation  of the job indices such that , for all . Since the processing times only depend on the stage and no preemption is possible, clearly the same then also holds for starting times instead of completion times.\nNote that this definition is not dependent on the specific machine where a job is scheduled.\nIf there exists an optimal schedule which is a permutation schedule with a certain ordering  of the jobs, we say that permutation schedules are optimal. A job ordering  which gives rise to an optimal permutation schedule is then called an optimal job ordering.\nFinally, an ordering  of the jobs is called an earliest release date ordering, if .\nUsing the techniques in the proofs of Lemma 2 and Theorem 3 from (Hertrich et al., 2020  ###reference_b12###), we obtain the following theorem. For the interested reader, details of the proof are available in the appendix.\nFor a PFFB with objective function , , , or , permutation schedules are optimal. Moreover, any earliest release date order is an optimal ordering of the jobs.\nFrom now on, we assume that jobs are indexed in earliest release date order and restrict our attention to permutation schedules where the job order is given by the indices. We therefore drop the notation of . It remains to decide, for each stage, how the job set should be divided into batches on the individual machines and when to process these batches. In other words, every time a machine becomes idle and at least one job is available for processing, we have to decide how long to wait for the arrival of more jobs before starting the next batch. Waiting for additional jobs incurs the cost of delaying the already available jobs."
        },
        {
            "section_id": "5",
            "parent_section_id": null,
            "section_name": "Lower Bounds for the Completion Times at each Stage",
            "text": "When analyzing approximation or online algorithms, one typically compares the quality of the solution produced by the algorithm with the optimal offline solution. However, for many problems, including PFFBs, it is difficult to make a precise statement about the quality of such an optimal solution in the offline scenario. In these cases, a common approach is to use a lower bound for comparison instead. Therefore, in the first part of this section we develop a lower bound  for the completion time  of each job  at each stage . No feasible permutation schedule with job order given by the indices can yield smaller completion times.\nIn the second part of this section, we show how this lower bound can be interpreted as a solution of a proportionate flexible flow shop problem without batching machines.\nFinally, we conclude the section by comparing our bound to another one given by Sung et al. (2000  ###reference_b23###)."
        },
        {
            "section_id": "5.1",
            "parent_section_id": "5",
            "section_name": "Recursive formula for the lower bounds",
            "text": "We start by observing two properties that hold for the completion times of any permutation schedule with job order .\nFirstly, since a job needs to finish stage  before it can be started at stage , we have\nfor all  and .\nSecondly, for a stage index  and a job index , consider the two jobs  and . Suppose there exists a point in time  at which both jobs are simultaneously processed at stage . Due to the fixed job permutation, this would imply that all the  jobs , , ,  would be processed at stage  at this time . However, this contradicts the batch capacity restriction  of the  machines. Hence, such a point in time  cannot exist and we may conclude\nfor all  and all .\nNow we construct the desired lower bound via recursion, using the right-hand sides of the two properties above.\nAs starting values, we define\n\nfor all  and\n\nfor  and . Then, we define\nClearly, by inductive application of the two properties (1  ###reference_###) and (2  ###reference_###), the values  defined this way are a lower bound for the completion times of a permutation schedule for a PFFB, as stated in the following lemma.\nAny feasible permutation schedule with job order  satisfies  for all  and .\nBefore we proceed to the next part, we give an example to show that the lower bound cannot always be achieved by a feasible schedule. Hence, it is not tight in general.\nConsider a PFFB instance without release dates, consisting of three stages with one machine each and two jobs (i.e., , , ). Processing times and batch capacities at each stage are given by  and . The only batching decision to make is whether to batch both jobs together at stage  or not. The two corresponding permutation schedules are illustrated in Fig. 3  ###reference_###. For ease of notation, we identify each stage  with its single associated machine . In both cases we have . However, recursively applying (3  ###reference_###) yields , illustrated in the third part of Fig. 3  ###reference_###."
        },
        {
            "section_id": "5.2",
            "parent_section_id": "5",
            "section_name": "The lower bounds as completion times of a proportionate flexible flow shop",
            "text": "Given an instance of PFFB, consider the following instance of a proportionate flexible flow shop (PFF) problem: at each stage, instead of  parallel batching machines with maximum batch size , there are  parallel machines with maximum batch size .\nIn other words, any batching machine with batch size  at stage  is replaced by  identical parallel machines without batching. All other data of the instance remain the same.\nConsidering the original PFFB instance, we call the instance of PFF constructed this way the corresponding instance without batching.\nThe main difference between the PFFB instance and its corresponding instance without batching is that the  machines in the instance without batching can start jobs independently from one another, whereas in the PFFB instance, jobs in the same batch have to be started at the same time.\nSo the corresponding instance without batching allows for  independent starts, while the PFFB setting only allows for  many.\nClearly, any feasible schedule for the PFFB instance implies a feasible schedule in the corresponding instance without batching, by keeping all start and finish times the same and only splitting up batches across machines such that one job runs on each machine.\nThe reverse does not work. Indeed, considering again Example 2  ###reference_mple2###, we can see that the third part of Fig. 3  ###reference_### shows a solution to the corresponding instance without batching which cannot be transformed into a solution for the PFFB instance.\nThe next theorem shows that an optimal schedule for the PFF instance is determined by the values , , , from (3  ###reference_###).\nConsider a PFFB instance with a regular objective function for which permutation schedules are optimal. Then the values , , , are the completion times of an optimal schedule of the corresponding PFF instance without batching.\nSince there are no batching machines involved in a PFF, there is no need to wait for the arrival of other jobs in order to achieve a fuller batch. Therefore, an optimal permutation schedule for the PFF can be achieved by starting each job  at each stage  as soon as the following two conditions are satisfied:\nThe job  has finished stage  (or has been released, if ).\nThere is a machine available for processing job  at stage  and all jobs  have already been started at that stage. Due to the fixed permutation and the number  of machines at stage , this is the case as soon as job  has finished stage  (or immediately, if ).\nPutting these conditions together, the completion time of job  at stage  in an optimal permutation schedule can be calculated recursively by\nThis is exactly the same formula as in the definition (3  ###reference_###) of the values , , .\u220e"
        },
        {
            "section_id": "5.3",
            "parent_section_id": "5",
            "section_name": "Comparison with the bound of Sung et al. (2000)",
            "text": "As mentioned in the literature review, Sung et al. (2000  ###reference_b23###) propose heuristic algorithms to schedule a PFB, that is, a PFFB with only one machine at each stage, without release dates. In order to evaluate their experiments, they provide a lower bound for the makespan. Transferred to our notation it reads as follows:\nWe show that our bound is an improvement, i.e., that  is at least as large as the bound given by (4  ###reference_###) and that for at least one instance, our bound is strictly larger.\nFix  and  as the maximizers in (4  ###reference_###). Applying the recursive definition (3  ###reference_###) with  for all  and  for all , we obtain the following four inequalities.\nSumming up these four inequalities yields that  is at least as large as the bound (4  ###reference_###) by Sung et al. (2000  ###reference_b23###). Moreover, the following example shows that  can be strictly larger than (4  ###reference_###). Consider a PFB (i.e., only one machine per stage) instance with  stages. Let  be the number of jobs and let , , , , and . One can easily check that for this instance the maximum in  is 16, which is attained either for  and  or for  and . However, for our bound it holds that\nHence,  is a strict improvement upon the bound  of Sung et al. (2000  ###reference_b23###).\nWe can compute  in time  by recursively using (3  ###reference_###). Since the computation of (4  ###reference_###) takes the same asymptotic runtime, our improvement of the bound incurs no increase in computational cost."
        },
        {
            "section_id": "6",
            "parent_section_id": null,
            "section_name": "The Never-Wait Algorithm",
            "text": "This section is devoted to establishing a simple, yet reasonably effective online scheduling rule for a PFFB. Again we focus on permutation schedules with job order . Hence, on each stage, when a machine is idle and jobs are available, the main scheduling decision is how long to wait until starting a new batch. One obvious strategy is to always immediately start a batch when jobs are present and a machine is idle. We call this strategy the Never-Wait algorithm.\nAnother strategy, in some ways the opposite to the Never-Wait algorithm, is to always wait until a full batch can be started. This strategy is called the Full-Batch algorithm.\nIn this section, we show that the Never-Wait algorithm is a 2-approximation with respect to various objective functions and, hence, 2-competitive when seen as an online algorithm. Furthermore, we show that the Full-Batch algorithm admits no constant approximation guarantee at all.\nThe Never-Wait algorithm for scheduling a PFFB is defined as follows: A batch is started at a stage whenever at least one job is available for processing at that stage and at least one machine is idle at that stage. The size of the new batch is chosen as large as possible, i.e., the minimum of the batch capacity at the stage and the number of available jobs at the stage when the batch is started.\nNote that, if at stage  several machines are idle but there are not more than  jobs available, only one machine is started. On the other hand, if there are more than  jobs available at stage , then more than one machine can be started at the same time.\nIn the following, let , , , be the completion times resulting from the Never-Wait algorithm and  be the bound defined in Section 5  ###reference_###. We also write  for the the time at which  becomes available at .\nSince the Never-Wait algorithm greedily starts as many available jobs as possible, the following property holds.\nSuppose that, for some  and some , it holds that .\nThen  and .\nNotice that  implies that  is available but not started at stage  during the complete interval . Since interval  has length  and at least one job is available during all of interval , each of the  machines starts processing exactly one batch during . Moreover, since  is already available, but not included in one of these batches, all these batches must be full batches. Hence, we obtain that at least  jobs complete stage  in the time interval . In particular, using the fixed job permutation, this implies that  and that  is completed not before time . \u220e\nNow we are ready to show that the completion times produced by the Never-Wait algorithm can be bounded from above in terms of the lower bound  of the previous section.\nFor all  and , the completion time  in the Never-Wait algorithm satisfies\nWe use a simultaneous induction on  and . Using , the following arguments settle induction start () and induction step () at the same time.\nLet  be a stage index and let  be a job index. Suppose the claim is already proven for all pairs of indices  and  with either  or . We distinguish two cases.\nCase 1:  waits for at most  time units at stage , i.e., . In particular, by Lemma 2  ###reference_ma2###, this always holds if . We obtain\nCase 2:  waits for more than  time units at stage , i.e., . By Lemma 2  ###reference_ma2###, this implies that  and that  is completed not before time . Then we conclude\nUsing this, we obtain the desired competitiveness result.\nWith respect to makespan, total completion time, maximum flow time and total flow time, the Never-Wait algorithm to schedule a PFFB is a -competitive online algorithm.\nUsing Theorem 4.1  ###reference_theorem1###, we obtain that there exists an optimal schedule  that is a permutation schedule with job order . Let  be the schedule produced by the Never-Wait algorithm. Using Theorem 6.1  ###reference_theorem1### and Lemma 1  ###reference_ma1### it follows for a fixed job index  that\nwhere the term  stems from .\nThus we have  and , which proves the desired statement. \u220e\nCorollary 1  ###reference_ollary1### and Theorem 3.3  ###reference_theorem3### imply the following corollary.\nFor the total flow time objective, there is no deterministic online algorithm which, in general, has a better competitive ratio than the Never-Wait algorithm.\nNext, we show by an example that the competitive ratio of the Never-Wait algorithm is not smaller than 2 with respect to any of the considered objectives.\nConsider the PFFB instance with only a single stage, with a fixed number  of machines, a batch capacity  to be chosen later, and processing time . For some small , suppose further there are  jobs, with release dates  for  and  for .\nThe Never-Wait algorithm schedules the first  jobs as singleton batches as soon as they arrive, filling all machines. All other jobs are not started before time , when the first machine becomes idle again. Thus, none of the  jobs , , can be finished before time . Hence, for the schedule  produced by the Never-Wait algorithm, we obtain\nIn contrast, consider the feasible schedule in which all machines remain idle until time , when the last job becomes available. At this point in time, all the  jobs are partitioned into  batches and started. For the resulting schedule  it follows that\nNow, given any , we show that  and  can be chosen such that the ratio of the objective values is at least . Without loss of generality, assume that  is an integer. If this is not the case, make  continuously smaller, until it is. Let  and .\nWe obtain\nHence, the Never-Wait algorithm does not have a competitive ratio less than 2 with respect to any of the considered objectives. Note that, while this example uses only a single stage, it can easily be extended to arbitrary many stages by using negligible processing times on all stages but the first one. Moreover, this example works for arbitrary values of , which implies that the competitive ratio of the Never-Wait algorithm cannot be better than 2, no matter how many parallel machines per stage there are.\nEven though the Never-Wait algorithm is in general not better than 2-competitive, concerning the makespan and total completion time objectives, Theorem 6.1  ###reference_theorem1### actually delivers a much stronger result than 2-competitiveness if the number of jobs is large.\nTo see this, we first show that for any , we have . Indeed, with  and , recursive application of (3  ###reference_###) yields\nwhere the last inequality follows from .\nFurthermore,  tends to infinity for .\nThus, in particular, if  tends to infinity, also  tends to infinity, which is a lower bound for the makespan.\nIn contrast, note that the difference between the makespan of the schedule produced by the Never-Wait algorithm and the optimal makespan is at most  by Theorem 6.1  ###reference_theorem1###. This difference stays constant if  tends to infinity.\nPutting these things together, we obtain that, with respect to the makespan, the competitive ratio of the Never-Wait algorithm tends to 1, if  tends to infinity.\nThe same holds for the total completion time objective, as we argue now. Note that, with the same arguments as before, the total completion time of any feasible schedule is lower bounded by\nOn the other hand, the difference between the total completion time of the schedule produced by the Never-Wait algorithm and the objective value of any optimal schedule is at most  by Theorem 6.1  ###reference_theorem1###. Thus, also for the total completion time, we obtain that the competitive ratio of the Never-Wait algorithm tends to 1, if  tends to infinity.\nHowever, a similar result cannot be achieved for our two flow time related objectives. To see this, note that Example 3  ###reference_mple3### can be kind of \u201ccopied\u201d arbitrarily often: given an instance with  jobs for which the Never-Wait algorithm achieves a competitive ratio of at least  for some , introduce  more jobs  to  with release dates , , for some large constant . Then, both, the Never-Wait algorithm and an optimal offline algorithm, process the jobs  to  in exactly the same way as they did process jobs  to , just shifted by  time steps. By the definition of flow times (in contrast to completion times), this keeps the maximum flow time constant, while the total flow time is doubled for both algorithms. Thus, with respect to these two objectives, the competitive ratio is still at least . This procedure can be repeated arbitrarily often. Hence, the competitive ratio of the Never-Wait algorithm does not tend to 1 for  with respect to flow time related objectives."
        },
        {
            "section_id": "6.1",
            "parent_section_id": "6",
            "section_name": "The Full-Batch algorithm",
            "text": "The Never-Wait algorithm can be seen as an extreme strategy, where all waiting time other than what is mandated by the scheduling constraints is avoided. Note that, for regular objective functions, it makes no sense to wait with starting a batch at stage  if a machine is available and already  jobs are waiting at stage . Thus, it can be viewed as the opposite extreme to always wait until a full batch can be started.\nThe Full-Batch algorithm for scheduling a PFFB is defined by the following rule: At each stage, use only full batches (the last batch at stage  may be less than full, if the batch capacity  is not a divisor of the total number of jobs ).\nNote that the Full-Batch algorithm is not actually an online algorithm in the strict sense, because in order to know when to start the last batch one needs to know the number of jobs in advance. This is not the case in the standard online setting. Therefore, we view the Full-Batch algorithm primarily as an offline approximation algorithm. It can also be seen as an online algorithm in a relaxed online setting, where the scheduler receives the information that no more jobs are coming when the last job is released.\nThere exists no  such that the Full-Batch algorithm is an -approximation for minimizing the makespan in a PFFB.\nThe statement already holds for usual PFBs, i.e. PFFBs where at each stage there is only one machine. Therefore, in the following, we assume  for all stages , . For ease of notation, we identify each stage  with its single associated machine .\nWithout loss of generality let  be integer. Construct a PFB instance without release dates as follows. Set , , ,  and  for .\nLet  be the schedule produced by the Full-Batch algorithm. Fig. 4  ###reference_### illustrates  on the first four machines for the case . An odd machine waits until all jobs have been finished on the previous even machine, before it processes all of them in a single batch. This way, we obtain , where the first term stems from the  odd machines and the second term from the  even machines.\nIn contrast, let  be the schedule where all batches consist of a single job only. On the first machine, each job is started two time steps after the previous job, i.e.,  is started at time . On all remaining machines, jobs can be started immediately upon arrival, since no processing time is larger than two. Fig. 5  ###reference_### illustrates  on the first four machines for the case . We obtain\nbecause it takes  time steps until the last job is started on the first machine, and  more time steps for processing the last job on all machines.\nHence, in total, we obtain\nTherefore, the Full-Batch algorithm cannot be an -approximation for any constant .\u220e\nNote that Hertrich (2018  ###reference_b11###) shows for the case of PFBs that the example in the proof of Theorem 6.2  ###reference_theorem2### is no longer valid if either the number of jobs  or the number of stages  is fixed and no longer depends on . In these cases, the Full-Batch algorithm becomes a constant factor approximation. Analyzing the proofs of Hertrich (2018  ###reference_b11###), one can see that these results carry over to PFFBs."
        },
        {
            "section_id": "7",
            "parent_section_id": null,
            "section_name": "Optimal Online Algorithm for Two Stages",
            "text": "We have seen that the competitive ratio of the Never-Wait algorithm is  with respect to all four objective functions considered in this paper. Comparing with the lower bounds of Section 3  ###reference_###, this is best possible for the total flow time objective. However, for the other three objectives, there is a gap between the lower bound of the golden ratio  and the upper bound of . In this section, we close this gap in the special case of  for makespan and total completion time by presenting a specialized -competitive algorithm for this case. This extends the result of Zhang et al. (2003  ###reference_b27###), who provide a -competitive algorithm for makespan minimization with , i.e., on identical, parallel batching machines.\nLet . This is the latest possible time at which the first batch must be started at the second stage if we want that a job released at time zero is completed at time , which is the minimal completion time of such a job multiplied with . The idea of the following algorithm is to schedule  in a way such that as many jobs as possible have completed  at time , while the machines of  stay idle until time  and are scheduled according to the Never-Wait algorithm afterwards.\nFor a 2-stage PFFB the -Switch algorithm is defined as follows. Let the set  of starting instants consist of those points in time , for which  for some integer , i.e.,\nAt stage , jobs are started only at starting instants. At each starting instant, as many jobs are started as possible, i.e., the minimum of  and the number of available jobs. The machines of  stay idle until time  and are scheduled according to the Never-Wait algorithm afterwards.\nNext, we prove three lemmas that help to show -competitiveness. In the following, let  and , , be the completion times produced by the -Switch algorithm and let , , , be the lower bounds of Section 5  ###reference_###.\nFor all , it holds that .\nWe use induction on .\nFix a job index . Note that  is started at the starting instant . Let  be the previous starting instant. First, suppose that , i.e.,  is the first starting instant after . Note, in particular, that since  jobs can be started at each starting instant, this is always the case if .\nIn this case, we directly obtain .\nOtherwise, if , then  was already released at starting instant , but has not been started at this time. Hence,  and exactly  other jobs must have been started at . This implies  and, hence,\nFor all  with , it holds that .\nWe use induction on . Suppose first that  is started at stage  exactly at time . Note that this is always the case if , as stage  is idle before time  and thus up to  jobs can be started at time  (recall that it is assumed that  is finished at  before time ). We obtain\nOn the other hand, consider the case in which  is started at stage  later than time . This can only happen if all machines of  continuously process full batches between time  and time . In particular, this implies  and . Hence,\nFor all , it holds .\nIf , then the claim for this index  follows by Lemma 4  ###reference_ma4###. If , then  is already scheduled according to the Never-Wait algorithm when  arrives. Hence, the claim can be proven analogously to Theorem 6.1  ###reference_theorem1###, making use of Lemma 3  ###reference_ma3###.\u220e\nNow we are ready to prove -competitiveness of the -Switch algorithm.\nFor a two-stage PFFB, the -Switch algorithm is -competitive with respect to the two objective functions  and .\nConsider a job , . We distinguish two cases:\nCase 1: . Using Lemma 3  ###reference_ma3###, it follows that . Since  must be a starting instant, we even obtain . Now Lemma 4  ###reference_ma4### yields\nCase 2: . Then it follows that . Using Lemma 5  ###reference_ma5###, we obtain\nHaving proven  for all , the -competitiveness follows for  and .\u220e\nTheorem 7.1  ###reference_theorem1### in combination with Theorems 3.1  ###reference_theorem1### and 3.2  ###reference_theorem2### implies the following corollary.\nFor PFFBs with  stages and the makespan or total completion time objective, there is no deterministic online algorithm which, in general, has a better competitive ratio than the -Switch algorithm."
        },
        {
            "section_id": "8",
            "parent_section_id": null,
            "section_name": "Conclusion",
            "text": "In this paper, we consider proportionate flexible flow shops with batching machines (PFFBs). We put a special focus on the online version of the problem, which is highly relevant for applications in the production of modern, individualized medicaments.\nTo the best of our knowledge, the online version has not been studied before, not even in the special case of proportionate (non-flexible) flow shops with batching machines (PFBs).\nWe describe and analyze two algorithms: the very general Never-Wait algorithm and the more specialized t-Switch algorithm.\nThe Never-Wait algorithm works for an arbitrary number of stages and machines. What is more, its description is relatively simple and therefore it is easy to implement in practice.\nWe show that, despite its simplicity, the Never-Wait algorithm is 2-competitive for minimizing the makespan, total completion time, maximum flow time, and total flow time.\nFurthermore, we show that for the total flow time objective, no deterministic online algorithm can, in general, do better than the Never-Wait algorithm.\nNote that the total flow time, which is equivalent with the average flow time by dividing by the constant number of jobs, is particularly important for our application: it measures the average time patients have to wait for their medicament after production is ordered. Obviously, a low average waiting time is necessary for patients to benefit from the medicine as quickly as possible.\nInterestingly, studying a particular industrial instance, Ackermann et al. (2020  ###reference_b1###) have also done some initial work to confirm that the theoretical usefulness of the Never-Wait algorithm is also coherent with its practical behaviour.\nThe t-Switch algorithm is specialized for PFFBs with only two stages and the makespan or total completion time objective. For these versions of the online problem, the t-Switch algorithm is a -competitive algorithm, with\n, the golden ratio.\nBy using and extending lower bounds known from the literature,\nwe show that no deterministic online algorithm to minimize the makespan or total completion time in PFFBs with two stages can, in general, be better than the t-Switch algorithm.\nBoth results are based on the observation that for all objectives we consider, there exists an optimal permutation schedule with start times of jobs ordered by a non-decreasing release date ordering on all stages. We show this as an extension to the theorem proved by Hertrich et al. (2020  ###reference_b12###).\nNotice that for the offline version, our results imply that the Never-Wait algorithm is a 2-approximation algorithm for PFFBs to minimize the makespan, total completion time, maximum flow time or total flow time. This is interesting as so far, for PFFBs with arbitrarily many stages, no exact polynomial algorithm has been found even in the case where all stages consist of only one machine (see, e.g., Hertrich et al. (2020  ###reference_b12###)).\nAs this is the first study of online PFFBs, it is natural that some open questions remain. Most importantly, there remains a gap between the competitiveness of the Never-Wait algorithm and the lower bound of competitiveness in the case of three or more stages for makespan and total completion time, and even in the case of two stages, for the maximum flow time.\nOf course, it would be desirable to close this gap, either by proving a larger lower bound of competitiveness or by finding a better algorithm than the Never-Wait algorithm. As we have shown in Example 3  ###reference_mple3###, the Never-Wait algorithm itself cannot be better than 2-competitive in general.\nOne way to improve the Never-Wait algorithm could be to better forecast what happens on the later stages of the PFFB. Observe that, despite the online situation, we can forecast job arrivals on later stages once the jobs become available at the first stage. Indeed, at any time step , the full schedule (and thus arrival forecast) at each stage can be computed for all jobs which become available before . Thus, for the later stages in the PFFB, the Never-Wait algorithm might be improved by using this additional knowledge of future job arrivals. Note that in the practical study mentioned above, such an improvement has been successfully attempted for a specific problem instance (see Ackermann et al. (2020  ###reference_b1###)).\nIn addition to closing these gaps, for the total completion time and total flow time objectives, it might be possible to achieve better competitive ratios for special cases where a certain minimum number of machines per stage is guaranteed. Observe that the lower bound constructions in Section 3  ###reference_### (Theorems 3.2  ###reference_theorem2### and 3.3  ###reference_theorem3###) only use a single machine. It might be the case that the same lower bounds do no longer hold if each stage contains several parallel machines. Possibly, better competitive ratios dependent on  could be established. Cao et al. (2011  ###reference_b5###) provide a result of this kind for parallel machines (only one stage) with unbounded batch capacity. For the makespan and maximum flow time objectives, however, the lower bounds by Zhang et al. (2003  ###reference_b27###) and Jiao et al. (2014  ###reference_b13###) involve arbitrarily many parallel machines. Hence, for these objectives, it is not possible to achieve better competitive ratios for high values of .\nAnother open question concerns different objective functions. We have shown that in a schedule computed by the Never-Wait algorithm the finishing time of a job  is at most twice the least possible finishing time of  in any permutation schedule ordered by release dates. Unfortunately, for most traditional scheduling objectives beyond those studied in this paper, permutation schedules ordered by release dates are not, in general, optimal (see, e.g., Hertrich et al. (2020  ###reference_b12###, Example 4)).\nStill, the Never-Wait strategy may help with these objective functions, if jobs are prioritized differently. For example, instead of scheduling jobs in order of their release dates, each time a machine is started in the Never-Wait algorithm, one may instead pick the available jobs with the largest weight, if the objective involves job weights.\nIt is, at the moment, unclear whether such an algorithm may be competitive and, if yes, what its competitiveness bound would be.\nOn the other hand, in the online scenario, it may be valid to restrict the study of other objectives to the case where jobs are ordered by their release dates on all stages.\nIn other words, instead of searching for an optimal schedule amongst all possible schedules, we search for an optimal schedule amongst all permutation schedules with jobs ordered by release dates.\nEspecially in the pharmacological application we consider, such a first-in-first-out approach may be mandated due to ethical and fairness considerations.\nFor this type of restricted problem, the Never-Wait algorithm may well prove to be competitive for many objectives beyond the ones considered in this paper, as long as these objectives are regular. For example, using the same arguments as before, the Never-Wait algorithm is 2-competitive w.r.t. the weighted total completion time / flow time. Indeed, as for the non-weighted versions, the factor 2 from Theorem 6.1  ###reference_theorem1### can be moved in front of the sum objectives to immediately see 2-competitiveness."
        }
    ],
    "appendix": [],
    "tables": {
        "1": {
            "table_html": "<figure class=\"ltx_table\" id=\"S1.T1\">\n<table class=\"ltx_tabular ltx_centering ltx_align_middle\" id=\"S1.T1.28\">\n<tbody class=\"ltx_tbody\">\n<tr class=\"ltx_tr\" id=\"S1.T1.28.29.1\">\n<td class=\"ltx_td ltx_align_center ltx_border_tt\" id=\"S1.T1.28.29.1.1\">\n<span class=\"ltx_inline-block\" id=\"S1.T1.28.29.1.1.1\">\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.1.1.1\">objective</span>\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.1.1.2\">function</span>\n</span>\n</td>\n<td class=\"ltx_td ltx_align_center ltx_border_tt\" id=\"S1.T1.28.29.1.2\">\n<span class=\"ltx_inline-block\" id=\"S1.T1.28.29.1.2.1\">\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.2.1.1\">number</span>\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.2.1.2\">of stages</span>\n</span>\n</td>\n<td class=\"ltx_td ltx_align_center ltx_border_tt\" id=\"S1.T1.28.29.1.3\">\n<span class=\"ltx_inline-block\" id=\"S1.T1.28.29.1.3.1\">\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.3.1.1\">lower</span>\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.3.1.2\">bound</span>\n</span>\n</td>\n<td class=\"ltx_td ltx_align_center ltx_border_tt\" id=\"S1.T1.28.29.1.4\">\n<span class=\"ltx_inline-block\" id=\"S1.T1.28.29.1.4.1\">\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.4.1.1\">upper</span>\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.4.1.2\">bound</span>\n</span>\n</td>\n<td class=\"ltx_td ltx_align_center ltx_border_tt\" id=\"S1.T1.28.29.1.5\">\n<span class=\"ltx_inline-block\" id=\"S1.T1.28.29.1.5.1\">\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.5.1.1\">reference</span>\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.5.1.2\">lower bound</span>\n</span>\n</td>\n<td class=\"ltx_td ltx_align_center ltx_border_tt\" id=\"S1.T1.28.29.1.6\">\n<span class=\"ltx_inline-block\" id=\"S1.T1.28.29.1.6.1\">\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.6.1.1\">reference</span>\n<span class=\"ltx_p\" id=\"S1.T1.28.29.1.6.1.2\">upper bound</span>\n</span>\n</td>\n</tr>\n<tr class=\"ltx_tr\" id=\"S1.T1.4.4\">\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.1.1.1\" rowspan=\"3\"><span class=\"ltx_text\" id=\"S1.T1.1.1.1.1\"></span></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.2.2.2\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.3.3.3\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.4.4.4\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.4.4.5\"><cite class=\"ltx_cite ltx_citemacro_citet\">Zhang et\u00a0al. (<a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#bib.bib27\" title=\"\">2003</a>)</cite></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.4.4.6\"><cite class=\"ltx_cite ltx_citemacro_citet\">Zhang et\u00a0al. (<a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#bib.bib27\" title=\"\">2003</a>)</cite></td>\n</tr>\n<tr class=\"ltx_tr\" id=\"S1.T1.7.7\">\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.5.5.1\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.6.6.2\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.7.7.3\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.7.7.4\"><cite class=\"ltx_cite ltx_citemacro_citet\">Zhang et\u00a0al. (<a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#bib.bib27\" title=\"\">2003</a>)</cite></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.7.7.5\"><span class=\"ltx_text ltx_font_bold\" id=\"S1.T1.7.7.5.1\">Theorem <a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#S7.Thmtheorem1\" title=\"Theorem 7.1 \u2023 7 Optimal Online Algorithm for Two Stages \u2023 Online Algorithms to Schedule a Proportionate Flexible Flow Shop of Batching Machines\"><span class=\"ltx_text ltx_ref_tag\">7.1</span></a></span></td>\n</tr>\n<tr class=\"ltx_tr\" id=\"S1.T1.10.10\">\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.8.8.1\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.9.9.2\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.10.10.3\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.10.10.4\"><cite class=\"ltx_cite ltx_citemacro_citet\">Zhang et\u00a0al. (<a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#bib.bib27\" title=\"\">2003</a>)</cite></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.10.10.5\"><span class=\"ltx_text ltx_font_bold\" id=\"S1.T1.10.10.5.1\">Corollary <a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#Thmcorollary1\" title=\"Corollary 1 \u2023 6 The Never-Wait Algorithm \u2023 Online Algorithms to Schedule a Proportionate Flexible Flow Shop of Batching Machines\"><span class=\"ltx_text ltx_ref_tag\">1</span></a></span></td>\n</tr>\n<tr class=\"ltx_tr\" id=\"S1.T1.14.14\">\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.11.11.1\" rowspan=\"2\"><span class=\"ltx_text\" id=\"S1.T1.11.11.1.1\"></span></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.12.12.2\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.13.13.3\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.14.14.4\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.14.14.5\"><span class=\"ltx_text ltx_font_bold\" id=\"S1.T1.14.14.5.1\">Theorem <a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#S3.Thmtheorem2\" title=\"Theorem 3.2 \u2023 3 Lower Bounds for the Competitive Ratio \u2023 Online Algorithms to Schedule a Proportionate Flexible Flow Shop of Batching Machines\"><span class=\"ltx_text ltx_ref_tag\">3.2</span></a></span></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.14.14.6\"><span class=\"ltx_text ltx_font_bold\" id=\"S1.T1.14.14.6.1\">Theorem <a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#S7.Thmtheorem1\" title=\"Theorem 7.1 \u2023 7 Optimal Online Algorithm for Two Stages \u2023 Online Algorithms to Schedule a Proportionate Flexible Flow Shop of Batching Machines\"><span class=\"ltx_text ltx_ref_tag\">7.1</span></a></span></td>\n</tr>\n<tr class=\"ltx_tr\" id=\"S1.T1.17.17\">\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.15.15.1\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.16.16.2\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.17.17.3\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.17.17.4\"><span class=\"ltx_text ltx_font_bold\" id=\"S1.T1.17.17.4.1\">Theorem <a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#S3.Thmtheorem2\" title=\"Theorem 3.2 \u2023 3 Lower Bounds for the Competitive Ratio \u2023 Online Algorithms to Schedule a Proportionate Flexible Flow Shop of Batching Machines\"><span class=\"ltx_text ltx_ref_tag\">3.2</span></a></span></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.17.17.5\"><span class=\"ltx_text ltx_font_bold\" id=\"S1.T1.17.17.5.1\">Corollary <a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#Thmcorollary1\" title=\"Corollary 1 \u2023 6 The Never-Wait Algorithm \u2023 Online Algorithms to Schedule a Proportionate Flexible Flow Shop of Batching Machines\"><span class=\"ltx_text ltx_ref_tag\">1</span></a></span></td>\n</tr>\n<tr class=\"ltx_tr\" id=\"S1.T1.21.21\">\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.18.18.1\" rowspan=\"2\"><span class=\"ltx_text\" id=\"S1.T1.18.18.1.1\"></span></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.19.19.2\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.20.20.3\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.21.21.4\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.21.21.5\"><cite class=\"ltx_cite ltx_citemacro_citet\">Jiao et\u00a0al. (<a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#bib.bib13\" title=\"\">2014</a>)</cite></td>\n<td class=\"ltx_td ltx_align_center ltx_border_t\" id=\"S1.T1.21.21.6\"><cite class=\"ltx_cite ltx_citemacro_citet\">Jiao et\u00a0al. (<a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#bib.bib13\" title=\"\">2014</a>)</cite></td>\n</tr>\n<tr class=\"ltx_tr\" id=\"S1.T1.24.24\">\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.22.22.1\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.23.23.2\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.24.24.3\"></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.24.24.4\"><cite class=\"ltx_cite ltx_citemacro_citet\">Jiao et\u00a0al. (<a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#bib.bib13\" title=\"\">2014</a>)</cite></td>\n<td class=\"ltx_td ltx_align_center\" id=\"S1.T1.24.24.5\"><span class=\"ltx_text ltx_font_bold\" id=\"S1.T1.24.24.5.1\">Corollary <a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#Thmcorollary1\" title=\"Corollary 1 \u2023 6 The Never-Wait Algorithm \u2023 Online Algorithms to Schedule a Proportionate Flexible Flow Shop of Batching Machines\"><span class=\"ltx_text ltx_ref_tag\">1</span></a></span></td>\n</tr>\n<tr class=\"ltx_tr\" id=\"S1.T1.28.28\">\n<td class=\"ltx_td ltx_align_center ltx_border_bb ltx_border_t\" id=\"S1.T1.25.25.1\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_bb ltx_border_t\" id=\"S1.T1.26.26.2\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_bb ltx_border_t\" id=\"S1.T1.27.27.3\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_bb ltx_border_t\" id=\"S1.T1.28.28.4\"></td>\n<td class=\"ltx_td ltx_align_center ltx_border_bb ltx_border_t\" id=\"S1.T1.28.28.5\"><span class=\"ltx_text ltx_font_bold\" id=\"S1.T1.28.28.5.1\">Theorem <a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#S3.Thmtheorem3\" title=\"Theorem 3.3 \u2023 3 Lower Bounds for the Competitive Ratio \u2023 Online Algorithms to Schedule a Proportionate Flexible Flow Shop of Batching Machines\"><span class=\"ltx_text ltx_ref_tag\">3.3</span></a></span></td>\n<td class=\"ltx_td ltx_align_center ltx_border_bb ltx_border_t\" id=\"S1.T1.28.28.6\"><span class=\"ltx_text ltx_font_bold\" id=\"S1.T1.28.28.6.1\">Corollary <a class=\"ltx_ref\" href=\"https://arxiv.org/html/2005.03552v2#Thmcorollary1\" title=\"Corollary 1 \u2023 6 The Never-Wait Algorithm \u2023 Online Algorithms to Schedule a Proportionate Flexible Flow Shop of Batching Machines\"><span class=\"ltx_text ltx_ref_tag\">1</span></a></span></td>\n</tr>\n</tbody>\n</table>\n<figcaption class=\"ltx_caption ltx_centering\"><span class=\"ltx_tag ltx_tag_table\">Table 1: </span>Known bounds for the competitive ratio of deterministic online algorithms to schedule a PFFB. Note that lower bounds for a single stage () carry over to arbitrary many stages by introducing stages with negligible processing times.</figcaption>\n</figure>",
            "capture": "Table 1: Known bounds for the competitive ratio of deterministic online algorithms to schedule a PFFB. Note that lower bounds for a single stage () carry over to arbitrary many stages by introducing stages with negligible processing times."
        }
    },
    "image_paths": {},
    "validation": true,
    "references": [],
    "url": "http://arxiv.org/html/2005.03552v2"
}