# A Discrete-Binary Transformation of the Reliability Redundancy Allocation Problem

Authors: Marco Caserta; Stefan Voß
Journal: Mathematical Problems in Engineering
 (2015)

---

## Abstract

Given a reliability redundancy optimization problem in itsdiscrete 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.


---

## Body

## 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, wheren different subsystems are placed in series and, within each system, si 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(1)RAP:RAP:maxR=∏i=1n‍1-∏k=1si‍1-RikyikRAP:s.t.∑i=1n∑k=1si‍gikqyik≤bq,q=1,…,QmRAP:axyik∈N,i=1,…,n,k=1,…,si,where si denotes the number of parallel components within subsystem i, Rik∈[0,1] is the reliability of component k within subsystem i, with i=1,…,n and k=1,…,si, gikq>0 accounts for the usage of resource q of component k within subsystem i (e.g., volume and cost), and bq∈R+ provides the maximum availability of resource q, with q=1,…,Q. Within the set of decision variables, each yik indicates how many times component k of subsystem i is present in an optimal configuration. It is easy to see that, in order to achieve a nonnull system reliability, the constraint ∑kyik≥1 must be implicitly satisfied for each subsystem i.


## 3. Transformation between the Discrete RAP and the Binary RAP

Let us indicate, for anyi=1,…,n and q=1,…,Q with(2)g¯iq=min⁡gikq:k=1,…,si,the minimum amount of resource q required to select at least one component within each subsystem i. In addition, let bq indicate the total amount of resource q available, and(3)b¯iq=bq-∑w≠ig¯wq,the maximum amount of resource q that could be devoted to subsystem i, 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 k within subsystem i is given by(4)uik=minqb¯iqgikq.Consequently, possible encoding for the binary RAP is obtained by creatinglog2uik+1 binary variables for each component within the system. For the sake of readability, let us focus on a single component k belonging to subsystem i and on a single resource q. Consequently, let us omit indexes i and q and let yk indicate the kth component of subsystem i. Finally, let us indicate with n^ the total number of binary variables needed to encode the discrete variable yk; that is,(5)n^=log2uk+1.The discrete variableyk, with 0≤yk≤uk, is substituted by a set of n^ binary variables; that is, yk=xk1,…,xkh,…,xkn^. Each of these n^ binary “components” corresponds to nkh replications of component k, where(6)nkh=2h-1,ifh<n^;uik-∑h=1n^-1‍2h-1,ifh=n^,with h=1,…,n^. Consequently, we have that(7)xkh=1,ifnkhreplicationsofkaretaken;0,otherwise.Therefore, coefficientsnkh are defined such that they sum up to uk, that is, the maximum number of replications of component k of subsystem i. Thus,(8)yk=∑h=1n^‍nkhxkhcan take any integer value between 0 and uk.Finally, each binary variablexkh is characterized by the following coefficients:(9)akh=nkhgkrkh=1-1-Rknkh,where Rk and gk indicate the reliability value and the amount of resource q used by component k within subsystem i, respectively.Each subsystemi can thus be expressed through the use of a set of binary variables. Let us now reintroduce subindex i. Let us indicate with n^ik the number of binary variables used to encode the discrete variable yik; that is,(10)n^ik=log2uik+1.Each subsystemi is defined by mi=∑k=1si‍n^ik binary variables. Let us call these variables, in a progressive fashion, xi1,…,xij,…,ximi. In addition, let us indicate the progressive position of vector x where the block of binary variables corresponding to a discrete decision variable yik begins with(11)pik=∑w=1k‍n^iwwith k=1,…,si. Therefore, the binary vector xi, that is, the set of binary variables used to describe subsystem i, is defined in the following way:(12)xi=xipisi-1+1,…,xipisi︸yisixi1,…,xipi1︸yi1∣xipi1+1,…,xipi2︸yi2∣………︸yik∣xipisi-1+1,…,xipisi︸yisi,while vector x, accounting for the whole system, is defined as x=x1,…,xn.Finally, note that the RAP can be transformed into its corresponding binary version inO(m), where(13)m=∑i=1n∑k=1si‍log2uik+1=∑i=1n‍mi.It is easy to see that sincen^ik 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:(14)RAP-B:RAP-B:maxR=∏i=1n‍1-∏j=1mi‍1-rijxijRAP-B:s.t.∑i=1n‍∑j=1mi‍aijqxij≤bq,q=1,…,QmRAP-B:axxij∈B,i=1,…,n,j=1,…,mi,where each xij, aijq, and rij 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 y11,…,y14, accounting for the number of replications of components 1,…,4 within subsystem 1. In Table 1 we summarize the relevant data, where R1k, g1k1, and gik2 represent the reliability, cost, and weight of component k within subsystem 1, with k=1,…,4.Table 1
Input data of subsystem1 of the instance from [12].
i
=
1
k
=
1
,
…
,
4
y
11
y
12
y
13
y
14
R
1
k
0.90
0.93
0.91
0.95
g
1
k
1
1
1
2
2
g
1
k
2
3
4
2
5Let us first consider componentk=1. From [12], the maximum number of replications for each component is equal to 4; that is, uik=4. Therefore, we have n^=log24+1=3. Consequently, we encode thediscrete variable y11 through the use of three binary variables; that is, y11=x11x12x13. Using (6), we compute the coefficients corresponding to the number of replications associated with each binary variable; that is, n11=1, n12=2, and n13=1. Therefore, as in (7), each binary variable has the following meaning: (15)x11=1,if1replicationofcomponent1istaken;0,otherwise,x12=1,if2replicationsofcomponent1aretaken;0,otherwise,x13=1,if1replicationofcomponent1istaken;0,otherwise.It is easy to see that every possible value ofy11 can be expressed through an appropriate choice of values of x11, x12, and x13. The coefficients of the binary variables are computed using (9): (16)r11=1-1-R11n11=0.9r12=1-1-R11n12=0.99r13=1-1-R11n13=0.9a111=n11g111=1×1=1a121=n12g111=2×1=2a131=n13g111=1×1=1a112=n11g112=1×3=3a122=n12g112=2×3=6a132=n13g112=1×3=3.In a similar way, we encode variablesy12, y13, and y14. Consequently, the whole set of discrete variables referring to subsystem 1 is encoded using 12 binary variables as follows:(17)x1=x11,…,x13︸y11∣x14,…,x16︸y12∣x17,…,x19︸y13∣x1,10,…,x1,12︸y14.


