Cycles and permutations in robotic cells

MATHEMATICAL

PERGAMON

COMPUTER MODELLING

Mathematical and Computer Modelling 34 (2001) 565-591 www.elsevier.nl/locate/mcm

Cycles and Permutations in Robotic Cells

N. BRAUNER* AND G. Finked Laboratory Leibniz-IMAG, 46, Avenue Felix Viallet

38031 Grenoble Cedex, F’rance

(Received March 1999; revised and accepted November- 2000)

Abstract-we consider a robotic cell, consisting of a flow-shop in which the machines are served by a single central robot. We concentrate on the case where only one part type is produced and analyze the validity of the so-called one-cycle conjecture by Sethi, Sriskandarajah, Sorger, Blasewica and Kubiak. This conjecture claims that the repetition of the best one-unit production cycle will yield the maximum throughput rate in the set of all possible cyclic robot moves.

We present a new algebraic approach, unifying the former rather tedious proofs for the known results on pyramidal one-cycles and two- and three-machine cells. In this framework, counterexamples will be constructed, showing that the conjecture is not valid for four and more machines.

We first present examples for a general four-machine cell, for which the two-unit production cycles dominate the one-unit cycles. Then we consider in particular the so-called regular cells, where all machines are equidistant, since the one-cycle conjecture has originally been formulated for this case. Here, we prove that for four-machine cells, two-unit production cycles are still dominated by one-unit production cycles. Then we describe a counterexample with a three-unit production cycle, thus, settling completely the one-cycle conjecture. @ 2001 Elsevier Science Ltd. All rights reserved.

Keywords-Scheduling, Flow-shop, Material handling system, Cyclic production.

1. INTRODUCTION

A robotic cell is a flow-shop with a circular layout for the machines and a central bidirectional

robot as the material handling system (Figure 1). Such a machining center was first introduced

in [l], where a three-machine robotic cell is described for machining castings for truck differential

assemblies. The generic layout for this industrial application is given in Figure 1 and has been

studied in [2]. The objective is to channel the parts through the system and to maximize the

production rate.

Figure 1. Robotic cell with m = 3 mschines.

*University Pierre Mend&s France, IUT2, Department GEA. tuniversity Joseph Fourier. This research wss partly supported by the project Polonium No. 98029 and also by the European Network DONET (Contract Number EBB TMHX-CT980202) which financed a postdoctoral position for the first author at the University of Liege (Belgium).

0895-7177/01/$ - see front matter @ 2001 Elsevier Science Ltd. All rights reserved. PII: SO8957177(01)00084-X

Typeset by .%&QX

566 N. BRAUNER AND G. FINKE

It is known that the robotic flow-shop scheduling problem becomes NP-hard if there are m 2 3

machines and two or more different part types (see [3]). It remains the interesting case of the

rn-machine robotic cell in which one wants to produce a single batch of identical parts. Then

the problem reduces to finding the optimal strategy for the robot moves in order to obtain the

maximal throughput rate for this unique part. The production process is assumed to be periodic,

i.e., a certain number, k, of the parts is produced in a repetitive pattern. The production in the

form of k-cycles greatly facilitates the programming of the robot arm. The interesting conjecture

by Sethi, Sriskandarajah, Sorger, Blazewicz and Kubiak [2], the so-called one-cycle conjecture,

claims that the maximum throughput rate is obtained by repeating a particular cycle, producing

each time a single part.

This conjecture has been open since 1989. The authors of the original paper [2] could only

demonstrate its validity for the two-machine case, believing that, with their description of the

robot moves, the three-machine case is combinatorially intractable. Since then, it has been shown

that the conjecture holds for three machines and two cycles, i.e., the two-cycle production is not

better than the one-cycle production [3]. The proof is, in fact, a computer demonstration: the

problem is formulated as an integer linear program with 103 constraints, 81 continuous and 30

binary variables, and solved by a commercial LP code. Then, in [4], a lengthy demonstration is

given for the validity of the conjecture for the general m = 3 machine case, using state graphs

with 2’n+1 vertices and a case by case proof. We have provided a simpler, more concise proof

in [5], based on a state graph with 2m vertices. But state graphs become much more complicated

for nz 1 4 machines, so that an analysis of the conjecture seems to be no longer possible by such

an approach.

The purpose of this paper is three-fold.

(1) We shall give a more detailed discussion on the cycle times with the notion of so-called

active schedules (Section 3). There, the robot always executes the next operation as early

as possible, which is very desirable in an industrial context.

(2) We shall present a completely new approach to the one-cycle conjecture (Section 4). A

purely algebraic formulation of the problem is given, which provides a unifying access

to all known results, i.e., to the dominance of pyramidal one-cycles within the set of all

one-cycles (Section 5) and to very short and elegant proofs for the two- and three-machine

caSes (Section 6).

(3) Finally, we will be able to settle completely the one-cycle conjecture (Section 7). With the

help of this new approach, we shall construct counterexamples, showing that the conjecture

is no longer valid for m 2 4 machines. These examples have not been published so far, but

have been known since November 1997 and have been distributed to the community in the

form of an internal note [6]. We shall distinguish two cases: the regular cells, for which

the machines are equidistant, and the general nonregular cells. It will be demonstrated

that the cycle dominance is different for these two configurations. Emphasis will be on

regular cells, since the one-cycle conjecture has been posed in [2] for this case.

2. GENERIC REPRESENTATIONS OF k-CYCLES

The m machines of a robotic cell are denoted by Ml, Mz, . . . , M,,, and we add two auxiliary

machines, MC, for the input station IN and Mm+1 for the output station OUT. The robotic cell

represents a flow-shop with the central robot as the material handling system. The raw material

for the parts to be produced is available in unlimited quantity at MO. The central robot can

handle a single unit at a time. A part is picked up at M-J and transferred in succession to

Ml,A/rz,. . . , Mm, where it is machined in this order until it finally reaches the output station

h’lm+l. At Mm+l, the finished parts can be stored in unlimited amounts. We focus on the

classical case as in [2], where the machines Ml, h/l, . . . , Mm are without buffer facility. In this

case, the robot has to be empty whenever it wants to pick up a part at i& (h = 0, 1, . . . , m). In

Robotic Cells 567

order to travel from machine Mh to machine A&, the robot takes the shortest path on the circle. Consequently, the distances are additive.

We consider cyclic robot moves for the production process of the parts and define a k-cycle as a production cycle of exactly k parts. It can be described as a sequence of robot moves where exactly k parts enter the system at MO, k parts leave the system at A&+1, and each time the robot executes the k-cycle, the system returns to the same state, i.e., the same machines are loaded, the same machines are empty, and the robot returns to the starting position. Having restored the same cell configuration permits repetition of the same moves of the k-cycle. Note that we are not, for each repetition of the k-cycle, assuming the same remaining processing times for the parts on the machines. We only return to the same part-machine incidence vector.

To describe k-cycles, we use the concept of activities [4]. The activity Ah (h = 0, 1, . . . , m)

consists of the following sequence.

l The idle robot takes a part from A&. l The robot travels with this part from A& to Mh+l. l The robot loads this part onto Mh+l.

Note that many sequences are not feasible, e.g., (. . . Ao, Ao, . . . ) since the robot carries a part to Ml which is occupied. In [4], the authors characterize the k-cycles as follows.

DEFINITION 1. A k-cycle Ck is a sequence of activities in which each activity occurs exactly k times and between two consecutive (in a cyclic sense) occurrences of Ah (h = 1,2,. . . , m),

there is exactly one occurrence of Ah-1 and between two consecutive occurrences of A,, (h = 0, 1,

2 ,***, m - l), there is exactly one occurrence of Ah+l.

we represent a k-cycle Ck as in Figure 2. The vertical axis represents the cell. The graph indicates the position of-the robot in the cell during the cycle. The dashed lines are the empty robot moves and the plain lines are the loaded robot moves. Let mh(Ck) (h = 0, 1, . . . m)

represent the number of times the robot travels between iUh and Mh+l in both directions while executing the k-cycle Ck and let ?&(Ck) (h = 1,2,. . . , m) represent the number of occurrences of the pattern Ah_lAh in Ck. For the one-cycle 7r, in Figure 2, we have, for instance, mz(r) = 4 and UT(T) = 1, and all other Us = 0. The quantities mh(Ck) and Uh(Ck) will play an important role for further analysis in Section 4. In the following, we shall present their basic properties.

