a heuristic algorithm for determining replacement policies in consecutive k-out-of-n systems

Available online at www.sciencedirect.com

Computers & Operations Research 31 (2004) 1335–1348www.elsevier.com/locate/dsw

A heuristic algorithm for determining replacement policies inconsecutive k-out-of-n systems

James Flynn∗, Chia-Shin Chung

Department of Operations Management and Business Statistics, Cleveland State University, Cleveland,OH 44115, USA

Abstract

This article presents a heuristic algorithm for determining replacement policies in a discrete-time, in,nite-horizon, dynamic programming model of a binary coherent system with n statistically independent components,and then specializes the algorithm to consecutive k-out-of-n systems. Costs arise when the system fails andwhen failed components are replaced. The objective is to minimize the long run expected average undiscountedcost per period. A companion article (Naval Res. Logistics 49 (2002) 288) develops a branch and boundalgorithm for computing optimal policies. Extensive computational experiments on consecutive k-out-of-nsystems ,nd it e5ective when n6 40 or k is near n; however, the computations can be intractable whenn¿ 40 and 26 k ¡n−15, suggesting the need for a good heuristic. Computational experiments on consecutivek-out-of-n systems involving over 300,000 test problems ,nd the heuristic of this article highly e5ective. Foreach n and k tested, its percentage error was under 2.53%, and its mean computation time on a 1700 MHzPentium IV was under 0:24 s (the largest n in our experiments was 200).? 2003 Elsevier Ltd. All rights reserved.

Keywords: Heuristic algorithm; Reliability; Replacement policies; Multicomponent; Consecutive k-out-of-n

1. Introduction

Replacement models have been a subject of great interest (see the surveys by Barlow and Proschan[1], Pierskalla and Voelker [2], Sherif and Smith [3], and Wang [4]). Multicomponent models areespecially important, since they can allow one to represent overall costs more accurately and tradeo5component replacement and system failure costs more e5ectively. Flynn et al. [5] studied a discretetime, in,nite horizon dynamic programming model for determining component replacement policiesin a multicomponent, binary coherent system. For the case of in k-out-of-n systems, Chung and Flynn

∗ Corresponding author. Tel.: +216-6216349.E-mail address: [email protected] (J. Flynn).

0305-0548/$ - see front matter ? 2003 Elsevier Ltd. All rights reserved.doi:10.1016/S0305-0548(03)00094-7

mailto:[email protected]

1336 J. Flynn, C.-S. Chung / Computers & Operations Research 31 (2004) 1335–1348

[6,7] provide optimal and heuristic algorithms. Recently, Flynn and Chung [8] develop an optimalalgorithm for binary coherent systems, and then specialized the algorithm to consecutive k-out-of-nsystems. The computations of the optimal algorithm can be intractable for certain n and k values,however. The main contribution of this article is an e5ective heuristic algorithm for consecutivek-out-of-n systems.

Following [5,8], we impose the following assumptions. The system is coherent and contains ncomponents. (see Section 2 below or Barlow and Proschan [1] for the de,nition of coherent). Thereare two possible conditions for the system and for each component: functioning and failed. Thestate is a n-dimensional vector indicating the condition of each component. At the start of each ofan in,nite number of periods, one perfectly observes the state and has the option of immediatelyreplacing or not replacing any failed component with a functioning one. If component i (i=1; : : : ; n)is functioning after such replacements, it continues to function for the rest of the period with prob-ability pi ∈ (0; 1) and fails during the period with probability qi = (1 − pi). Replacing componenti costs ci ¿ 0. The system being in a failed condition at the end of a period costs c0¿ 0. Theseprobabilities and costs do not depend on the period. The component lifetimes are geometric (i.e.,independent of age) and statistically independent. Observing components costs nothing. The objec-tive is to ,nd replacement policies minimizing the long run average, expected, undiscounted cost perperiod.

Section 1 formulates our problem as a dynamic programming model with 2n states. Unfortu-nately, ,nding an optimal policy using standard techniques is impractical for large n. One wayaround this diLculty is to show that one can restrict attention to policies for which the computationsare not too demanding. The main results of [5] justify restricting attention to critical componentpolicies (CCP). Under a CCP, decisions are determined by a critical component set and the rule:Replace a component if and only if it is failed and in the critical component set. Thus failed com-ponents not in the critical component set stay failed. There always exists a CCP minimizing thelong run average of the expected undiscounted cost per period. This article calls such a policyoptimal.