## 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 O(∏q=1Q‍bq), where Q 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 i, indicated with Ri. The objective function of each subsystem can easily be linearized and the reliability of single subsystem i can be rewritten as(18)Ri′=∑j=1mi‍rij′xij,where Ri′=-ln⁡1-Ri and rij′=-ln⁡1-rij. The problem of finding the optimal allocation of redundant components for subsystem i, with i=1,…,n, can be written as follows: (19)RAPi:RAPi:max∑j=1mi‍rij′xijRAPi:s.t.∑j=1mi‍aijqxij≤bqq=1,…,QmRAPi:axxij∈0,1j=1,…,mi.Problem RAP(i) is equivalent to a standard multidimensional knapsack problem with Q constraints, which can be solved in pseudopolynomial time using DP (O(mib¯) where b¯=∏qbq). Let us indicate with fi(k,d) the optimal objective function value of the RAP(i) when only the first k components are considered, with k=1,…,mi, and dT=d1,…,dQ such that dq=0,…,bq. A forward recursion formula for this problem is(20)fik,d=0ifd<aikrik′otherwisefork=1,max⁡rik′+fik-1,d-aik,maxfik-1,drik′fork=2,…,mi,where aikT=aik1,…,aikQ indicates the resource consumption of component k, with k=1,…,mi. Thus, fi(d)=fi(mi,d) indicates the optimal solution with respect to subsystem i when d units of resources are used. In order to solve the RAP, let us now define R(s,d) as the optimal objective function value of the RAP when the first s subsystems are considered, with s=1,…,n, and dT=d1,…,dQ such that dq=0,…,bq. A DP recursion for the “classical” series-parallel RAP (i.e., ki=1) is the following:(21)Rs,d=f1dfors=1,maxw=0,…,dfsw×Rs-1,d-wfors=2,…,n.Obviously,R(n,b) is the optimal objective function value of the original RAP. The overall computational complexity of the recursive algorithm is O(nb¯2).


### 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 n=14, Q=2, and mi either 3 or 4, depending on the value of i; 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
W
C
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.808In Table2, the first column provides the instances number and the second and third columns give the total weight W and cost C 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].


## 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 i, indicated with Ri. The objective function of each subsystem can easily be linearized and the reliability of single subsystem i can be rewritten as(18)Ri′=∑j=1mi‍rij′xij,where Ri′=-ln⁡1-Ri and rij′=-ln⁡1-rij. The problem of finding the optimal allocation of redundant components for subsystem i, with i=1,…,n, can be written as follows: (19)RAPi:RAPi:max∑j=1mi‍rij′xijRAPi:s.t.∑j=1mi‍aijqxij≤bqq=1,…,QmRAPi:axxij∈0,1j=1,…,mi.Problem RAP(i) is equivalent to a standard multidimensional knapsack problem with Q constraints, which can be solved in pseudopolynomial time using DP (O(mib¯) where b¯=∏qbq). Let us indicate with fi(k,d) the optimal objective function value of the RAP(i) when only the first k components are considered, with k=1,…,mi, and dT=d1,…,dQ such that dq=0,…,bq. A forward recursion formula for this problem is(20)fik,d=0ifd<aikrik′otherwisefork=1,max⁡rik′+fik-1,d-aik,maxfik-1,drik′fork=2,…,mi,where aikT=aik1,…,aikQ indicates the resource consumption of component k, with k=1,…,mi. Thus, fi(d)=fi(mi,d) indicates the optimal solution with respect to subsystem i when d units of resources are used. In order to solve the RAP, let us now define R(s,d) as the optimal objective function value of the RAP when the first s subsystems are considered, with s=1,…,n, and dT=d1,…,dQ such that dq=0,…,bq. A DP recursion for the “classical” series-parallel RAP (i.e., ki=1) is the following:(21)Rs,d=f1dfors=1,maxw=0,…,dfsw×Rs-1,d-wfors=2,…,n.Obviously,R(n,b) is the optimal objective function value of the original RAP. The overall computational complexity of the recursive algorithm is O(nb¯2).


## 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 n=14, Q=2, and mi either 3 or 4, depending on the value of i; 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
W
C
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.808In Table2, the first column provides the instances number and the second and third columns give the total weight W and cost C 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.



---

*Source: 276234-2015-05-25.xml*