robotic cell A

Figure 2. The pyramid81 permutation A = (Ao, Aq, As, A7, As, Aa, Aa, Al).


PROPERTY 1. The following equations are valid, for a k-cycle Ck:

mo(Ck) = 25, (1) m,(Crc) = 2k (2) ml(Ck) = 4k - 2w(Ck), (3)

m,_l(Ck) = 4k - %n(G& (4)

PROOF OF EQUATION (1). During the execution of the k-cycle Ck, k parts enter the system

in MO. The robot does not make any useless movement. Therefore, it arrives k times in MO in

order to take a part and it leaves k times MO loaded with the part to enter the system (execution

of Ao). Thus, the robot covers exactly 2k times the path between MO and Ml: k times empty

from Mr to MO and k times loaded from MO to Ml. The proof for equation (2) is similar. 1

PROOF OF EQUATION (3). During the execution of Ck, the robot travels from Ms towards Mi

only in order to execute AI or to continue to MO to execute Ao. Just before each of the k exe-

cutions of Ao, the robot necessarily comes from Mz. Moreover, to execute Al, the robot comes

from MO if it has just executed A0 (us times) and from Mz otherwise (k - ul(Ck) times).

Therefore, just before (k - ul(ck)) executions of Al, the robot travels from Mz to Mi. Thus,

the robot travels from MZ to Ml exactly (2k - Ul(ck)) times. At each execution of the cycle,

the robot goes from Ml to Ms the same number of times it goes from Ms to Mi. Therefore, the

robot also travels exactly (2k - Ul(ck)) times from Ml to Ms. Hence, mi(Ck) = 4k - 2ul(ck). The proof for equation (4) is similar. I

In [2], the authors proved that a one-cycle is completely defined by a permutation of the

activities. Hence, there are exactly m! one-cycles. We may normalize, without loss of gen-

erality, the sequences rr of activities and start with activity Ao. The one-cycles are then of

the form 7r = (Ao, Ai,, Ai2,. . . , Ai,,,), where (ir, iz, . . . , im) is a permutation of {1,2,. . . , m}.

Let us consider the one-cycles x belonging to the set of pyramidal permutations. We call

71. = (Ao, Ai,, Ai,, . . . , Ai,,,) pyramidal if there is a p such that 1 5 ii < .. . < i, = In and

m > i,+i > . . . > i, 2 1 (Figure 2).

Let x = (Ao, Ai,, Ai,, . . . , Ai,,,) be a pyramidal permutation with i, = m. The activity Ai, is

uphill if j 5 p and downhill otherwise. One can observe that during the execution of n, the robot

travels between Mh and Mh+l twice if Ah is uphill (?nh(r) = 2) and four times if Ah is downhill

(mh (X) = 4). By definition, Ao and A, are always uphill and all other activities can be either

uphill or downhill. A partition of the activities between downhill and uphill sets uniquely defines

a pyramidal permutation. Therefore, there exists a one-to-one correspondence between the set

of pyramidal permutations and the set of (m - 1)-vectors in numbers two and four. Hence, there

are Zm-l different pyramidal permutations. Let us set II. = 2”+’ - 1 and denote the pyramidal

permutations by nj (j = 0, 1, . . . , p).

A schedule is called active if the robot always executes the next operation as soon as possible.

For active schedules, all execution times for the robot are uniquely determined once the sequence

of activities is given. The only possible waiting period can occur at a machine where the idle

robot is ready to carry out the next activity, but encounters a part still being processed on this

machine. In the following sections, we shall assume that all the schedules are active.

3. CYCLE TIMES

Consider an instance I of an m-machine robotic cell. The processing times of the parts are

given by ph on machine Mh (h = 1,2, . . . ,m). Let bh be the travel time of the robot (idle or

loaded) from Mh to Mh+i or from Mh+l to Mh (h = 0, 1, . . . , m). Let EL be the time to load a

part onto Mh from the robot (h = 1,2, . . . , m + 1) and let ez be the time to unload a part from

Robotic Cells 569

Mh onto the robot (h = 0, 1, . . . , m). The trip of the idle robot from Mh to Mh’ (h # h’) takes

max(h,h’)-1

c Sj time units. j=min(h,h’)

We shall use the abbreviation l

Ah = 26/z-1 + 2Sh + ~2-i + cf, + c;t + &+i.

Suppose that all data of an instance are integers. Then, starting the process at time zero, all subsequent time events in the cell remain integer valued, since the only algebraic operation is to determine the maximum of the travel time for the robot to get to a machine and the processing time left for the part on that machine. If the data of a given instance are rational numbers, we may multiply by the least common multiple and again have an integer argument. Therefore, we may restrict our proofs to integer numbers.

Normalize, without restriction, the k-cycle Ck and start with one of the activities AO. The k-cycle Ck defines a unique initial part-machine incidence vector which indicates the loaded and the empty machines at the beginning of the cycle. The initial remaining processing time vector

of Ck, denoted by P’(Ck), indicates the remaining processing time of the parts on the loaded machines at the beginning of the initial cycle. The hth component of P’(Ck) is equal to -1 if machine Mh is empty at the beginning of the cycle and is in the range [0, ph] otherwise. Note that we are not including the initial phase into the cycle. For instance, one’ might want to start with the empty system and load first the machines as required by the cycle, which is then repeated.

For a given instance, we represent the k-cycles as in Figure 3: the horizontal axis represents the time. The graph indicates the robot position in the cell according to the time. The dashed lines are the empty robot moves and the plain lines are the loaded robot moves, the loading/unloading processes or the waiting times of the robot at the machines. Let us illustrate the concept with an example.

M4

M3

M2

Ml

MO

+ robotic cell

I

‘: :., :A :

_I 1 ‘.._ 1 3 ‘... :..’ I..._.. , . ‘-_,

0. ‘.., ..: ‘. .:’ ,.: ‘... I 1

‘1 ‘.., ,.! “., 1 f

‘.. / I,

.I) ‘., ,.: ._

--/

:., ..-I . . . . ,:’

:: 2

. : : : : . : , : ,: . , , : , , , , , , , . 012 5 10 15 20 25

15

Figure 3. C = (AoAzAlA3) for the instance 10 with PO(C) = (-1,3, -1).

EXAMPLE 1. In a three-machine cell, consider the onecycle C = (AoA2A1A3). Let IO be the following instance:

bh=l, (h=0,1,2,3), 1 c; = ch+i = 0, (h = 0, i,2, 3)7

~1 = 6, p2 = 9, p3 = 6.

At the beginning of the cycle C = (AoA~AIA~), machine Ms is loaded and machines Mi and Ms are empty. The vector p(C) = (-1,3, -1) is a possible initial remaining processing time vector for C.

570 N. BRAUNERAND G. FINKE

At time 9, in Figure 3, the robot is at machine Ms and is waiting one time unit for the part to be ready in order to execute activity As. One can observe that the cycle does not repeat identically. We shall study this phenomenon.

Let Ti(Ck) denote the duration of the ith execution of the k-cycle Ck. We shall decompose Ti(Ck) into three components: the total travel time, the loading/unloading time, and the total waiting time. They are described as follows.

l TT(Ck) is the total travel time of the robot, i.e;,

TT(ck) = 2 mh(Ck)&.

h=O

Note that the travel time is constant for each repetition of the cycle. Hence, it is not indexed by i.

l TL(k) is the total time for the robot to load and unload parts, i.e.,

TL(k) =k&+km!jr;. h=O h=l

TL(k) is constant, and hence, it is independent of i. Moreover, it depends only on k and not on the form of the cycle Ck.

l T$,(Ck) is the total waiting time of the robot at the machines during the ith execution of Ck.

Let us describe the waiting times, &(Ck), during the ith execution of Ck in greater detail. The robot arrives k times at machine Mh (h = 1,2 . . . m) in order to carry out activity Ah. Consequently, we can identify k waiting times at machine Mh during each repetition of ck. These times wk(Ck) are written as a column vector of length k where the jth component refers to the jth occurrence of Ah in the cycle. We set Wi(Ck) = (wi(ck), ?.Ua(Ck) . . .u&(Ck)) defining a matrix of size k x m that is called the ith-waiting time matrix of Ck. One can observe that the initial waiting time matrix w’(Ck) is uniquely defined by the initial remaining processing time vector P’(Ck), since it depends only on the initialization of the cycle.

The total waiting time ?&(Ck) is the sum of all km elements in the matrix wi(Ck). The ith cycle time, Ti(Ck), VerifieS

!i!+(ck) = TT(ck) + TL(k) + T&(ck).

We say that the k-cycle ck is stationary for the initial remaining processing time vector P’(Ck) and for the instance 1 if the sequence w*(Ck) is stationary, i.e., all waiting times wj(Ck) are equal for all j 2 i, i large enough. The k-cycle Ck is stable if it is stationary for every vector P’(ck), leading to the same waiting times. If Ck is stable, we call the constant T(Ck) = Ti(Ck) for i large enough, the cycle time of Ck. If Ck is not stable, then one has the following property for integer instances, and hence, for integer waiting times. This proposition can be extended to rational numbers.

PROPERTY 2. For any instance and for any initial remaining processing time vector, the sequence wi(Ck) is cyclic, i.e., there exists an integer 1 such that, for i large enough, ?.@‘(Ck) = &(Ck).

PROOF. Let Ck be a k-cycle. Consider an integer instance and an initial integer remaining processing time vector PO(&). They define uniquely the initial integer waiting time matrix wl(Ck). One can observe that Wi(Ck) only depends on the instance and on the vector wiml(Ck). Therefore, if there exists an index i and an integer 1 verifying &+“(Ck) = Wi(Ck), then the values are repeating: &‘+‘(Ck) = wi+’ (Ck), wif’+2(Ck) = wi+2(Ck), etc.

But, each component of wi(Ck) is an integer number ranging from 0 to ph. Hence, there is a finite number of possible waiting time matrices wi(Ck). This implies that there exists an 1 and an index i such that &+‘(Ck) = &(Ck).

Robotic Cells 571

Denote by Z(Ch) the smallest periodicity of the k-cycle Ck, i.e., 1 = Z(Ck) is the smallest positive

integer verifying wi+l(Ck) = wi(Ck) for i large enough. It is easy to see that every integer 1’

verifying wi+l’(Ck) = wi(Ck), for i large enough, is a multiple of Z(Ck). By definition of 1 = Z(Ck),

all values wi+q (Q = 1,2.. . 1) are different.

We have seen that wi(Ck) is cyclic, which implies that also Ti(Ck) is cyclic.

EXAMPLE 1. (CONTINUED). For the instance la, one has Z+(C) = 12 and AL = 0. Since

k = 1, w;(C) has only one component. One gets w’(C) = (l,l, 1) which gives T&,(C) = 3 and

P(C) = 15. Similarly, one has w2(C) = (2,0,0) which gives T&(C) = 2 and T2(C) = 14. For

the cycle C, the instance Is, and the initial remaining processing time vector PO(C) = (-1,3, - 1))