These results have applications to system design. They suggest that the ,rst step in designinga system from a set of available components, {1; 2; : : : ; n}, is to determine the critical componentset S∗ of an optimal CCP. The second is to constrict the system so that it consists entirely ofthe components in S∗. For the resulting |S∗|—component system, it would be optimal to replacecomponents whenever they fail. Note that the design aspects may be of secondary importance. Inapplications, one usually encounters existing systems which consist of both critical and noncriticalcomponents. Furthermore, the parameters may change over time, due to economic conditions thata5ect the costs, changes in technology, problems with the availability of some components, etc. Onemay wish to respond to such changes with a rolling horizon scheme like the following: Find astationary policy that is optimal for an in,nite horizon under the current parameters. Use this policyfor a given number of periods. Revise the parameters and repeat.

Finding an optimal CCP is a binary nonlinear programming problem in n variables. Ref. [8]develops a branch and bound algorithm that computes optimal CCPs for consecutive k-out-of-n(failure) systems. In such a system, the components occupy n possible positions on a line and thesystem fails if components in k or more consecutive positions fail. Consecutive k-out-of-n systems,rst appear in Kontoleon [9] and Chiang and Niu [10]. The literature on these systems and theirgeneralizations is vast (see Chao et al. [11] for references). Applications occur in telecommunications

J. Flynn, C.-S. Chung / Computers & Operations Research 31 (2004) 1335–1348 1337

systems, pipeline networks, and integrated circuit design. For example, consider a chain of n ,xedrelay stations, each with a transmitter/receiver module. Signals are successfully transmitted alongthe chain if every sequence of k consecutive stations contains at least one functioning module. Here,components are relay stations and a component is functioning if and only if it contains a functioningmodule. (Replacing a failed component means bringing it to a functioning state by replacing itsfailed module.) The replacement costs and the reliabilities of the modules need not be the same atall stations.

The branch and bound algorithm of [8] can handle a wide variety of problems. Its memoryrequirement is O(n), and computational experiments with more than 300,000 test problems suggestthat it performs well for a wide range of parameters when n6 40 or k is near n. Unfortunately, thecomputational demands of the algorithm can be excessive for n¿ 40 and 2¡k¡n−15, suggestingthe need for a good heuristic policy. (The model of [8] is new, so outside of this article, there areno existing heuristic policies for this model.) We conjecture that ,nding an optimal CCP is NP-hardfor general k and n.

Section 2 lists assumptions and summarizes results needed from [5,8]. Section 3 obtains conditionsthat are necessary for optimality in a binary coherent system with statistically independent compo-nents, and provides a search procedure that computes a CCP meeting those conditions. Such a CCPis locally optimal in the sense that it is better than any other CCP that is “close” to it. Section 4adapts the procedure of Section 3 to consecutive k-out-of-n systems by providing two starting solu-tions, which under our search procedure, converge to two locally optimal CCPs. Our heuristic policyis formed from the better of these two policies. Section 4 gives an illustrative example. Section 5reports on extensive computational experiments that evaluate the heuristic solution’s e5ectiveness forconsecutive k-out-of-n systems. Our results suggest that it performs well. Its memory requirementis O(n). For each n and k tested, its mean percentage error was under 2.53%, and its mean com-putation time on a 1700 MHz Pentium IV was under 0:24 s. (The largest n tested was 200.) Ourresults also indicate that using the heuristic policy as the initial incumbent for the branch and boundalgorithms of [6,8] can substantially reduce computation. Section 6 indicates that our heuristic alsoperforms well for other binary coherent systems, i.e., the k-out-of-n and the circular consecutivek-out-of-n systems (see Section 6 for de,nitions). Section 7 summarizes our results and states ourconclusions.

2. Notation, assumptions, and de�nitions

Represent the state by the vector x = (x1; : : : ; xn)∈X ≡ {0; 1}n, where xi (i = 1; : : : ; n) indicatesthe beginning-of-period condition of the ith component, i.e., xi = 1 if component i is functioningand xi = 0 if component i is failed. Represent the decision by the vector d= (d1; : : : ; dn)∈X, wheredi indicates the condition of the ith component when the replacements for a period are completed.Decision d is feasible in state x if di¿ xi for i = 1; : : : ; n. (Strict inequality holds when componenti is replaced.)

The condition of the system depends on the conditions of its components through a coherentstructure function � with � = 1 if the system is functioning and � = 0 if it is failed. (Coherencemeans �(x1; : : : ; xn) is nondecreasing in xi for 16 i6 n and there are no irrelevant components:see [1]). If feasible decision d is selected in state x, there is a replacement cost

∑ni=1(di − xi)ci, a


random transition to a new state T̃(d) = (T̃ 1(d1); : : : ; T̃ n(dn)), and an expected system failure costc0P[�(T̃(d)) = 0]. Note that P[T̃ i(di) = 1] = pidi and P[T̃ i(di) = 0] = 1 − pidi (i = 1; : : : ; n). Alsothe expected single-period cost, when the state is x and the decision is d, equals

