Mathematical Problems in Engineering
Volume 2015 (2015), Article ID 276234, 6 pages
http://dx.doi.org/10.1155/2015/276234

Research Article

A Discrete-Binary Transformation of the Reliability Redundancy Allocation Problem

Marco Caserta¹ and Stefan Voß2,3

¹IE Business School, IE University, Maria de Molina 31B, 28006 Madrid, Spain
²Institute of Information Systems, University of Hamburg, Von-Melle-Park 5, 20146 Hamburg, Germany
³Escuela de Ingeniera Industrial, Pontificia Universidad Católica de Valparaíso, Avenida Brasil 2241, 2362807 Valparaíso, Chile

Received 10 December 2014; Accepted 4 April 2015

Academic Editor: Wei-Chiang Hong

Copyright © 2015 Marco Caserta and Stefan Voß. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

Abstract.

Given a reliability redundancy optimization problem in its discrete version, it is possible to transform such integer problem into a corresponding binary problem in log-time. A simple discrete-binary transformation is presented in this paper. The proposed transformation is illustrated using an example taken from the reliability literature. An immediate implication is that a standard exact dynamic programming approach may easily solve instances to optimality that were usually only solved heuristically.

1. Introduction

Dealing with system reliability is a central issue in a variety of fields. Hardware and software reliability are of paramount importance, since hardware and software components are pervasive in modern society. The current competitive business environment is placing further emphasis on effective product and system design. In particular, in engineering design with reliability in mind, it is most important to improve the competitive position and to save in engineering design and warranty costs. Academics as well as practitioners have devoted and still put special attention to the advancement of reliability design and analysis methods for complex systems, both hardware and software. Reliability is a strategic issue in a number of industries such as, for example, the aerospace, automotive, civil, defense, telecommunications, and power industries, where advanced systems like space shuttle, aerospace propulsion, nanocomposite structure, and bioengineering systems are designed and developed with reliability in mind. Electronics, mechanics, computer science, and industrial engineering are just other fields interested in current studies on reliability.

Design with reliability in mind provides a number of advantages, spanning from the ability to produce safer and, obviously, more reliable products to the improvement in the competitive position via significant reduction of costs.

One of the recent trends observed in the field of reliability is related to the growth in size and complexity of the systems studied. Due to the fact that hardware and software systems keep growing in size and complexity, there is a need to design and develop efficient methods, that is, algorithms, for reliability problems. More precisely, software solutions that are aimed at reducing the time required to design complex reliability systems, that are able to deal with large scale models, and that are robust with respect to the system configuration are deemed vital.

An immediate idea or technique commonly used to increase reliability of a complex system is via redundancy allocation. The underlying hypothesis is that the reliability value is directly correlated to the number of redundant components placed in each stage of the system. However, owing to a set of constraints describing limitations in terms of cost, physical space availability, and similar limitations, the optimal allocation of redundant components is a hard task.

Usually, algorithms developed for the reliability redundancy allocation problem (RAP) work on the discrete version of the problem (see, e.g., [1–7]). In this paper we present a simple transformation into the binary version of the problem. Based on that, without loss of generality, one can work with the binary version of the RAP and use this for the future development of algorithms. As a result we can show that problem instances that are still solved heuristically in many recent papers (see, e.g., [8–10]) can be solved to optimality with a straightforward dynamic programming algorithm in reasonable computational time. The proposed discretization is supporting the dynamic programming problem as it allows treating incorporated problems of knapsack type directly as binary knapsack problems. In that sense, it allows binarizing a set of subproblems and then solving the general RAP via dynamic programming by linking or combining a set of binary knapsack problems.

In the next section we first provide a mathematical formulation for the RAP. In the sequel we transform the integer version of the problem into its analogous binary version (log-time transformation) in the spirit of, for example, the authors of [11] who developed similar ideas regarding the knapsack problem. After that, we show that a standard dynamic programming approach is able to quickly solve instances to optimality that were usually out of reach for exact approaches. We close with some conclusions.

2. A Nonlinear Formulation

Let us consider the RAP for the series-parallel configuration system, where different subsystems are placed in series and, within each system, parallel components are available, as illustrated in Figure 1. The objective of the problem is to determine which components and how many replications of each available component should be selected to maximize the overall system reliability. The problem is complicated by the existence of knapsack-type constraints, typically describing limitations in terms of volume, weight, and cost.

Figure 1: RAP series-parallel system.

A nonlinear integer formulation for the RAP is