one has for all i > 0,

w2i+1(c) = (l,l, 1) and w2i(C) = (2,0,0).

Hence, the cycle C = (AoA~AIA~) is not stationary for P’(Ck) = (-1,3, -1) and for the

instance la: the execution times of the cycle are alternately 14 and 15. One may verify that C

is stationary for the instance 10 and for the initial remaining processing time vector PO(C) =

(-1,2.5, -1) with a cycle execution time of 14.5 (which is also the average of 14 and 15).

Note that the one-cycle C = (A A A A ) 0 2 1 3 is not a pyramidal permutation. It seems that a

characteristic property of pyramidal permutations is their stability.

PROPERTY 3. The one-cycles belonging to the pyramidal permutations are stable for m 5 3

machine cells.

The proofs for m = 2 and m = 3 can be deduced from the literature [2,3]. We shall provide an

explicit proof in Appendix A. But for m 2 4, the stability property is an open problem.

We know that the smallest periodicity depends on P’(Ck), since we have for Example 1 the

values 1 = 1 and 1 = 2 for P” = (-1,2.5, -1) and (- 1,3, - 1 ), respectively. The interesting

question is whether the average value of T$,(Ck) during a full period

is depending on PO. This average does not depend on P” for Example 1, but the problem

remains open in general. We, therefore, define the long run average cycle time T(Ck) for the

most favorable vector P’(C’k), i.e.,

T(G) = TdGc) + TL(~) + Tw(G),

with

Tw(Ck) = inf PO(G)

(; &+qG,) >

q=l

where i is large enough and 1 is the length of a period.

We call T(Ck) the cycle time and T(Ck)/k the cycle length. The throughput mte is defined

by k/T(Ck). Thus, the p-cycle C, is optimal if it maximizes the throughput rate or equivalently

minimizes the cycle length T(Ck)/k over the set of all possible k-cycles (k = 1,2,3, . . . ). The

approach in [7] of the cycle time stability is, in a way, different. A strict periodicity of all cycle

times is obtained by shifting the time events of the robot in form of a critical path. This requires

a specific initial vector PO.

DEFINITION 2. Let S and S’ be two sets of cycles. S dominates S’ if, for any instance, one has

the following property: for every k’-cycle Ck’ of S’, there exists a k-cycle Ck in S verifying