∑ni=1(di − xi)ci +

c0P[�(T̃(d)) = 0].A policy is a rule for determining an in,nite sequence of feasible decisions for each initial state

x∈X. A stationary policy � speci,es for each x∈X what feasible decision �(x) to select whenthe state is x. Decisions thus selected do not depend on the period. Here, costs are undiscountedand the objective is to minimize the long run expected average cost per period. For any policy �,any integer N ¿ 0 and any x∈X, let lim infN→∞ VN� (x) represent the expected total N -period costsunder � when the initial state is x, and let ��(x) = lim infN→∞ VN� (x)=N , the long run expectedaverage cost per period under �. Any policy �∗ such that ��∗(x) = inf ��(x) for all states x is saidto be optimal.

Denote by � the set of all subsets of {1; 2; : : : ; n}. Results in [5] ensure the existence of an optimalCCP. A CCP is a stationary policy where the decisions are determined by a critical component setS ∈� and the rule: Replace component j if and only if j is failed and j∈ S. For S ∈�, let �S denotethe CCP with S as its critical component set, and let dS = (dS1 ; dS2 ; : : : ; dSn), where dSj = 1 if j∈ Sand dSj = 0 if j �∈ S. Given decision dS , the set of components that are functioning immediatelyafter the replacements for a period are completed equals S. Note that dS is feasible when thebeginning-of-period set of functioning components is a subset of S. In general,

�S(x) = (max{dS1 ; x1};max{dS2 ; x2}; : : : ;max{dSn ; xn}); x∈X: (2.1)

Call S ∈� an optimal critical component set if �S is optimal. For S ∈�, let PF(S) denote theprobability of system failure given dS , i.e., PF(S) = P[�(T̃(d)) = 0], and let

B(S) =∑

i∈Spici and G(S) =

∑

i∈Sqici + c0PF(S); (2.2)

g∗ = minS∈�

G(S); b∗ = minS∈� and G(S)=g∗

B(S); and

�∗ = {S ∈�: G(S) = g∗ and B(S) = b∗}: (2.3)

By [5, Theorem 4.3], S∗ is an optimal critical component set if S∗ ∈�∗. Note that G(S) equals thelong run expected average cost per period under �S , and g∗ equals the optimal long run expectedaverage cost per period.

Say that S ∈� dominates T ∈� if either G(S)¡G(T ) or [G(S) = G(T ) and B(S)6B(T )].Trivially, each S dominates itself. Say that S strictly dominates T if G(S)¡G(T ) or [G(S)=G(T )and B(S)¡B(T )]. Note that each S∗ in �∗ dominates every S in � and strictly dominates every Sin � − �∗.

Lemma 2.1 below, which comes from [8, Section 2], gives iterative formulas for PF(S), which areuseful for consecutive k-out-of-n systems ([8, Lemma 4.1]). For S ∈� and 16 i6 n, de,ne PF(S; i)as the conditional probability of system failure given decision ds∪{i} and given that i is functioningat the end of a period. Our statistical independence assumption allows us to obtain PF(S; i) by settingpi equal to 1 and then computing PF(S ∪ {i}).


Lemma 2.1. Suppose S ∈�. Then the following hold.

PF(S ∪ {i}) = PF(S)qi + PF(S; i)pi for i �∈ S; (2.4)

PF(S) − PF(S; i) = qi[PF(S − {i}) − PF(S − {i}; i)] for i∈ S: (2.5)

3. Necessary conditions for optimality

This section obtains conditions that are necessary for S∗ ∈�∗, and shows how to compute an S#

meeting those conditions. Such an S# is locally optimal in the sense that it strictly dominates eachset in � that di5ers from it by exactly one component (see Theorem 3.2 below). Furthermore, S#

can provide an initial incumbent solution for our optimal branch and bound algorithm and can alsoserve as a heuristic solution. The next theorem extends [6, Theorem 4].

Theorem 3.1. Suppose S∗ ∈�∗. Then the following conditions must hold.

qici=pi¿ c0[PF(S∗) − PF(S∗; i)] for i �∈ S∗; (3.1)

q2i ci=pi ¡c0[PF(S∗) − PF(S∗; i)]; for i∈ S∗: (3.2)

The proof of Theorem 3.1 requires the following lemma.

Lemma 3.1. Suppose S ∈�. Then the following hold.

G(S ∪ {i}) = pi{qici=pi − c0[PF(S) − PF(S; i)]} + G(S) for i �∈ S; (3.3)