where denotes the number of parallel components within subsystem , is the reliability of component within subsystem , with and , accounts for the usage of resource of component within subsystem (e.g., volume and cost), and provides the maximum availability of resource , with . Within the set of decision variables, each indicates how many times component of subsystem is present in an optimal configuration. It is easy to see that, in order to achieve a nonnull system reliability, the constraint must be implicitly satisfied for each subsystem .

3. Transformation between the Discrete RAP and the Binary RAP

Let us indicate, for any and with

the minimum amount of resource required to select at least one component within each subsystem . In addition, let indicate the total amount of resource available, and

the maximum amount of resource that could be devoted to subsystem , while ensuring that all the other subsystems will have enough spare resources to select at least one component. An upper bound on the number of replications of each component within subsystem is given by

Consequently, possible encoding for the binary RAP is obtained by creating binary variables for each component within the system. For the sake of readability, let us focus on a single component belonging to subsystem and on a single resource . Consequently, let us omit indexes and and let indicate the th component of subsystem . Finally, let us indicate with the total number of binary variables needed to encode the discrete variable ; that is,

The discrete variable , with , is substituted by a set of binary variables; that is, . Each of these binary “components” corresponds to replications of component , where

with . Consequently, we have that

Therefore, coefficients are defined such that they sum up to , that is, the maximum number of replications of component of subsystem . Thus,

can take any integer value between and .

Finally, each binary variable is characterized by the following coefficients:

where and indicate the reliability value and the amount of resource used by component within subsystem , respectively.

Each subsystem can thus be expressed through the use of a set of binary variables. Let us now reintroduce subindex . Let us indicate with the number of binary variables used to encode the discrete variable ; that is,

Each subsystem is defined by binary variables. Let us call these variables, in a progressive fashion, . In addition, let us indicate the progressive position of vector where the block of binary variables corresponding to a discrete decision variable begins with

with . Therefore, the binary vector , that is, the set of binary variables used to describe subsystem , is defined in the following way:

while vector , accounting for the whole system, is defined as .

Finally, note that the RAP can be transformed into its corresponding binary version in , where

It is easy to see that since is the minimum amount of binary variables required to encode the corresponding discrete variable, any other encoding will introduce the same amount of binary variables [11].

With this encoding, we finally define the RAP in its binary version:

where each , , and are defined as in (7) and (9).

In line with what is mentioned in [3] for the RAP, model RAP-B enables consideration of (i) multiple component choice for each subsystem—that is, each component can be selected more than once—and (ii) component mixing within a subsystem—that is, more than one component per subsystem can be selected.

An Example. Consider the first subsystem of the benchmark instances of [12]. We present the encoding of variables , accounting for the number of replications of components within subsystem . In Table 1 we summarize the relevant data, where , , and represent the reliability, cost, and weight of component within subsystem , with .

Table 1: Input data of subsystem of the instance from [12].

0.90
0.93
0.91
0.95

1
1
2
2

3
4
2
5

Let us first consider component . From [12], the maximum number of replications for each component is equal to ; that is, . Therefore, we have . Consequently, we encode the discrete variable through the use of three binary variables; that is, . Using (6), we compute the coefficients corresponding to the number of replications associated with each binary variable; that is, , , and . Therefore, as in (7), each binary variable has the following meaning:

It is easy to see that every possible value of can be expressed through an appropriate choice of values of , , and . The coefficients of the binary variables are computed using (9):

In a similar way, we encode variables , , and . Consequently, the whole set of discrete variables referring to subsystem is encoded using binary variables as follows:

4. Utilizing the Transformation

Dynamic programming (DP) has been used for the RAP by, for example, the authors in [12–14] who present DP schemes for the single-constraint version of the RAP. The inherent difficulty of using DP in the multiconstraint case is related to the growth of the dimensions of the table for the DP return function. More precisely, both space complexity and computational complexity of the DP scheme grow with , where indicates the number of knapsack-type constraints. Consequently, even with only a few constraints, the use of a DP approach can be cumbersome, though using the above transformation enables its use in settings that seemed out of reach without it.

In the next subsection we describe a DP algorithm for the RAP followed by a subsection presenting and discussing numerical results.

4.1. A Dynamic Programming Approach

We present a straightforward DP recursion for the RAP (note that this recursion can be used in various settings, e.g., as subroutine for metaheuristics; see [15]). We first separate each subsystem and transform the original problem into a series of “independent” knapsack problems (similar to [16]). The objective here is to maximize the reliability of subsystem , indicated with . The objective function of each subsystem can easily be linearized and the reliability of single subsystem can be rewritten as

