A Discrete-Binary Transformation of the Reliability Redundancy Allocation Problem

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.


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][2][3][4][5][6][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][9][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.

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.
A nonlinear integer formulation for the RAP is RAP: where   denotes the number of parallel components within subsystem ,   ∈ [0, 1] is the reliability of component  within subsystem , with  = 1, . . .,  and  = 1, . . .,   ,    > 0 accounts for the usage of resource  of component  within subsystem  (e.g., volume and cost), and   ∈ R + provides the maximum availability of resource , with  = 1, . . ., .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 ∑    ≥ 1 must be implicitly satisfied for each subsystem .

Transformation between the Discrete RAP and the Binary RAP
Let us indicate, for any  = 1, . . .,  and  = 1, . . .,  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 ⌈log 2 (  + 1)⌉ 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 n the total number of binary variables needed to encode the discrete variable   ; that is, The discrete variable   , with 0 ≤   ≤   , is substituted by a set of n binary variables; that is,   = (  1 , . . .,   ℎ , . . .,   n ).Each of these n binary "components" corresponds to   ℎ replications of component , where with ℎ = 1, . . ., n.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 0 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 n the number of binary variables used to encode the discrete variable   ; that is, Each subsystem  is defined by =1 n binary variables.Let us call these variables, in a progressive fashion,  1 , . . .,   , . . .,    .In addition, let us indicate the progressive position of vector x where the block of binary variables corresponding to a discrete decision variable   begins with with  = 1, . . .,   .Therefore, the binary vector x  , that is, the set of binary variables used to describe subsystem , is defined in the following way: while vector x, accounting for the whole system, is defined as x = (x 1 , . . ., x  ).Finally, note that the RAP can be transformed into its corresponding binary version in O(), where It is easy to see that since n 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: RAP-B: 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  11 , . . .,  14 , accounting for the number of replications of components 1, . . ., 4 within subsystem 1.In Table 1 we summarize the relevant data, where  1 ,  1 1 , and  2  represent the reliability, cost, and weight of component  within subsystem 1, with  = 1, . . ., 4.
Let us first consider component  = 1.From [12], the maximum number of replications for each component is equal to 4; that is,   = 4. Therefore, we have n = ⌈log 2 (4 + 1)⌉ = 3.Consequently, we encode the discrete variable  11 through the use of three binary variables; that is,  11 = ( 11  12  13 ).Using (6), we compute the coefficients corresponding to the number of replications associated with each binary variable; that is,  11 = 1,  12 = 2, and  13 = 1.Therefore, as in (7), each binary variable has the following meaning: 1, if 2 replications of component 1 are taken; 0, otherwise, It is easy to see that every possible value of  11 can be expressed through an appropriate choice of values of  11 ,  12 , Table 1: Input data of subsystem 1 of the instance from [12].and  13 .The coefficients of the binary variables are computed using (9): 11 = 0.9 12 = 0.99 13 = 0.9 In a similar way, we encode variables  12 ,  13 , and  14 .Consequently, the whole set of discrete variables referring to subsystem 1 is encoded using 12 binary variables as follows: ) . (17)

Utilizing the Transformation
Dynamic programming (DP) has been used for the RAP by, for example, the authors in [12][13][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(∏  =1   ), 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.

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 The problem of finding the optimal allocation of redundant components for subsystem , with  = 1, . . ., , 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 (O(  ) where  = ∏    ).Let us indicate with   (, d) the optimal objective function value of the RAP() when only the first  components are considered, with  = 1, . . .,   , and d  = ( 1 , . . .,   ) such that   = 0, . . .,   .A forward recursion formula for this problem is where a   = ( 1  , . . .,    ) indicates the resource consumption of component , with  = 1, . . .,   .Thus,   (d) =   (  , d) indicates the optimal solution with respect to subsystem  when d units of resources are used.In order to solve the RAP, let us now define (, d) as the optimal objective function value of the RAP when the first  subsystems are considered, with  = 1, . . ., , and d  = ( 1 , . . .,   ) such that   = 0, . . .,   .A DP recursion for the "classical" series-parallel RAP (i.e.,   = 1) is the following: Obviously, (, b) is the optimal objective function value of the original RAP.The overall computational complexity of the recursive algorithm is O( 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  = 14,  = 2, and   either 3 or 4, 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.
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].

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