G(S) = (pi=qi){q2i ci=pi − c0[PF(S) − PF(S; i)]} + G(S − {i}) for i∈ S: (3.4)

Proof. Suppose i �∈ S. By (2.2), G(S ∪ {i}) = G1(S) + qici + c0PF(S ∪ {i}). On substituting (2.4),one gets G(S ∪{i}) = qici− c0pi[PF(S)−PF(S; i)] +G(S), which implies (3.3). Next, suppose i∈ S.By (3.3), G(S) =G((S − {i}) ∪ {i}) = pi{qici=pi − c0[PF(S − {i}) − PF(S − {i}; i)]} +G(S − {i}).This (2.5), and routine algebra give us (3.4).

Proof of Theorem 3.1. Suppose i �∈ S∗. By (2.3), G(S∗∪{i})¿G(S∗). This and (3.3) give us (3.1).Next, suppose i∈ S∗. Again by (2.3), G(S∗)6G(S∗ − {i}). Also, if G(S∗) =G(S∗ − {i}), then S∗cannot satisfy (2.3), since B(S∗)¿B(S∗ − {i}). Hence, G(S∗)¡G(S∗ − {i}). This inequality andLemma 3.1 imply (3.2).

Although the necessary conditions of Theorem 3.1 are not suLcient for membership in �∗(see below), a heuristic policy whose critical component set S# satis,es them might be useful.De,ne

�# = {S# ∈�: S# satis,es (3:1) and (3:2)}: (3.5)


By Theorem 3.1, �∗ ⊆ �#. The next theorem indicates that each S# ∈�# is locally optimal in thesense that S# strictly dominates each set in � that di5ers from it by exactly one component.

Theorem 3.2. Each S# ∈�# strictly dominates S# ∪ {i}, for i �∈ S#, and S# − {i}, for i∈ S#.

Proof. Let S# ∈�#. If S ′ = S# ∪ {i}, where i �∈ S#, then B(S ′)¿B(S#) and, by (3.3) and (3.1),G(S ′)¿G(S#). If S ′ =S# −{i} where i∈ S#, then G(S ′)¿G(S#) by (3.4) and (3.2). In either case,S# strictly dominates S ′.

Turn to the problem of computing a set in �#. Consider any S ∈�. Either S satis,es both (3.1)and (3.2) or there exists a component i such that

i∈ S and q2i ci=pi¿ c0[PF(S) − PF(S; i)]; (3.6)

or

i �∈ S and qici=pi ¡c0[PF(S) − PF(S; i)]: (3.7)

The arguments for Theorem 3.1 imply that S − {i} strictly dominates S if i satis,es (3.6), andS ∪ {i} strictly dominates S if i satis,es (3.7). Starting from a given initial set S0, the procedurebelow ,nds an S# ∈�#.

Procedure search;

begin S := S0;

while (3:6) or (3:7) holds for some i do replace S by a set that strictly dominates S;

S# := S; end;

(3.8)

Strict dominance ensures that cycling is impossible, so the search procedure converges to someset in �#, say S#, in a ,nite number of steps. Note that S# can vary with S0, e.g., S# equals S0

when S0 ∈�#. Note also that the search procedure above does not uniquely de,ne S#, since it doesnot uniquely specify the replacement for S when more than one i satis,es (3.6) or (3.7). (This ismade precise in Section 4.)

One should exercise care when selecting an initial set S0. For k-out-of-n failure systems withk6 n=2, one should avoid ∅, since ∅ belongs to �# and thus is absorbing—even though G(∅) isoften far from g∗. Convergence to ∅ is impossible, of course, when G(S0)¡G(∅). Even startingfrom S0 = {1; 2; : : : ; n} cannot ensure nonconvergence to ∅, since �# = {∅} is possible. Furthermore,convergence to a nonnull S# ∈�# − �∗ is also possible. ([6, Example 1] describes such an S#.)Section 4 uses two initial sets to generate the heuristic solution.

4. Consecutive k-out-of-n systems

Throughout this section and Section 5, assume that the system is a consecutive k-out-of-n failuresystem. Recall that Section 3 outlines a search procedure that given an arbitrary starting solutionS0 ∈�, converges to an S# ∈�#, where �# consists of all sets that satisfy the necessary conditionsfor optimality of Theorem 3.1. This section adapts that search procedure to consecutive k-out-of-n


failure systems. It also provides two starting solutions, S0L and S0

H, which under our search procedure,converge to SL ∈�# and SH ∈�#, respectively. De,ne the heuristic solution as any set among SL,SH, and ∅ that dominates the others. (Including ∅ in the pool ensures that the heuristic solutiondominates ∅.) De,ne the heuristic policy as the CCP whose critical component set is the heuristicsolution.