T(Cd < T(Ck’) k -7

.

572 N. BFIAUNER AND G. FINKE

In [8], the authors proved that the pyramidal permutations dominate the one-cycles. They give an algorithm of complexity 0(m3) for the determination of the best pyramidal permutation. The interest in one-cycles is motivated by the following conjecture.

ONECYCLE CONJECTURE. (See [21.) The set of one-cycles dominates the set of all production cycles. It meam t&d the maximum throughput rate over all sequences of finite cyclic robot

moves is obtained by executing a one-cycle.

As mentioned earlier, the conjecture is valid for m = 2 [2] and m = 3 [4,5]. In the first very

tedious proof, using state graphs, the authors, in [4], assume that & = 6 (h = 0,. . . , m) and e’ = 61 h h+l = 0 (h = 0,. . . , m). It is mentioned in the conclusion that the demonstration can be generalized to a system with nonzero and equal loading and unloading times for the machines and arbitrary values for the travel time 6h. The interest of this conjecture is, of course, that it reduces the complexity of the problem. Indeed, it suffices to find the best one-cycle among the m! admissible one-cycles. We shall provide a new access to the conjecture based on systems of inequalities rather than graphs. For the remaining sections, we need the subsequent optimality criterion.

LEMMA 1. The cycJe time T(Ck) of an arbitrary k-cycle ck satisfies

T(Ck) 2 k(A/t + md, h= 1,2 ,..., m.

PROOF. This inequality has been introduced for k = 1 in [8].

t

robotic cell

Figure 4. Illustration of Lemma 1

During the execution of c,+, the robot must carry out k times the activities Ah_l and A,,. These cannot be executed if machine Mh is processing a part. Let tj (j = 1,. . , , k + 1) be the jth instant in the cycle when Mh starts to process a part. We assume that the cycle begins at time tl

and ends at time tk+l. Between tj and tj+l (j = 1,2,. . . , k), at least the following sequential events have to occur (Figure 4).

l Machine Mh processes the part [duration: ph time units]. l The part is transferred to Mh+l [e;t + 6h + E;+~ time units].

Robotic Cells 573

0 The robot retUrnS to machine &i&r [&_I + & time units]. 0 A new part iS transferred onto machine k?h [cK_r + b&r + E; time units].

Therefore, tj+r - tj > ph + Ah. Since Ti(ck) 2 tk+r - tr for any i, one has, for each execution,

Ti(ck) 2 k(Ah +Ph). Hence, one dS0 g&S T(Ck) > k(Ah +ph). I

The following criterion is an immediate consequence of Lemma 1.

PROPERTY 4. OPTIMALITY CRITERION. If, for a given instance I, the cycle time of a k-cycle ck SatiSfieS

T(Ck) = k (Ah + ph) , for some h (1 2 h 5 m),

then ck is optimal.

4. PYRAMIDAL COVER

In the following sections, we want to settle completely the one-cycle conjecture for robotic cells with additive distances. We introduce the pyramidal covers which allow us to rapidly prove the one-cycle conjecture for two- and three-machine cells. This approach also permits us to obtain new results: for the regular case (& = 6 and EY = cf = E for all i), the one-cycle conjecture is valid for m = 4 and k = 2, i.e., two-cycles are dominated by one-cycles. We shall consider each of the three components of the cycle time.

DEFINITION 3. Consider a k-cycle ck. Let CC be a vector of nonnegative coefficients (Zj) for the

pyramidal permutations nj, with C& xj = k.

a x is a pyramidal cover of ck if

T(‘%) 2

l x is a pyramidal travel-cover of ck if

TT(ck) 2

eXjT(rj). j=O

LXjTT (Tj).

j=O

(5)

(6)

0 x is a pyramidal waiting-time cover of ck if

(7)

We want to establish dominance relations between a cycle ck and the pyramidal permutai tions rj. For this purpose, in inequality (5), we consider linear convex combinations C(zi/k) T(rj) that dominate the cycle Iength T(Ck)/k of ck. In inequalities (6) and (7), we cover separately the travel and waiting times. The hope is to determine a pyramidal permutation dominating ck among those that have both smaller total travel time and smaller total waiting time.

For the loading times TL(k) and TL( 1) = C;I”=o E; + CF=‘;’ EL, one has the following equality for each vector 2 verifying Cr=, xj = k:

m m+l Y

TL(k)=kCEg+kz&=Czj h=O h=l j=O

This implies the following.

574 N. BRAIJNER AND G. FINKE

LEMMA 2. If x is a pyramidal travel-cover and a pyramidal waiting-time cover of Ck, then x is a pyramidal cover of Ck.

LEMMA 3. Let ck be a k-cycle. If there exists a pyramidd cover of ck, then ck is dominated by the set of pyramidal permutations.

PROOF. Consider an instance I and a pyramidal cover x of ck. Let 7rh be the pyramidal permutation with minimal cycle time for the instance I. One has

T(m) 5 T bj) , for any j E {O,l, . . . p}.

Hence, inequality (5) leads to

T(Ck) 2 kxjT(q) = kT(n/J. j=O

Therefore, for any instance, there exists a pyramidal permutation dominating ck, since T(nh) 5

T(Ck)/k. I

Set mk(Ck) = min(mh(ck), 4k) and define the following system:

&jm,&)=m~(&), h=o,l,..., m,

(8)

j=O,l,..., ,&

where the vector x is the variable. Note that &!&(ck) contains redundant equations. Indeed, we know from equation (1) that mh(ck) = ms(ck) = 2k and mc(Xj) = 2 for every pyramidal permutation rj e Therefore, equation (8) is always true for h = 0 and also for h = m (equation (2)). Since ml (ck) = mi (ck) = 4k - 2211 (Ck) (Property l), eqUatiOU (8) for h = 1 is equivalent to

‘Ul(ck) = kxjul (rj) *

j=O

We know that m,_i(Ck) = m&_i(ck) = 4k - 2um(ck) (Property 1). This implies that equation (8) for h = m - 1 leads to

‘h(ck) = 2 xj%n (nj) .

j=O

LEMMA 4. Every solution of &!?n( ck) is a pyramidal travel-cover.

PROOF. Let z be a solution of &(ck). One obtains inequality (6) from equation (8) as follows. Multiply each of the equations (8) by the corresponding distance & and replace mi(ck) with

mh(Ck) to get

mh(Ck)b 2 kxjmh (rj) hr (h=O,l,..., m). j=O

Adding these inequalities, one obtains

TT(ck) = 2 mh(Ck)Jh ?I 2 2 xjmh (nj) 8h. h=O h=O j=O

Robotic Cells 575

This implies

j=O h=O j=O

The following proposition presents conditions for the dominance of pyramidal permutations.

PROPOSITION 1. Let ck be a k-cycle. Any of the following conditions is sufficient to guarantee

that Ck is dominated by the pyramidal permutations.

(Cl) There exists a pyramidal permutation Kj which verifies T(Ck) 2 kT(rj).

(C2) There exists a pyramidal permutation rj verifying T(rj) = Ah f ph for some h E

{1,2...m}.

(C3) There exists a solution z of S, (ck) which is a pyramidaJ cover.

(C4) There exists a solution z of S,(Ck) which is a pyramidal waiting-time cover.

PROOF. For (Cl), Proposition 1 is true by definition. Property 4 indicates that if (C2) is valid,

then the pyramidal permutation Xj is optimal. For (C3), Proposition 1 is an immediate conse-

quence of Lemma 3 and for (C4), it can be easily deduced from Lemmas 2 and 4. I

The following theorem is the main result of this paper. With the help of this theorem, we can

now settle completely the one-cycle conjecture, obtaining its validity range and also counterex-

amples of minimal size.

THEOREM 1. The one-cycJe conjecture is valid for two- and three-machine robotic cells. The

conjecture is wrong for general m-machine cells, m L 4. In fact, for each m 2 4, there are cases

where two-cycles dominate all one-cycles. For regular cells and m = 4, the one-cycles dominate

the two-cycles, but there are instances where three-cycles dominate one-cycles.

We will prove this theorem in the following sections using Proposition 1.

5. DOMINANCE OF PYRAMIDAL PERMUTATIONS

In [8], the authors proved that the set of pyramidal permutations dominates the set of one-

cycles. They transform a nonpyramidal permutation successively to a pyramidal permutation

and prove that each transformation does not increase the cycle time. With our definition of cycle

times, stability is a requirement for the validity of the proof. We shall establish the dominance

of pyramidal permutations using the algebraic approach of Section 4.

Let C be a one-cycle. The system Z&(C) is given by

kXjmh(Kj)=mL(C), h=O,l,..., m, j=O

2 Xj = 1, j=O

Xj L 0, j=0,1,..., I_L.

Remember that there exists a one-to-one correspondence between the set of pyramidal permu-

tations and the set of vectors V = (‘Uh)h=1,2,..., m_~ such that wh E {2,4}. Indeed, in a pyramidal permutation K, activity Ah is uphill if and only if rnh(r) = 2 and Ah is downhill if and only if

rnh(r) = 4 (A0 and A, are always uphill). Therefore, for every one-cycle C, one can define the

unique pyramidal permutation rc as follows:

mL(c) = min(mh(c), 4) = mh (?r”) , forallh=O,l,..., m.

Let us call & the pyramidal permutation associated with C.


PROPOSITION 2. Suppose that the pyramidal permutations are stable for the m-machine robotic

cell. Then the pyramidal permutations dominate the one-cycles.

PROOF. Suppose that all pyramidal permutations are stable. We want to prove, by means of

Proposition 1, that

T(C) > T (rc), (9)

for every one-cycle C. Note that the pyramidal permutation xc associated with C also defines

the solution X of Sm(C) given by

xj = 1, if7rj =?Tc and Xj =O, otherwise.

We shall proceed by induction on the number m of machines in the robotic cell. For m = 2,

all one-cycles are pyramidal permutations, and hence, inequality (9) is satisfied. Suppose that

inequality (9) is verified for any one-cycle in a system composed of Q machines where q < m. We

have to prove that inequality (9) remains valid for a system composed of m machines.

Consider an m-machine robotic cell and a one-cycle C. There are several particular cases for

which we can show directly the validity of inequality (9) without using the induction hypothesis.

In fact, the hypothesis will only be required for the last case considered (Case 3).

robotic cell -_I 7rC.

, AI ,

Figure 5. A1 is downhill in 8 and the robot waits at Ml.

Returning to Figure 4, we get the following possibilities for ?I~.

Let Al be downhill and the robot waits at Mi (Figure 5). Since 8 is assumed to be

stable, T(&) is equal to the time that elapses between two consecutive instants at which

Ml starts to process a part. Thus, T(rc) = pl + hi and 8 is optimal (Condition (C2)

of Proposition 1 is satisfied).

Let A,_1 be downhill and the robot waits at Mm, but does not wait at Mm-j. One shows

similarly that T(nC) = p, f Am.

Let Ah-1 and Ah be downhill for some h (h = 2,3,. . . , m - 1) and the robot waits at &,

but not at Mh-1. Similarly, one has T(8) = ph -I Ah,

We shall consider the remaining cases. If there is no waiting time at the machines while execut-

ing &, then one has Tw(rc) = 0 <_ Tw (C). Hence, inequality (7) is verified. Therefore, (C4)

is true. Consider now the case where the robot has to wait at a machine. Let T be the smallest

index such that the robot has to wait at MT while executing xc.

Robotic Cells 577

CASE 1. r=m.

In this case, A,,+1 is uphill in @, and hence, xc contains the subsequence A,_lA,. Since

there is no waiting time at machines MI, Mz, . . . , h&,-l, one has Tw(nC) = p,. Since A,_1 is uphill in &, one has m,_i(&) = 2 = mm-i(C). Property 1 indicates that m,_i(C) =

4 - 2um(C) which implies that urn(C) = 1. Hence, C contains the sequence A,_ IA, and

TwfC) 1 P, = Z’w(8). Therefore, (C4) is true.

CASE 2. 1 < 7 < m and A, is downhill, and hence, A,_1 is uphill in 8.

Since A,_1 is uphill in nc (i.e., m7_i(C) = mT_i(8) = 2), one can observe that (Figure 6)

l in C, every activity between A,_1 and A, has an index superior to r;

l in 8, all the activities with index superior to 7 are between A,_1 and A,.

Hence, one has (see Figure 6)

h=O h=O

Each execution time of C, and hence, also the average T(C), exceeds T(&):

r-2 r-2

T(C) 2 p, + 26, + 26,-l + c:_~ + ci + c: + E:+~ + c mh(c)dh + c (E; + c;+~) 2 T (8) , h=O h=O

since, by construction, one has mh(C) 2 mh(&) for h = 0, 1, . . . , m. Hence, Condition (C3) is

robotic cell C

-4-1/r pr --..

tobotic cell ,c:

Figure 6. Illustration of Case 2.

CASE 3. 1 5 r c m and A, is uphill in #.

Only for this case, the induction hypothesis has to be used. An illustration of the induction

and of the following notation is given in Figure 7.

Since A, is uphill in ?yc, one has ml(C) = m7(?rc) = 2. Hence, during the execution of the

cycle C, the robot goes only once from M, to A&+1, namely, when it is executing A,. Let t, be

578 N. BFLAUNER AND G. FINKE

4robotic cell ,

Mo I

‘..,

b T’ 4 +l’ .*r $7

Figure 7. Illustration of the induction step if A,_1 is downhill in ?yc.

the moment of the beginning of activity A, in C, when the robot unloads M,. The robot also goes only once from M,+l to M,. Denote t: the moment of the passage of the robot at M, when coming from M7+1. Similarly, define the times s, and .sk for the cycle #.

Define

T = T(C) - (t: - tr) and T* = T (8) - (s; - s,) .

We now calculate the value of T* and a lower bound for T in order to prove that T* 5 T. Since the robot waits at M, in xc, the duration between the end of A,_1 and the beginning of A, is p,. Hence, if A,_1 is downhill in 7rc (in this case, one has T # l), then T* = pT + S-1 + E;_~ + E:

and T 2 p, +26,-l + E:__~ + EL (see Figure 7). If A,_1 is uphill in & (see Figure 8), then, since there is no waiting time at Mh (h < T), one has

r-l 7-l

T* = p, + c 7% (r”) &, + c (6; + F;+l) .

h=O h=O

Robotic Cells 579

Figure 8. Illustration of the induction step if A,_1 is uphill in xc,

Since A,_1 and A, are uphill in &, one has m7-r(C) =m,_r(nC) = 2 and m,(C) = m7(rc) = 2.

In this case, there is no activity between A,__1 and A, in C. Hence, C contains the sequence

A,_ 1A,. Therefore, one has

7-l 7-l

T L P, + ~m/z(Wh + c (6: + c;+l) 2 T*, h=O h=O

Since mh(C) 2 mh(rC). We proved that T* < T. Let S, be the reduced robotic cell, consisting of the m - r machines

W, W+1, * * *, ~m+l, where M, corresponds to the input station. Consider the reduced cycles,

x,” and C,, of # and C in S,. By construction, rr,” * 1s the pyramidal permutation associated

with C, in S,. For the robotic cell S,, we retain the previous data c;1, EL, 6h, ph except E: which

is redefined by E:($) = T. We can now apply the induction hypothesis to obtain

Finally, we have to relate the cycle times T(C7) and T(r$) to T(C) and T(8). Suppose C and C, are executed in parallel, starting with the loaded robot at M,. The robot carries out

the same activities and travels empty from M,+r to M, at the same moment. The cycle C terminates after T time units with the robot again at the initial position. In the cell S,, the

580 N. BFWJNER AND G. FINKE

robot can load without delay a part in T time units. Consequently, the cycles terminate at the

same time, i.e., T(G) = T(C). Using, in addition, the fact that T 2 T*, one shows similarly

that T($) 2 T(#). Therefore, T(rc) < T(C) and Condition (C3) of Proposition 1 is true.

6. TWO-MACHINE AND THREE-MACHINE CELLS

We shall now give the new proofs for two- and three-machine cells, based on our

approach, in particular, Proposition 1.

algebraic

PROPOSITION 3. The one-cycle conjecture is valid for two-machine and three-machine cells.

We include the proof for m = 2 in order to expose the new algebraic framework. Then we

present a new short proof for the important three-machine case, replacing the, lengthy proofs

of [4,5].

6.1. Two-Machine Case

In a two-machine cell, the two pyramidal permutations together with their cycle time compo-

nents [2] are given in Table 1.

Table 1.

j =j TT (rj) TW (nj)

0 AOAIAS &6h Pl SP2 h=O

2 - 261 -262 - 1 AoAz-41 2 c 6,, +261

max(O,pl -6; p2-260-261-EE;-4)

E$,

h=O

PROOF OF PROPOSITION 3. We show that Conditions (C2) or (C4) of Proposition 1 are true for

any k-cycle Ck. Let us consider two cases.

CASE 1. Tw(m) > 0.

In this case, the cycle time of ~1 satisfies T(?rl) = max(pr + Ar,pz + AZ). Hence, (C2) is true.

CASE 2. Tw(nl) = 0.

In this case, one has Tw(ro) = pl +pz and Tw(r~) = 0. For any k-cycle Ck, the system &(ck)

is given by

UI(ck) = 20,

U2(ck) = ZO,

~0 + ZI = k,

Xj L 0, forj =O,l.

Since ml(Ck) = 4k - 2Ui(ck) = m,+r(Ck) = 4k - 2212(&) (Proposition l), one ha ul(ck) =

uz(ck). The vector X = (Ul(ck), k - ul(ck)) Solves s2(ck) and satisfies

&xjTw(rj) = ‘Ul(Ck)Pl + UZ(Ck)PZ I TW(Ck)*

j=O

Hence, (C4) is true.

Robotic Cells 581

Table 2.

2 AoAzAsAl Al+As p3+mMO,pl-2261-A3-p3,

+261 P2 - 260 -261-E; -c:,

AI+& max(O,pl - 261 - 262 - As,

3 Ao&&AI +261 + 262 p2 - 261 - 262 - Al - A3 + A2,

p3 - 261 - 262 - Al)

6.2. Three-Machine Case

In this section, uh stands for uh(Ck), for all h E {1,2,3}. The four pyramidal permutations

are given in Table 2 [3].

The system Ss (Ck) is given by

‘1L1=20+21, (10)

243 = 20 +22, (11)

k = 20 + 21+ 22 + 23, (12)

Xj 2 09 for j = 0, 1,2,3.

PROOF OF PROPOSITION 3. Consider an instance and a k-cycle Ck. We shall present two cases.

CASE 1. One of the following conditions is verified:

Tw(nl) = ~3 - A1 - 262,

Tw(r2) = ~1 - 261- A37

Tw(n3) # 0.

In this case, Condition (C2) is always true. Suppose, for instance, that Tw(ni) = pa - Ar - 262.

Then one has T(?ri) = ps + As.

CASE 2. For all other cases, the following conditions are verified:

Tw(n1) =pi +w:,

Tw(n2) = P3 + w;,

Tw(r3) = 0,

where wi = max(O,ps - 262 - 26s - clj - E:) and wz = max(O,pz - 260 - 261 - E: - e:). We will

prove that Condition (C4) is true. Let x be the following vector:

2s = mjn(2lh),

21 = ui - mp(uh),

x2 = u3 - mjn(2Lh),

x3 = k - u1 - u3 + mp(uh).

One can easily verify that x is a vector verifying equations (IO)-(12) of ss(ck). It is also obvious

that xc, xi, and 22 have nonnegative values. We only have to prove that x3 is nonnegative and

that inequality (7) is verified, i.e.,

TW (ck) 2 20 (Pl + m + ?‘3) + 21 (pl + ‘w:) + 22 (p3 + w2”) . (13)

582 N. BFLWNER AND G. FINKE

In ck, consider the sequence AoAl, if it exists, and the last occurrence of Al preceding this

sequence (in a cyclic sense). According to Definition 1, there is exactly one occurrence of A2 between the two occurrences of AI:

Al--A2 . . . AoAl.

Let us analyze the possibilities for the sequence Al-As to the left. One can neither have A0 nor AZ, since each of these activities can occur only once between two occurrences of A,; Al is impossible by construction. Thus, each of the ~1 occurrences of AoAl is preceded by an

occurrence of AlA or by an occurrence of AlAsA (where the two Al are consecutive) which

implies that

UI I ~2 + IAlA3A21. (14)

In the same way, one can prove that each sequence of AzA3 is followed by either AlA or by

AlAoA2 (where the two A2 are consecutive). Hence, one has

~3 5 ~2 + IAlAoAzl . (15)

Adding those two inequalities, one obtains

ul + 213 I 2u2 + (AI&A~I + lAlAoA21,

Activity A2 appears k times in ck. Therefore, (AlA + IAlA3A21 $ lAlAoA2l 5 k, and hence,

~1 + us < up + k. If minh(uh) = us, then the preceding inequality indicates that 23 > 0.

Moreover, if minh(uh) equals ~1 or ug, then, since uh 5 k, one also has x3 2 0.

We shall now prove that inequality (13) is verified. For this, we need the following inequality:

w;+w; Ip2. (16)

One always has wi 5 pz and 20; 5 pz. Hence, if wi = 0 or w 2” = 0, then inequality (16) is true.

Otherwise, one has w: > 0 and w$ > 0. If pp > Ai + As - A2 + 2&i + 262, then Tw(7r3) > 0,

which is in contradiction to the hypothesis that Tw(7rs) = 0. Hence, one has

P2 5 260 + 261 + 262 + 26s + E; + E: + E; + ct.

Adding p2 to both sides of the inequality yields inequality (16),

w; + w; = p2 - 260 - 261 - 62; - : E +p2-2~2-2~3--~--EfiIp2.

t

robotic cell

Mel ; ’ 6

*t

Figure 9. The sequence AlA3Az.

Robotic Cells 583

One can see that the subsequence AlAsA (respectively, AlAoA2) implies a waiting time of at

least wi (respectively, wi) (Figure 9). Therefore, Tw(Ck) 2 u1p1 + 212~2 + 213~3 + (AIA~A~[w~ + IA1AoA21wg. Considering inequalities (14)-(16), one obtains inequality (13) as follows:

zo (Pl + P2 + P3) + 21 (PI + w;) + x2 (p3 + w$

=min(uh)bl+fi+p3]+[ u1 - mh (udl m + [u3 - min (a)] p3

+ [us - min (uh)] wi + [ug - min (uh)] wi

I ulpl + min (oh) p2 + u3p3

+ b2 - min (ud + (AI&AZ)] w: + [u2 - min (TAG) + IA1AoA21] W$

5 WI + min (udp2 + [u2 - min (ud]p2 + ‘113~3 + IA1A3A21 W; + lAlAoA21 W;

I 61 + ~2~2 + 213~3 + IAIA~AzI w; + IAlAoAzl w;

I Tw (Ck) *

This finishes the proof. I

7. GENERAL ROBOTIC CELLS

In this section, we disprove the one-cycle conjecture for general robotic cells with m > 4. We

shall consider separately the nonregular case (Section 7.1) and the regular case (Section 7.2). For

both cases, we construct counterexamples of minimal size, i.e., we present instances for which

k-cycles, with k the smallest possible value, are no longer dominated by the set of one-cycles.

7.1. Nonregular Cells

We know that the one-cycle conjecture is true for two- and three-machine cells. Therefore, a

counterexample to the conjecture for m = 4 and k = 2 is minimal.

PROPOSITION 4. In general robotic cells, one-cycles do not dominate twcFcycles for m 2 4.

PROOF. For an easier understanding, we first construct an example for m = 4, with machines

not equidistant and with some zero processing times. This example will then be generalized to

nonzero processing times and any number of machines m 1 4. Consider the following instance 14

(Figure 10):

m = 4, EX = Ef, = 0, for all h,

~1 = 6, P2 = IO, P3 = 9, P4 = 0,

So = 6, & = 6, 62 = 1, 63 = 1, d4 = 1.

6

/

6

/

I MO

p2 = 10

I Ml

Figure 10. The instance 14.


Let C’s = (AoA 102143423 A A A A A A A A ). For the instance 14, the two-cycle Cz dominates all 2m-1 = 8 pyramidal permutations, i.e.,

T(C2) - < T(zJ,

2 for all pyramidal permutations nj.

First consider the two-cycle CZ = (AoA~AoA~A~A~A~A~A~A~). For this representation of C’s, the unique possible initial state consists of no parts on Mi, M2, and Ms and a ready part on MA, since the processing time on M4 is 0. After one execution of C2, the exact state of the system is restored and the part on M4 is again ready. Hence, the two-cycle C2 is stationary and stable for the instance 14 and its cycle time is 82. It remains to show that T(rj) > T(C2)/2 = 41.

We have only shown stability for pyramidal permutations for m = 2 and m = 3. For the particular instance 14, it is easy to see that the pyramidal permutations are stable and’that their cycle times are given by

T(AoA1A2A3A4) = 46, T(AOA1A2A4A3) = 48,

T(AoA1A3A4A2) = 42, T(A,,AlA4AsAz) = 42,

T(AOA2A3A4A1) = 42, T(AoA2A4A3A1) = 44,

T(AOA3A4A2A1) = 44, T(AOA4A3A2A1) = 46.

In order to avoid zero processing tunes, we multiply all elements of 14 by 10 and set ps and p4 to 1, thus obtaining

m = 4, e: = ef, = 0, for all h,

PI = 60, p2 = 100, P3 =I, P4 = 1,

6. = 60, 13~ = 60, 6.2 = 10,63 = 10, 64 = 10.

For this instance, one has T(C2)/2 = 411 and the shortest cycle time for the pyrakhidal permutations is 420.

The previous counterexample to the one-cycle conjecture can be lifted to any m-machine cell (m 2 4). Consider the following instance 1,:

m, e;t = E:, = 0 , Vh,

6. = 60(m - 3), 61 = 60(m - 3), 62 = lO(m - 3), Ss = lO(m - 3), ~5, = lO(m - 3),

ifm>4, &=I, for4Ih<m-1,

pi = 60(m - 3), p2 = lOO(m - 3), Ph = 1, for 3 5 h 5 m.

Denote U, the sequence of all activities of index greater than 4 in increasing order. For instance, Us = A4AsAe. Let C’s be the two-cycle (A~A~AoA~A~I~,A~U,A~A~). For the instance I,, we shall prove that the two-cycle C2 dominates all 2”‘-l pyramidal permutations,

i.e., T(C2) - < T(rj), 2

for all pyramidal permutations zj (j = 0,l. . . p).

Let us first prove that T(C2) 2 830(m - 3). For the same reason as for m = 4, the cycle C2 is stationary and stable for the instance I,. One can see that me(&) = 4 and mr;( C’s) = 6 for 1 5 h 5 3 and mh(C2) = 4 for 4 5 h 5 m. Hence, one has

TT(C2) = c mh (Cs) bh h=O

= 4 * 60(m - 3) + 6 * 60(m - 3) + 6 * 2 * lO(m - 3) + 4 * (m - 4) + 4 * lO(m - 3)

= 760(m - 3) + 4(m - 4).

hbotic Cells 585

Moreover, the waiting time at machines Mh for 3 5 h 5 m is

ps+p4+2gph=2(m-4)+2. h=5

We also have, to consider the waiting times at machine Mi before executing A1 and at Mz before

executing AZ. The sequence A041 generates a waiting time of pi = 60(m - 3) time units. The

sequence AoAzAl does not generate any waiting time since the travel time between the end of A0 and the beginning of Al is equal to 140(m - 3) which is greater then pi. In the same way, one

can verify that the sequence Al AoAz does not generate any waiting time at Mz. In the sequence

A1U,A3U,,,A2, the travel time between the end of the execution of A1 and the arrival of the

robot at machine MZ in order to execute A:! is greater than p2 = lOO(m - 3). Therefore, this

sequence does not induce any waiting time at Mz. Moreover, TL(~) = 0, since E; = EL = 0 for

all h. Consequently, one has

T(C2) = 57T(C2) + Tw(C2) + 57L(2)

= 760(m - 3) + 4(m - 4) + 60(m - 3) + 2m - 6 + 0

= 826(m - 3) - 4

<830(m - 3).

bet us now concentrate on the pyramidal permutations and prove that T(rj) 2 420(m - 3) for

all j E {O,l,. . . , p). We shall consider two cases depending on the position of Al in rj. If A1 is

downhill, then mi(nj) = 4 and mh(rj) 2 2 for all h. Hence, one has

TT (nj) 14 * 60(m - 3) + 20(m - 3) * (6 + 1 + 1 + 1) > 420(m - 3).

Otherwise, if A1 is uphill, then nj is of the form (AoAl[. . .]Az) or of the form (AoAlAz[. . .I). In

both casesj the robot has to

l execute A0 [JO = 60(m - 3) time units];

C wait at tii before executing Ai [pi = 60(m - 3) time units];

l execute A1 [c& = 60(m - 3) time units];

l between the end of AI and the beginning of A;?, there are at least p2 = lOO(m - 3) time

units; l execute A2 [62 = lO(m -.3) time units];

l return from Ms to MO [62 + S1 + 60 = 130(m - 3) time units].

Therefore, one has

T(nj) 2 (6 + 6 + 6 + 10 + 1 + 13)lO(m - 3)

2 420(m - 3).

We proved that, for the instance I,,,, T(C2)/2 5 415(m - 3) and that T(rj) 2 42O(m - 3) for

every pyramidal permutation rj. Therefore, there is a two-cycle which is not dominated by the

pyramidal permutations.

7.2. Regular Cells

In this section, we study the regular case for which all the machines are equidistant (& = 6 for

all i) and the loading and unloading times are all equal (C = cf = c for all i). This configuration

seems reasonable in industry whenever the machines are of similar dimension. In [2], the one-cycle

conjecture was proposed for the regular case.

We know that the one-cycle conjecture is true for m = 3 in the general case. Hence, it is

also true for the regular case for two- and three-machine cells. From four machines, the results


are different. We first study the one-cycle conjecture for m = 4 and k = 2. Then we describe

an instance for which a three-cycle is strictly better than all one-cycles. This disproves the

conjecture for m = 4 and k = 3. Note that for the regular case, the time to go from machine Mi

to machine Mj is ]j - i]6 time units.

PROPOSITION 5. In a regular four-machine cell, the one-cycles dominate the two-cycles.

SKETCH OF THE PROOF. The fact that one-cycles dominate two-cycles seems to be interesting,

but we have been unable to prove this result using the state graphs of [4,5]. However, a proof

of Proposition 5 may be based on the pyramidal-cover approach. The demonstration is very

technical. For this reason, we only describe the main ideas. Detailed proof can be found in [9].

The idea is to first eliminate all simple cases. Then, for any two-cycle C’s, we propose a

solution z of the system Sd(C2) depending on the value of mQ(Cs) and we prove that z is a

waiting-time cover of Cs. We now describe the main elements of the proof. The cycle times of the pyramidal permuta-

tions, in a four-machine cell, are given in Table 3.

Table 3. Cycle times of the pyramidal permutations for m = 4.

j =j TT(rj) TW (nj 1

0 (AoAI-%-~A~) 106 Pl +P2 +P3 +p4

1 (AoAlA2A4Ad 126 Pl +p2+

max(o,pa-446-2e,p4-86-6c-pl-p2) , .

2 (AoA1b4-h) 12s Pl + p4+

ma@,pz-66-4t-p4,p3-66-4e-pl)

3 (Ao-hA4b‘b) 146 PI + max(O,pz - 86 - 4~

p3-106-6~-p1,p,-lOb-6~-p1) 4 (AoAdwLA) 126 P3 +p4+

max(O, p1 - 86 - 6t: - p3 - ~4, p3 - 46 - 2e) max(0, p1 - 106 6~, 46 - - - 5 (Ao&&A3&) 146 p3 26,

p3-46-26,p4-lO6-6~,p3+p3-86-46)

6 (AoA3&&&) 146 p4 + max(O, pl - 106 - 6e - ~4, pz - 106 - 6~ - p4,p3 - 86 - 4~)

7 (AoA4A3AA) 166 maxi(O, pi - 126 - 6~)

The loading/unloading times for any pyramidal permutation rj (j = 0,l. . .7) verify !!‘~(l)

= 10~. For the k-cycle Ck, the system Sd(Ck) is as follows:

S4(Ck) =

L

20 + Xl + 52 + 23 = Ul(Ck),

20 + 52 + X4 + Xs = 214(Clc),

X0 + X1 + X2 + X3 + X4 + X5 + 5s + X7 = I$

2Zc + 2X1 + 422 + 4X3 + 2X4 + 2X5 + 42s + 4X7 = min(VQ(Ck), dk),

Xj2>0, j=O,1...7.

The proof is decomposed into five steps that cover all possible cases.

l STEP 0. The cases for which a pyramidal permutation is trivially optimal are eliminated (for

instance, whenever the cycle time of a pyramidal permutation is equal to a lower bound).

l STEP 1. If, for a k-cycle Ck, ud(Ck) = k or ur(Ck) = k, then Condition (Cl) is true (in the

following steps, we consider that Ur(Ck) < k and IQ(Ck) < k).

l STEP 2. If the k-cycle Ck verifies ms(Ck) = 2k, then (C4) is true.

l STEP 3. If the two-cycle C2 verifies mz(C2) = 6, then (Cl) or (C2) or (C4) is true.

l STEP 4. If the two-cycle C’s verifies ms(Cs) L 8, then (C2) or (C4) is true. I

Robotic Cells 587

Thus, the one-cycle conjecture is true for k = 2. It becomes false from m = 4 and k = 3.

PROPOSITION 6. There are regular four-machine cells for which three-cycles dominate ail one-

cycles.

PROOF. Consider the following instance I:

m = 4, 6 = 10, E = 0,

Pl = 1, p2 = 100, P3 = 100, p4 = 1.

Let C3 = (A 014342010342132 A A A A A A A A A A A A A A ). For the instance I, the three-cycle C’s

dominates strictly all one-cycles, i.e.,

T(C3) - <T(r),

3 for all one-cycles 7r.

We know that [8] it is sufficient to verify this inequality for the 2m-’ = 8 pyramidal permu-

tations Tj (j = 0,l . . . 7). Their cycle times are given in Table 3. For the instance I, the best

pyramidal permutation lasts 160 time units. But the cycle time of C’s verifies T(C3) = 464.

Therefore, since T(C3)/3 = 154.66667, the three-cycle C3 dominates strictly all one-cycles. 1

8. CONCLUSION

In this article, we have settled completely the validity range of the one-cycle conjecture in

robotic cells. In Section 3, two open problems are stated: stability of the pyramidal permutations

(which has only been established formally for m = 2 and 3), and in general, for k-cycles, Ck,

independence of cycle times from the initial vector P’(Ck). Our intuition is that both statements

(conjectures) are true. It remains the challenging problem, for m 2 4, to determine the optimal

k-cycle.

APPENDIX

STABILITY OF PYRAMIDAL PERMUTATIONS

In this appendix, we consider two- and three-machine cells. We analyze the stability and derive the cycle times of the pyramidal permutations.

Remember that w;&(r) denotes the waiting time of the robot at machine A& during the ith execution of the pyramidal permutation K. In the formulas, we suppress 7r in wf( ZT) whenever there is no possible confusion. To prove the stability of the pyramidal permutation 7r, we have to show that the sequences w;(r) are constant, for i large enough, and independent of the initial remaining processing time PO.

A.l. General Properties

We first present some lemmas and properties. They will help to simplify the proofs of stability and they eliminate some trivial or general cases.

LEMMA 5. Let ui and vi be the integer sequences defined by

ui = max(O, a - vi), Vi = max(O, b - ui-l)r ‘1Lo 2 0,

where UO, a, and b are integer numbers. There exists an index io such that, for all i 2 io, the sequences ZL~ and vi are constant and verify ui + 01 = max(O, a, b).

PROOF. Replacing vi by its expression in terms of ui, one obtains

ui = max(O, a - max(O, b - ui-1))

= max(O, a + min(O, pi-1 - b)).


CASE 1. a 5 0. Since min(O, ‘ZL+1 - b) 5 0 and a 5 0, for all i, one has ui = max(O, a + min(0, IJ~__~ - b)) = 0.

CASE 2. a > 0 and a 2 b. Obviously, if ui 1 b for some i, then uj = a, for all j 2 i. Hence, if u. 2 b, then ui = a, for

all i. If uc < b, then ~1 = uc + a - b; u2 = uo + 2(a - b) . . . . Hence, the sequence increases by a - b. If a > b, then ui will exceed b for some i. Otherwise, ( i.e., a = b), ui = uo for all i.

CASE 3. a > 0 and a < b. One has Q = max(O, b + min(O, vi-1 - a)). Exchanging a and b in the previous demonstration,

one obtains vi = b for i sufficiently large.

Figure 11 summarizes the different values for ui and wi (i 1 ic), according to a and b. From this figure, it is easy to deduce that ui + vi = max(O, a, b).

\

P-

a .Ui

Vi

=b = min( b_, ug) = b - mm(b, ug)

Figure 11. Values of the sequences ui and vi.

We now consider a special pyramidal permutation: the identity, 7~ = (AoA1. . . A,).

LEMMA 6. The one-cycle identity, ?ro = (AoA1 . . . A,), is stable and its cycle time is given by

m m T (7ro) = c (26h + E;Lh + &+i) + CPh.

h=O h=l

PROOF. In ~0, all activities are uphill. Hence, mh(Q) = 2, for all h = 0, 1, . . . , m. Therefore, one has

h=O h=O

We know that

TL(~) = 2 (6; + E;) . h=O

Since Ah follows immediately Ah-1 for h = 1,2,..., m, one has W;(Q) = ph, for all h = 1,2,..., m. Hence, the waiting times W;(Q) are constant and one has

Tw (no) = &h. h=l


A.2. The Two-Machine Case

In a two machine cell, there are /J + 1 = 2”+’ = 2 pyramidal permutations: the identity, ~0 = (AoAlAz), and the downhill permutation, ?rl = (AoAzAl).

Robotic Cells 589

PROPOSITION 7. In a twemachine cell, the two pyramidal permutations are stable and their cycle times are given by

T(7rl) = c (261, + Et+&+1 h=O

PROOF. For ~0, Proposition 7 is an immediate consequence of Lemma 6. It remains to calculate the cycle time of ~1 and to prove that 7~1 is stable. One can observe that, for ~1, one has

wt; = max (0, pl - 2% - 262 - Ez - EL - &) ,

WP t = max (O,p2 - 2~53 - 261 - &j - Ei) .

Hence, wa is constant. Since w’; only depends on wb, it is also constant. Therefore, ~1 is stable. Moreover, one has

Tw(m) = w; + w: = max (09 Pl - 261 - 262 - E; - 4,P2 - 2&J - 261 - co” - 6;) .

We know that

h=O

In ~1, only A1 is downhill. Hence, one has TT(~I) = 260 + 4% + 2~52. This finishes the proof. 1

A.3. The Three-Machine Case

The cycle times of the pyramidal permutations in a three-machine cell were first calculated in [2]. Remember that Ah = 2C&,- 1 + 26h + e;l_ 1 + ef, + c; + E;+~.

~>ROPOSITION 8. In a three-machine cell, the four pyramidal permutations are stable and their cycle times are given by

T(rl) = A, + A3 + 262 + pl + max (0,~s - A, - 262 - p1,pz - 262 - 263 - E: - c:) ,

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

T(7r3) = A, + A3 + 261262

+ max(O,pl - 261 - 262 - A3,pz - 261 - 262 - A, - A3 + A2,p3 - 261 - 262 - A,),

where no = (AoAlAzAs), ?rl = (AoAlAsAz), 7r2 = (AoA~A~AI), and 7~3 = (AoAaAzAl).

PROOF. For 7ro, Proposition 8 is an immediate consequence of Lemma 6. We know that, for a pyramidal permutation T, if Ah is uphill, then mh(r) = 2 and if Ah is downhill, then mh(n) = 4. Since Z+(T) = Crzo mh(?r)&, it is easy to derive the travel time. In a thrmmachine cell, one

has TL(~> = E”,&;t + ~;+l ) for any pyramidal permutation 7r. It remains to calculate the waiting times wi(nj) for j = 1,2,3, and to prove that they are constant.

For ~1, one has

WI = Pl,

w5=max(O,pz-262-263--$--c~-w~),

wi = max (0,~ - A1 - 262 - w”;) .


These formulas can be rewritten as

Since wi, wi, and wi can be expressed independently of i, they are constant. The waiting time satisfies

Tw(n1) = Wf + w; + wj

For 7r3, one has

wf=max(0,p~-261-A3-w;-w~),

w~=max(O,p3-2Sc-26~-~Zj-.$),

w; = p3.

For the same reason as for ~1, the waiting times of ~3 are constant and we obtain

Tw(n2) = w”l + w; + 20;

For 7r3, the arguments are different since we cannot suppress simply i in the expression of wk. One has

wf=max(O,pr-26r-262-A3-w~-w~),

w~=max(O,p3-26r-263-Ar-A3+A3-w~),

w$ = max (0,~s - 261 - 263 - Ar - wi-‘) .

We shall describe, for wi, wi, and w:, a transformation which yields quantities ui and vi and an application of Lemma 5. One can write the waiting times as follows:

w”; = max (0,pr - 261 - 262 - A3 - (wb + wb)) ,

w$ + w$ = max (w$,pz - 26r- 262 - Ar - A3 + A,)

= max (0,~ - 261 - 263 - Ar - A3 + A2,p3 - 261 - 263 - Al - UJ’~-‘) .

One may verify that the waiting times can be written in the form of ui and vi with the following values:

(Y = max(O,p2 - 261 - 262 - A, - A3 + A2),

a = pr - 261 - 263 - A3 - Q, ui = wz;,

b = p3 - 2Sr - 2b2 - A, - Q, Vi=W5+WJ_Ct!.

Since ILK and vi are constant from a certain rank, wi and wi + w& also become constant. Since w”; becomes constant and wi only depends on wi, the waiting time wi also becomes constant. Since wi + wi and wi become constant for i large enough, wi also becomes constant. Therefore, the pyramidal permutation 7r3 is stable. Lemma 5 allows us to find the expression of Tw(~3):

Tw(?~3)=w~+w5+w9=u~+vi+a=m~(O,a,b)+~

= max(O,pr - 261 - 262 - A3,pz - 261 - 2S2 - A, - A3 + A2,p3 - 261 - 262 - A,).


Robotic Cells 591

REFERENCES

1. CR. Asfahl, Robots and Manufacturing Automation, John Wiley & Sons, New York, (1985). 2. S.P. Sethi, C. Sriskandarajah, G. Sorger, J. Blazewicz and W. Kubiak, Sequencing of parts and robot moves

in a robotic cell, Znt. J. FMS 4, 331-358 (1992). 3. N.G. Hall, H. Kamoun and C. Sriskandarajah, Scheduling in robotic cells: Classification, two and three

machine cells, Operations Research 45 (3), 421-439 (1997). 4. Y. Crama and J. vandeKlundert, Cyclic scheduling in 3-machine robotic flow shops, Working Paper

RM/97/018, Maastricht Research School of Economics of Technology and Organisation (1997); Journal of Scheduling 2, 35-54 (1999).

5. N. Brauner and G. Finke, On a conjecture about robotic cells: New simplified proof for the three-machine case, Journal of Information Systems and Operational Research-ZNFOR 37 (l), 20-36 (1999).

6. N. Brauner and G. Finke, On cycles and permutations in robotic cells, Internal Note (1998); Technical Report Leibniz-IMAG, RR 1010-I (1999).

7. Y. Crama, V. Kats, J. vandeKlundert and E. Levner, Cyclic scheduling in robotic flowshops, Annals of Operation Research: Mathematics of Industrial Systems (to appear).

8. Y. Crama and J. van deKlundert, Cyclic scheduling of identical parts in a robotic cell, Operations Research

45 (6), 952-965 (1997). 9. N. Brauner, Ordonnancement dans des cellules robotis&s, analyse de la conjecture des un-cycles, Th&e de

doctorat, Universite Joseph Fourier, Grenoble, France, (1999).

Documents

Cycles and permutations in robotic cells