where and . The problem of finding the optimal allocation of redundant components for subsystem , with , can be written as follows:

Problem RAP() is equivalent to a standard multidimensional knapsack problem with constraints, which can be solved in pseudopolynomial time using DP ( where ). Let us indicate with the optimal objective function value of the RAP() when only the first components are considered, with , and such that . A forward recursion formula for this problem is

where indicates the resource consumption of component , with . Thus, indicates the optimal solution with respect to subsystem when units of resources are used. In order to solve the RAP, let us now define as the optimal objective function value of the RAP when the first subsystems are considered, with , and such that . A DP recursion for the “classical” series-parallel RAP (i.e., ) is the following:

Obviously, is the optimal objective function value of the original RAP. The overall computational complexity of the recursive algorithm is .

4.2. Numerical Results

The DP algorithm described in the previous subsection has been coded in C++ and compiled with the GNU C++ compiler using the -O option. We present results for a benchmark set made up of 33 instances originally proposed by [12] but also used by a number of researchers. Best known results have been reported by [7, 17] and, consequently, we will compare the results of the proposed algorithm with those reported by these authors. The 33 variations of the RAP are series-parallel systems with two knapsack-type constraints, representing weight and cost, and 14 different links. That is, the system characteristics are , , and either or , depending on the value of ; see [7, 12] for details. Table 2 presents numerical results for these 33 benchmark instances. The wall-clock time is measured in seconds on a dual core Pentium 1.8 GHz Linux workstation with 4 Gb of RAM.

Table 2: Results on 33 benchmark instances.

Number

Objective
Time DP

1
191
130
0.986811
17.664

2
190
130
0.986416
17.556

3
189
130
0.985922
17.712

4
188
130
0.985378
17.22

5
187
130
0.984688
16.98

6
186
129
0.984176
16.728

7
185
130
0.983505
16.74

8
184
130
0.982994
16.692

9
183
129
0.982256
16.452

10
182
130
0.981518
16.008

11
181
129
0.981027
16.068

12
180
128
0.98029
16.14

13
179
126
0.979505
15.864

14
178
125
0.9784
15.336

15
177
126
0.977596
15.06

16
176
124
0.97669
14.916

17
175
125
0.975708
15.264

18
174
123
0.974926
14.628

19
173
122
0.973827
14.664

20
172
123
0.973027
14.184

21
171
122
0.971929
14.136

22
170
120
0.97076
13.944

23
169
121
0.969291
13.86

24
168
119
0.968125
13.56

25
167
118
0.966335
13.38

26
166
116
0.965042
13.284

27
165
117
0.963712
13.188

28
164
115
0.962422
13.056

29
163
114
0.960642
12.672

30
162
115
0.959188
12.732

31
161
113
0.958035
12.312

32
160
112
0.955714
12.372

33
159
110
0.954565
11.808

In Table 2, the first column provides the instances number and the second and third columns give the total weight and cost allowed. We solved all the instances to optimality using the DP scheme described above with the objective values and computational times as indicated in Table 2. Note that [7] also found these solutions, however, without being able to prove optimality. That is, the benefit of our transformation lies in applying a standard algorithm under this transformation to prove optimality of the instances within a short amount of time.

To make things more clear, we should emphasize that there are elaborate and versatile exact algorithms available that solve these instances to optimality as well as various heuristics and metaheuristics. Most interesting seem two avenues of research.

The first is the fact that we have successfully applied the transformation described in this paper in a subsequent paper [18], which not only is able to solve all benchmark instances from [12] to optimality, but for the first time also provides optimal solutions to the extended benchmark instances given in [3] that have not been solved to optimality before.

The second is the observation that the benchmark instances from [12] are still an object of intensive investigation for heuristics and metaheuristics. For instance, in a recent paper, [8], the authors provide a summary of various metaheuristics (including variable neighborhood search, tabu search, ant colony optimization, a genetic algorithm, and their own differential evolution algorithm; see Tables 2 and 3 of [8]) and none was able to solve all 33 benchmark instances to optimality (and they did not try those from [3]). While the computational times of our DP algorithm are higher than those of most of these metaheuristics, it is a standard DP approach which is easy to implement. That is, based on our results, there should be no good reason to study heuristics and metaheuristics for these instances just by themselves, unless the algorithms are applied to more general problems or at least more difficult instances than the ones from [12].

5. Conclusion