Note that in order to compute the heuristic policy one must employ our search procedure twice:,rst, using the starting solution S0

L to get SL, and second, using the starting solution S0H to get SH. In

each case, our search produces a solution that is locally optimal in the sense that it strictly dominateseach set in � that di5ers from it by exactly one component (see Section 3). Thus ,nding a heuristicsolution reduces to ,nding two locally optimal solutions. Example 4.1 illustrates our results.

The order in which one adds or deletes components can a5ect the search result. Results in [8]suggest that for k-out-of-n failure systems, more important components tend to have smaller qici=pivalues. For 16 j6 n, let ij be the component with the jth smallest value of qjcj=pj (break tiesarbitrarily). Replace the while statement of search procedure (3.8) by the following nested repeatstatement.

Repeat

repeat

Sbegin := S; for j := n down to 1 do if ij satis,es (3:6) then S := S − {ij}until S = Sbegin;

repeat

Sbegin := S; for j := 1 to n do if ij satis,es (3:7) then S := S ∪ {ij}until S = Sbegin;

until (3:6) and (3:7) fail for all components;

(4.1)

Under the above revised search procedure, components with smaller values of qjcj=pj are added,rst and deleted last. (This does better than random selection in the numerical study of Section5.) Hwang [12] develops a set of recursive equations for computing the reliability of a consecutivek-out-of-n failure system in O(n) time. Section 5 uses his algorithm to evaluate the function PF

when checking (3.6) and (3.7).We tried two starting solutions: a low density solution S0

L and a high density solution S0H. The

obvious choice for the latter is S0H = {1; 2; : : : ; n}. Choosing S0

L is more complicated, since theobvious choice ∅ is unacceptable for reasons discussed in Section 3. To decrease the likelihood ofconvergence to ∅, we impose PF(S0

L)¡ 1. Also, given the discussion in the previous paragraph, weprefer components with smaller values of qici=pi. Therefore, let S0

L be any solution to

f(S0L) = min{F(S): PF(S)¡ 1}; (4.2)

where

f(S) =∑

i∈Sqici=pi for S ∈�: (4.3)


One can compute S0L in O(nk) time by solving the dynamic programming recursions (4.7) and

(4.8) below. Since the system is a consecutive k-out-of-n failure system, (4.2) implies that

f(S0L)= minimize f(T )

Subject to : T ⊆ {1; 2; : : : ; n}; and {1; 2; : : : ; n} − Tdoes not contain k consecutive components:

(4.4)

For m= 1; 2; : : : ; n, let

hm= minimize f(T )

Subject to : m∈T; T ⊆ {m;m+ 1; : : : ; n}; and {m;m+ 1; : : : ; n} − Tdoes not contain k consecutive components:

(4.5)

The requirements on T in (4.4) imply that T has a ,rst component j and, further, that 1¡j6 k.Therefore

f(S0L) = min{hj: 0¡j6 k}: (4.6)

By (4.3), (4.5), and the nonnegativity of qici=pis,

hm = qmcm=pm for n− k ¡m6 n: (4.7)

Next, suppose that 16m6 n− k, T satis,es (4.5), and T ′ ≡ T − {m}. Then T ′ must have a ,rstcomponent j where m¡j6m+ k. Using G1(T ) = qmcm=pm + G1(T ′) and (4.5), one can establish

hm = qmcm=pm + min{hj: m¡j6m+ k and j6 n}; for 16m6 n− k: (4.8)

Note that the time needed to compute the hms is O(nk). After determining the hms, one can usebacktracking to determine S0

L: The ,rst component of S0L is the j achieving the minimum in (4.6).

If n − k ¡ j6 n, there is no second component. Otherwise, the second component of S0L is the j

achieving the minimum in (4.8), when m equals the ,rst component of S0L, and so forth.

This section closes with an illustrative example.

Example 4.1. Let n= 8, k = 2, c0 = 1:0, c1 = 0:356, c2 = 0:922, c3 = 0:341, c4 = 0:702, c5 = 0:865,c6 = 0:168, c7 = 0:207, c8 = 0:745, q1 = 0:110, q2 = 0:198, q3 = 0:157, q4 = 0:207, q5 = 0:109,q6 = 0:138, q7 = 0:036, and q8 = 0:272. Also, let pj = 1 − qj, for 16 j6 n. Turn to the heuristicpolicy. One easily obtains SL = S0

L = {3; 6}, PF(SL) = 0:27333, and g(SL) = 0:3501. Also, one getsS0

H ={1; 2; 3; 4; 5; 6; 7; 8}, SH ={3; 5; 6; 7}, PF(SH)=0:17341, and g(SH)=0:3519. Since g(∅)=c0 =1:0and g(SL) = =min{g(SL); g(SH); g(∅)}, we conclude that the heuristic solution S# equals SL = {3; 6}and g(S#) = 0:3501. Finally, applying the optimal branch and bound algorithm of [8], one getsS∗ = {1; 3; 4; 6; 7}, PF(S∗) = 0:07415, and g∗ = g(S∗) = 0:3428. Thus the heuristic policy is 2.12%more expensive than an optimal policy.

5. Computational experience

This section reports on computational experiments that evaluate the e5ectiveness of the heuristicpolicy for consecutive k-out-of-n failure systems. Our results suggest that the heuristic performs


well. For each n and k tested, the heuristic policy’s mean percentage error was under 2.53%, andits mean computation time was under 0:24 s. (The largest n in our experiments was 200.) Thiscontrasts with our branch and bound algorithm, which had diLculty solving problems with n¿ 40and 2¡k¡n− 15.

The optimal policy was computed using the branch and bound algorithm of [8]. The algorithmswere coded in Borland Pascal 7.0 and run on a 1700 MHz Pentium IV under Windows 2000. Allcalculations used double precision. For each test problem, we kept track of (i) the heuristic policy’spercentage error, i.e., 100[G(S#)=g∗−1], (ii) whether the heuristic policy was optimal, and (iii) thecomputation time for the heuristic policy. Our problem generation procedure outlined below, whichis the same as [8], yields test problems encompassing a wide variety of situations.

1. The success probabilities, p1; : : : ; pn, were independent, identically distributed, uniform randomvariables on [PL; 1]. Ten values were used for PL: 0.0, 0.2, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.99, and0.999.

2. The system failure cost c0 was normalized to 1. The replacement costs, c1; : : : ; cn, were indepen-dent, identically distributed, uniform random variables on [0; CU]. Twenty values were used forCU: 10−6, 10−5, 10−4, 4 × 10−4, 7 × 10−4, 0.001, 0.004, 0.007, 0.01, 0.04, 0.07, 0.1, 0.4, 0.7,1.0, 4.0, 7.0, 10, 100, and 1000.

Note that ci represents the ratio of the replacement cost of component i to the system failure cost.There are 2n nodes. We stopped our branch and bound algorithm when the node count reached 107.

To measure performance versus n and k, we solved a total of 258,000 test problems with n =10; 15; 20; 25; 30; 35 and k = 2; 3; : : : ; n. (For each combination of n, k, PL, and CU, we generated10 problems.) The mean computation times were not sensitive to k. Table 1 reports on how thepercentage error for the heuristic, and the percentage of cases where the heuristic is optimal variedwith k when n = 30, while Table 2 summarizes how the quantities of interest vary with n whenaveraged over all k. The numbers in Table 1 indicate that the heuristic’s average performance isexcellent for small k and good for all k when n= 30. The same pattern extends to n= 10–35. Table2 ,nds that the mean percentage error tends to increase with n while the percentage of cases wherethe heuristic is optimal tends to decrease with k. For n=35, the former equals 1.164% and the latter81.6%.

Next, to evaluate the heuristic for n between 40 and 50, we solved 74,000 test problems withn=40; 45; 50 and k=n−15, n−10, n−6, n−5; : : : ; n; n=40 and k=2; 3; 4; 5; n=45 and k=2; 3; 4;n = 50 and k = 2; 3. (We generated 10 problems for each combination of n, k, PL, and CU.) It isimpractical to solve many problems with other k values using our branch and bound algorithm. Thenumbers in Tables 3 and 4 suggest that average performance is still excellent for small k and goodfor k near n when 406 n6 50. To study k near n when n is large, we solved 10,000 problems withn= 100; 200 and k=n−15, n−10, n−6, n−2, n. (We generated 5 problems for each combinationof n, k, PL, and CU.) The numbers in Tables 3 and 4 indicate that performance degrades slightlyas n increases when k¿ n− 15.

Table 2 suggests that the mean computation times for the heuristic tend to increase with n, but notrapidly. To test this for large n, we computed the heuristic solution for a large sample of problemswith n= 50; 100; 200, and k= 2; 3; : : : ; n. (We generated one test problem for each combination of n,k, PL, and CU.) Our results con,rm that the mean computation time for the heuristic is not highly


Table 1The mean % error for the heuristic, and the % of cases where the heuristic is optimal vs. k for n= 30

k Mean % error % Cases optimal

2 0.018 98.63 0.258 91.34 0.446 84.95 0.587 81.36 0.638 80.48 0.818 77.8

10 1.066 76.012 1.155 77.914 1.273 80.816 1.646 78.218 1.933 80.320 1.376 84.122 1.034 87.524 0.900 89.826 0.975 89.628 1.160 88.329 1.221 87.930 1.284 87.7

Table 2The mean computation time and the mean % error for the heuristic, and the % of cases where the heuristic is optimalvs. n (averaged over k)

n Mean time (in S) Mean % error % Cases optimal

10 0.001 0.420 94.715 0.001 0.632 91.020 0.001 0.793 88.725 0.002 0.963 85.730 0.002 1.066 83.635 0.002 1.164 81.6

sensitive to n or k. For n= 200, the overall mean computation time equals 0:062 s, while the largestand smallest means (as a function of k) equal 0.013 and 0:241 s, respectively.

Finally, we address two questions concerning the heuristic solution’s use as the initial incumbentfor our branch and bound algorithm. First, how much worse would one do using ∅? Second, howmuch better could one do with a better solution? We solved a sample of 5800 test problems withn = 30 and k = 2; 3; : : : ; n. (For each combination of k, PL, and CU, we generated one problem.)Each problem was solved using the three initial incumbent solutions: ∅, the heuristic solution, andan optimal solution. We found that the mean time using the heuristic solution was 46% as largeas the mean time using ∅; moreover, using an optimal solution rather than the heuristic solutionreduced the mean time by only 5%. Next, we applied the same procedure to a sample of 3200 test


Table 3The mean % error for the heuristic vs. n and k

k n= 40 n= 50 n= 100 n= 200

2 0.016 0.022 NA NA3 0.216 0.074 NA NA4 0.361 NA NA NA5 0.341 NA NA NAn− 15 1.762 1.508 1.575 1.932n− 10 1.151 1.321 1.940 2.204n− 6 1.307 1.376 1.900 2.211n− 2 1.125 1.480 1.749 2.381n 1.344 1.633 1.668 2.527

Table 4The % of cases where the heuristic is optimal vs. n and k

k n= 40 n= 50 n= 100 n= 200


problems with n= 40; 50 and k= 2, n−15, n−10, n−6, n−4, n−2, n−1, n. Here, the mean timeusing the heuristic solution was only 22% as large as the mean time using ∅ and using an optimalsolution rather than the heuristic solution produced a savings of only 3%. These results suggest thatone should start with the heuristic rather than with ∅—especially when n is large, but one shouldnot try for a better starting solution.

6. Other binary coherent systems

Ref. [7] develops a heuristic for k-out-of-n systems. (A k-out-of-n (failure) system fails if k ormore of its n components fail.) When k = n both consecutive k-out-of-n systems and k-out-of-nsystems reduce to parallel systems. When applied to parallel systems, the current heuristic producedmuch smaller percentage errors than the heuristic of [7]. For example, Table 3 reports 1.668% fork = n= 100, while [7, Table 2] reports 4.90%. This suggests that our heuristic might outperform [7]for k-out-of-n systems.


Table 5For circular systems: the mean computation time and the mean % error for the heuristic, and the % of cases where theheuristic is optimal vs. n (averaged over k)

n Mean time (in S) Mean % error % Cases optimal

10 0.000 0.520 93.515 0.002 0.832 87.920 0.003 0.957 84.625 0.003 1.124 81.530 0.005 1.346 78.635 0.011 1.503 75.8

Table 6For circular systems: the mean % error for the heuristic vs. n and k

k n= 40 n= 50 n= 100 n= 200


Flynn and Chung [8, Section 4.3] indicates how to adapt our optimal algorithm to circular con-secutive k-out-of-n (failure) systems, where the components occupy n possible positions on a circleand the system fails if components in k or more consecutive positions fail. For such systems, Hwang[12] requires O(nk2) time to compute PF(S). However, PF(S; i) only requires O(n) time, since giventhat i functions, the system fails if and only if the consecutive system, i + 1; : : : ; n; 1; : : : ; i − 1, hask consecutive failures. For convenience, our heuristic for circular systems solves (4.6)–(4.7) to getS0

L—even though S0L no longer solves (4.2)–(4.3).

This section reports on computational experiments that evaluate the e5ectiveness our heuristicwhen applied to circular consecutive k-out-of-n failure systems. Our problem generation procedureand set of parameters tested are the same as in Section 5. The main di5erence is that we nowgenerate only one problem for each combination of n, k, PL, and CU. Thus the current test bed isa subset of the earlier one. Our results, summarized in Tables 5 and 6, suggest that our heuristicperforms well (though not as well as for consecutive k-out-of-n failure systems). For instance, themean error when n = 30 is 1.346% for circular consecutive systems and 1.066% for consecutivesystems (see Tables 2 and 5).


7. Summary and conclusions

The study of maintenance and replacement models has been a subject of great interest. Mostoptimization models assume a single component, which is suboptimal where there are multiple com-ponents and the objective is to tradeo5 the component maintenance and replacement costs and thesystem failure cost. This is one of two articles dealing with an important class of multicomponentsystems with applications in telecommunications, computer, and pipeline networks—the consecutivek-out-of-n failure system. A companion article [8] develops a branch-and-bound algorithm for com-puting optimal policies for a dynamic programming model of such systems. That optimal algorithmis e5ective when n6 40 or k is near n, but can be intractable for other n and k, suggesting the needfor a good heuristic policy. (We conjecture that ,nding an optimal policy is NP-hard for general kand n.)

This article ,lls a gap by developing the ,rst heuristic policy for our model. This heuristic utilizesa search procedure that starting from an arbitrary initial policy converges to a policy that satis,escertain necessary conditions for optimality. Applying this procedure to two speci,c initial policiesproduces the heuristic policy. This policy is much easier to compute than an optimal policy. Extensivecomputational experiments involving over 300,000 test problems suggest that it is e5ective for a widevariety or of n and k values and that its computational requirements are not highly sensitive to nand k. For each n and k tested, the heuristic policy’s mean percentage error was under 2.53%, andits mean computation time was under 0:24 s. (The largest n in our experiments was 200.)

One can easily adapt the heuristic policy of this article to other binary coherent systems. A morerestricted set of experiments ,nds that it performs well for circular consecutive k-out-of-n failuresystems and that it outperforms an earlier heuristic in [7] for parallel systems. This suggests that itmight also outperform [7] for k-out-of-n failure systems.

References

[1] Barlow R, Proschan F. Statistical theory of reliability and life testing: probability models. New York: Holt, Rinehart,and Winston, 1975.

[2] Pierskalla W, Voelker J. A survey of maintenance models: the control and surveillance of deteriorating systems.Naval Research Logistics Quarterly 1976;23:353–88.

[3] Sherif YS, Smith ML. Optimal maintenance policies for systems subject to failure—a review. Naval ResearchLogistics Quarterly 1981;8:47–74.

[4] Wang H. A survey of maintenance policies of deteriorating systems. European Journal of Operational Research2002;139:469–89.

[5] Flynn J, Chung CS, Chiang D. Replacement policies for a multicomponent reliability system. Operations ResearchLetters 1988;7:167–72.

[6] Chung CS, Flynn J. A branch and bound algorithm for computing optimal replacement policies in k-out-of-n systems.Operations Research 1995;43:826–37.

[7] Chung CS, Flynn J. A heuristic algorithm for determining replacement policies in k-out-of-n systems. Naval ResearchLogistics 1997;44:273–86.

[8] Flynn J, Chung CS. A branch and bound algorithm for computing optimal replacement policies in consecutivek-out-of-n systems. Naval Research Logistics 2002;49:288–302.

[9] Kontoleon JM. Optimum allocation of components in a special 2-port network. IEEE Transactions on Reliability1978;R-27:112–5.

[10] Chiang DT, Niu SC. Reliability of consecutive k-out-of-n: F system. IEEE Transactions on Reliability 1981;R-30:87–9.


[11] Chao MT, Fu JC, Koutras MV. Survey of reliability studies of consecutive k-out-of-n : F & related systems. IEEETransactions on Reliability 1995;R-44:120–7.

[12] Hwang FK. Fast solutions for consecutive k-out-of-n: F system. IEEE Transactions on Reliability 1982;R-31:447–8.

Chia-Shin Chung is a Professor in the Department of Operations Management and Business Statistics at ClevelandState University. He received a Ph.D. in operations research from Berkeley. He has published in Operations Research,Management Science, European Journal of Operational Research, Computers & Operations Research, Naval ResearchLogistics, Journal of the Operational Research Society, Journal of Operations Management, IEEE Transactions onReliability, etc. His current research interests include inventory control, supply chain management, and reliability.James Flynn is a Professor and Chair of the Department of Operations Management and Business Statistics at Cleveland

State University. He received an A.B. in mathematics from UCLA and a Ph.D. in statistics from Berkeley. He has publishedin Operations Research, Management Science, Mathematics of Operations Research, European Journal of OperationalResearch, Computers & Operations Research, Naval Research Logistics, Annals of Statistics, IEEE Transactions onReliability, etc. His current research interests include inventory control, supply chain management, and reliability.

a heuristic algorithm for determining replacement policies in consecutive k-out-of-n systems

Documents