In this paper we have proposed a reformulation of the reliability redundancy allocation problem based on a binary discretization. That is, we proposed a simple discrete-binary transformation for reliability redundancy allocation. The discretization may be characterized as known in other fields, though it was not applied to this particular class of problems before. While our aim was not to investigate any new type of algorithm, we strongly believe that future research on algorithms for the redundancy allocation problem may favorably utilize this transformation as we have shown by means of a standard dynamic programming approach. Note in passing that we have applied this transformation in different context to obtain numerical results that were out of reach to the RAP community for quite some time. Moreover, for future research it should be of interest to apply our simple transformation on a wider scale for other types of reliability problems wherever deemed practical.

Conflict of Interests

The authors declare that there is no conflict of interests regarding the publication of this paper.

References

A. Azaron, H. Katagiri, K. Kato, and M. Sakawa, “A multi-objective discrete reliability optimization problem for dissimilar-unit standby systems,” OR Spectrum, vol. 29, no. 2, pp. 235–257, 2007.

A. Billionnet, “Redundancy allocation for series-parallel systems using integer linear programming,” IEEE Transactions on Reliability, vol. 57, no. 3, pp. 507–516, 2008.

D. W. Coit and A. Konak, “Multiple weighted objectives heuristic for the redundancy allocation problem,” IEEE Transactions on Reliability, vol. 55, no. 3, pp. 551–558, 2006.

S. Kulturel-Konak, A. E. Smith, and D. W. Coit, “Efficiently solving the redundancy allocation problem using tabu search,” IIE Transactions, vol. 35, no. 6, pp. 515–526, 2003.

J. E. Ramirez-Marquez, D. W. Coit, and A. Konak, “Redundancy allocation for series-parallel systems using a max-min approach,” IIE Transactions, vol. 36, no. 9, pp. 891–898, 2004.

B. Soylu and S. K. Ulusoy, “A preference ordered classification for a multi-objective maxmin redundancy allocation problem,” Computers & Operations Research, vol. 38, no. 12, pp. 1855–1866, 2011.

P.-S. You and T.-C. Chen, “An efficient heuristic for series-parallel redundant reliability problems,” Computers & Operations Research, vol. 32, no. 8, pp. 2117–2127, 2005.

N. Beji, B. Jarboui, P. Siarry, and H. Chabchoub, “A differential evolution algorithm to solve redundancy allocation problems,” International Transactions in Operational Research, vol. 19, no. 6, pp. 809–824, 2012.

G. Kanagaraj, S. G. Ponnambalam, and N. Jawahar, “A hybrid cuckoo search and genetic algorithm for reliability-redundancy allocation problems,” Computers & Industrial Engineering, vol. 66, no. 4, pp. 1115–1124, 2013.

E. Valian and E. Valian, “A cuckoo search algorithm by Lévy flights for solving reliability redundancy allocation problems,” Engineering Optimization, vol. 45, no. 11, pp. 1273–1286, 2013.

S. Martello and P. Toth, Knapsack Problems: Algorithms and Computer Implementations, John Wiley & Sons, 1990.

Y. Nakagawa and S. Miyazaki, “Surrogate constraints algorithm for reliability optimization problems with two constraints,” IEEE Transactions on Reliability, vol. 30, no. 2, pp. 175–180, 1981.

K. Y. K. Ng and N. G. F. Sancho, “A hybrid ‘dynamic programming/depth-first search’ algorithm, with an application to redundancy allocation,” IIE Transactions, vol. 33, no. 12, pp. 1047–1058, 2001.

A. Yalaoui, E. Châtelet, and C. Chu, “A new dynamic programming method for reliability & redundancy allocation in a parallel-series system,” IEEE Transactions on Reliability, vol. 54, no. 2, pp. 254–261, 2005.

M. Caserta and S. Voß, “A corridor method based hybrid algorithm for redundancy allocation,” Journal of Heuristics, 2014.

R. L. Bulfin and C. Y. Liu, “Optimal allocation of redundant components for large systems,” IEEE Transactions on Reliability, vol. 34, no. 3, pp. 241–247, 1985.

J. Onishi, S. Kimura, R. J. W. James, and Y. Nakagawa, “Solving the redundancy allocation problem with a mix of components using the improved surrogate constraint method,” IEEE Transactions on Reliability, vol. 56, no. 1, pp. 94–101, 2007.

M. Caserta and S. Voß, “An exact algorithm for the reliability redundancy allocation problem,” European Journal of Operational Research, vol. 244, no. 1, pp. 110–116, 2015.