Reliability optimization of linear consecutive k-out-of-n: F systems with Birnbaum importance–based quantum genetic algorithm

Abstract

Component assignment problem is a common challenge of reliability optimization, which is a non-deterministic polynomial hard problem widely used in the linear consecutive k-out-of-n systems. In consideration of the advantages of quantum computing and importance measure, this article proposed a novel algorithm, which is Birnbaum importance–based quantum genetic algorithm, to improve the efficiency and accuracy for solving component assignment problem. First, the model of reliability optimization for linear consecutive k-out-of-n systems is established. Second, the detailed procedure of Birnbaum importance–based quantum genetic algorithm is introduced to solve the component assignment problem. Moreover, the effectiveness and the convergence of the quantum genetic algorithm, Birnbaum importance–based genetic local search, and Birnbaum importance–based quantum genetic algorithm is discussed through two comparative experiments. Finally, the case of production monitor systems is introduced to illustrate the effectiveness of Birnbaum importance–based quantum genetic algorithm comparing with the Birnbaum importance–based two-stage approach.

Introduction

Reliability optimization^1,2 has become a significant concern in recent years, especially for large systems consisting of a large number of subsystems, modules, and components, such as heavy-duty pallet system ³ and complex engineering systems under epistemic uncertainties. ⁴ Component assignment problem (CAP) is a common challenge of reliability optimization for some typical systems, such as consecutive k-out-of-n systems and two terminal networks. In a system, there are n positions and n components with different reliability, and the CAP considers how to assign n components in n different positions for obtaining the arrangement with maximum system reliability. CAP actually can be regarded as a problem at the design phase for maximizing the system reliability without considering the cost.^5,6 Many practical engineering systems also need to consider CAP, such as the pipeline system and street light system. The pipeline system is a linear consecutive k-out-of-n: F system (Lin/Con/2/n: F system) because each pump can give the pressure to transport the oil for two-unit distance. The street light system, which is a Lin/Con/2/n: F system, aims to illuminate all the area because two adjacent areas can be lighten up by one lamp.

When the scale of the system is small, the optimal arrangement can be determined by the enumeration method, which is a classic method for solving the CAP accurately. However, the efficiency of the enumeration method strongly depends on the scale of the optimization problem. It is hard to find the optimal solution within a reasonable time because CAP is a non-deterministic polynomial hard (NP-hard) problem. With the assumption that each component has the constant reliability, some researchers^7,8 considered CAP for parallel-series system and series-parallel system using the optimization and Schur-convex function.

However, some complex system in engineering practice cannot be divided into the series or parallel structure. Therefore, the reliability optimization of CAP is quite complicated in these cases. The Birnbaum importance (BI) measure is proposed in 1968 to measure the effect of component reliability on the system reliability. ⁹ Boland et al. ¹⁰ reduced the solution space by eliminating the invalid assignments based on the importance of positions. When the order of components’ reliabilities is known, the optimal arrangement can be determined based on the order of component reliability, and the optimal assignment is noted as the invariant optimal assignments. The BI-based heuristics can be used to obtain the optimal arrangements by assigning higher reliable components to the position with the higher importance measure. Zuo and Kuo ¹¹ presented two algorithms, which are ZKA and ZKB heuristics, based on the pairwise exchange based on the importance of positions and the system reliability after exchanging to solve the CAP for a linear consecutive k-out-of-n system. Lin and Kuo ¹² further put forward a greedy algorithm named as LKA heuristic. LKA assigns the lowest reliable component into all positions at first and then assigns the component with the highest reliability into the position with the highest BI. Yao et al. ¹³ suggested the Birnbaum importance–based two-stage approach (BITA) to solve the CAP, which combines the LK-type heuristic with ZK-type heuristic. Si et al. ¹⁴ proposed the generalized BI considering the boundary of component reliability, which is a new way of measuring the importance of position with different reliability.

Many researchers focused on quantum computing in recent years because of its parallelism and high effectiveness. Narayanan and Moore ¹⁵ incorporated “many universes” into the genetic algorithm and constructed the quantum inspired genetic algorithm. The proposed quantum genetic algorithm (QGA) is based on the genetic algorithm and quantum computing, whose parallelism is essential for quantum acceleration. Han and Kim ¹⁶ applied the quantum state vector table into the genetic codes for adjusting the chromosome by quantum rotation. Han and Kim ¹⁷ proposed a quantum-inspired evolutionary algorithm based on the quantum bit and superposition of states, where a quantum gate is introduced as a variation operator to drive the individuals toward better solutions. Han and Kim ¹⁸ improved the efficiency of the proposed quantum evolutionary algorithm by a new termination criterion. Talbi et al. ¹⁹ proposed a novel algorithm for solving the traveling salesman problem, which was inspired based on genetic algorithms and quantum computing. The obtained result was significantly better than that of the standard genetic algorithm. Wang and Wang ²⁰ presented a hybrid QGA, which performed the crossover and mutation on quantum bits with more advantages comparing with other QGAs. Wang et al. ²¹ proposed a quantum-inspired ant algorithm to solve the knapsack problem. Singh and Mahapatra ²² used quantum-behaved particle swarm optimization for a job shop scheduling problem due to its advanced global search ability. Dahi et al. ²³ proposed a variant of the quantum-inspired genetic algorithm based on a novel quantum gate to solve the antenna positioning problem. Various experiments with different dimensions have demonstrated the efficiency and robustness of the proposed algorithm.

Since the 1970s, heuristic algorithms gradually applied to reliability optimization. Heuristic algorithms can obtain the optimal or approximate optimal solutions based on the greedy strategy, in which the higher reliable components should be assigned to the position with the highest importance, and the advantages of heuristics become significantly for the large scale system. The meta-heuristic algorithm, such as the genetic algorithm,^24,25 can avoid the local optimal solution, which can find a better solution than heuristics. As a typical evolutionary algorithm, ant colony optimization is widely used to solve the NP-hard combinational optimization problem.^26,27 Shingyoch et al. ²⁸ proposed two types of simulated annealing algorithms to obtain quasi-optimal solutions for a circular consecutive-k-out-of-n: F system, which can exclude the equivalent assignment efficiently. Cai et al. ²⁹ proposed the GA based on the importance to improve the system performance for multicomponent maintenance, and the local search makes GA more effective and efficient. Yao et al. ³⁰ constructed an integrated genetic algorithm, which referred as Birnbaum importance–based genetic local search (BIGLS). The local search of BIGLS is based on the ZK-type heuristics, which can gradually reduce the solution space and find the optimal solution effectively. Comparing with the standard genetic algorithm, BIGLS can improve the accuracy and the convergence speed for CAP. Cai et al. ³¹ proposed a BI-based genetic algorithm to search the near global optimal solution for Lin/Con/k/n systems. Combining the evolutionary algorithms with local search method based on the heuristics can improve the efficiency of CAP.^32,33 Zhao et al. ³⁴ proposed the parallel genetic algorithm to solve the extended CAP considering the reconfigurable cost.

According to the literature review, the BI, which is introduced as the local search method, is effective for solving the CAP. At the same time, the quantum computing can also speed up the efficiency of solving optimization problems. Therefore, combing the quantum computing with BI is a better idea to improve the effectiveness and efficiency of solving the CAP.

The remaining of the paper is organized as follows. Section “Modeling of reliability optimization for CAP” describes the modeling of reliability optimization for CAP. Section “BIQGA” introduces the procedures of Birnbaum importance–based quantum genetic algorithm (BIQGA) in detail, especially for the quantum coding method, the quantum decoding method, and the quantum rotation. Comparing with the standard genetic algorithm, QGA, and BIGLS, section “Comparative experiments” illustrates the effectiveness and convergence of BIQGA through two numerical experiments. The production monitor system is introduced in section “A case study of production monitor systems” to discuss the effectiveness of BIQGA, which compares with BITA. Section “Conclusion” summarizes the main contribution of the research.

Modeling of reliability optimization for CAP

The following assumptions are necessary for CAP: ² (1) the system and each component is a binary state, such as working and failure; (2) the structure function of system is determined; (3) each component is independent; and (4) system and components are non-repairable.

The objective of CAP is to maximize the system reliability by assigning components to the positions in the system, and the system reliability can be calculated based on the structure function and the reliability of components ³⁵ as follows

$$h_f(p(n),k)=\sum _{i=n-k+1}^n{p}_i\left(\underset{j=i+1}{\overset{n}{\Pi }}{q}_j\right)·h_f(p(i-1),k)$$

(1)

where $p_i$ is the reliability of component i; $q_i=1-p_i$ is the unreliability of component i; $p(i-1)$ represents the vector of component reliability from component 1 to component (i – 1), which can be noted as $p(i-1)=(p_1,p_2,\dots ,p_{i-2},p_{i-1})$ ; $p(n)$ represents the vector of component reliability from component 1 to component n, which can be noted as $p(n)=(p_1,p_2,\dots ,p_{n-1},p_n)$ ; $h_f(p(n),k)$ is the reliability of Lin/Con/k/n: F system which consists of n components from component 1 to component n.

During the process of assignment, each position should have one component, and each component should be assigned to one position. If there are n components in a system, the solution space is composed of n! different permutations. The mathematical model of CAP is determined as follows considering the maximum system reliability and constraints of positions and component reliability.

$$\max :R_L(x_{\mathrm{ij}};k,n,\mathit{p})=h_f(p(n),k)$$

(2)

$$s.t.p_i=\sum _{j=1}^n{x}_{\mathrm{ij}}{\tilde{p}}_j$$

(3)

$$\sum _{j=1}^n{x}_{\mathrm{ij}}=1$$

(4)

$$\sum _{i=1}^n{x}_{\mathrm{ij}}=1$$

(5)

$$x_{\mathrm{ij}}=\{0,1\},(i=1,2,\dots ,n;j=1,2,\dots ,n)$$

(6)

where $x_{\mathrm{ij}}$ is the element in the assignment matrix for assignment before assigning components, whose element is 0 or 1, $x_{\mathrm{ij}}=1$ represents the component j is assigned to the position i; $R_L(x_{\mathrm{ij}};k,n,\mathit{p})$ is the system reliability of Lin/Con/k/n: F systems, and $\mathit{p}=p(n)=(p_1,p_2,\dots ,p_i,\dots ,p_n)$ ; $p_i$ is the reliability of component in position i after assigning components; ${\tilde{p}}_j$ is the reliability of component in position j before assigning components; $\sum _{j=1}^n{x}_{\mathrm{ij}}=1$ represents the position i only has one component; $\sum _{i=1}^n{x}_{\mathrm{ij}}=1$ represents the component j should be assigned to one position.

BIQGA

The feature and role of quantum computing focus on the quantum-bit (q-bit), quantum superposition, and quantum rotation gate in the improved genetic algorithm. Q-bit and quantum superposition are used in the coding method, and quantum rotation gate is used in the quantum rotation for updating the individuals.

Quantum coding method

Quantum computing is inspired by the quantum-mechanical phenomena, such as superposition and interference between a pair of quantum. A single q-bit $|\phi 〉$ is a linear sum of the basis states $|\phi 〉=\alpha |0〉+\beta |1〉$ , where $\alpha$ and $\beta$ are the probability amplitude of the corresponding states. The values ${\left|\alpha \right|}^2$ and ${\left|\beta \right|}^2$ denote the probability of collapse on the basis states $|0〉$ and $|1〉$ , respectively. $\alpha$ and $\beta$ should satisfy the normalization condition, ${\left|\alpha \right|}^2+{\left|\beta \right|}^2=1$ . If there are n basic states $|{\phi }_i〉(i=1,\dots ,n)$ , $|\phi 〉=\sum _i{c}_i|{\phi }_i〉$ is the linear superposition of $|{\phi }_i〉$ , where $c_i$ is the probability amplitude of $|{\varphi }_i〉$ , and ${\left|c_i\right|}^2$ is the probability of collapse on the basis states $|{\phi }_i〉$ .

The coding method in BIQGA takes advantage of q-bit and superposition to represent the possible assignment of CAP. The quantum population of generation t can be noted as $Q(t)=\{q_1^t,q_2^t,\dots ,q_n^t\}$ , and the chromosome with quantum information is defined as follows

$$q_j^t=\left[\begin{array}{c}{\alpha }_1^t|\hfill \\ \multicolumn{1}{c}{{\beta }_1^t|}\end{array}\begin{array}{c}{\alpha }_2^t|\hfill \\ \multicolumn{1}{c}{{\beta }_2^t|}\end{array}\begin{array}{c}\dots \hfill \\ \multicolumn{1}{c}{\dots }\end{array}\begin{array}{c}|{\alpha }_m^t\hfill \\ \multicolumn{1}{c}{|{\beta }_m^t}\end{array}\right]$$

where m is the size of q-bit, which is determined by the number of basic states. The coding method based on the q-bit is a better way to guarantee the individuals’ diversity.

Coding method determines the searching efficiency of the algorithm. For the system with n components and n positions, $P=\{P_1,\dots ,P_{n-1},P_n\}$ is the permutation of n components. The vector set $A=\{a_1,\dots ,a_i,\dots ,a_{n-1}\}$ , which is a one-to-one mapping with the set P, can be determined by counting the number of components with the lower reliability in the back positions comparing with the current component. Therefore, a_i is the number of $p_j$ which satisfies $p_j<p_i,$ where $i=1,\dots ,n-1,j=i+1,\dots ,n$ . For example, the permutation of a system is $P=\{5,3,4,2,1\}$ , and we can obtain the corresponding $A=\{4,2,2,1\}$ based on the mentioned rules. On the contrary, if $A=\{2,3,2,1\}$ is known, we can also determine the permutation is $P=\{3,5,4,2,1\}$ . For the coding process of BIQGA, $A=\{a_1,\dots ,a_{n-2},a_{n-1}\}$ can be represented by the quantum individual j as follows, which is a possible assignment of n components

$$\left[\begin{array}{cccccc}\left[\begin{array}{c}{\alpha }_{11}\hfill \\ \multicolumn{1}{c}{{\beta }_{11}}\end{array}\right]\hfill & \left[\begin{array}{c}{\alpha }_{12}\hfill \\ \multicolumn{1}{c}{{\beta }_{12}}\end{array}\right]\hfill & \left[\begin{array}{c}inf\hfill \\ \multicolumn{1}{c}{inf}\end{array}\right]\hfill & \left[\begin{array}{c}inf\hfill \\ \multicolumn{1}{c}{inf}\end{array}\right]\hfill & \left[\begin{array}{c}inf\hfill \\ \multicolumn{1}{c}{inf}\end{array}\right]\hfill & \left[\begin{array}{c}inf\hfill \\ \multicolumn{1}{c}{inf}\end{array}\right]\hfill \\ \multicolumn{1}{c}{\left[\begin{array}{c}{\alpha }_{21}\hfill \\ \multicolumn{1}{c}{{\beta }_{21}}\end{array}\right]}& \left[\begin{array}{c}{\alpha }_{22}\hfill \\ \multicolumn{1}{c}{{\beta }_{22}}\end{array}\right]\hfill & \left[\begin{array}{c}{\alpha }_{23}\hfill \\ \multicolumn{1}{c}{{\beta }_{23}}\end{array}\right]\hfill & \left[\begin{array}{c}inf\hfill \\ \multicolumn{1}{c}{inf}\end{array}\right]\hfill & \left[\begin{array}{c}inf\hfill \\ \multicolumn{1}{c}{inf}\end{array}\right]\hfill & \left[\begin{array}{c}inf\hfill \\ \multicolumn{1}{c}{inf}\end{array}\right]\hfill \\ \multicolumn{1}{c}{⋮}& ⋮\hfill & ⋮\hfill & ⋮\hfill & ⋮\hfill & ⋮\hfill \\ \multicolumn{1}{c}{\left[\begin{array}{c}{\alpha }_{n-2,1}\hfill \\ \multicolumn{1}{c}{{\beta }_{n-2,1}}\end{array}\right]}& \left[\begin{array}{c}{\alpha }_{n-2,2}\hfill \\ \multicolumn{1}{c}{{\beta }_{n-2,2}}\end{array}\right]\hfill & \left[\begin{array}{c}{\alpha }_{n-2,3}\hfill \\ \multicolumn{1}{c}{{\beta }_{n-2,3}}\end{array}\right]\hfill & \cdots \hfill & \left[\begin{array}{c}{\alpha }_{n-2,n-1}\hfill \\ \multicolumn{1}{c}{{\beta }_{n-2,n-1}}\end{array}\right]\hfill & \left[\begin{array}{c}inf\hfill \\ \multicolumn{1}{c}{inf}\end{array}\right]\hfill \\ \multicolumn{1}{c}{\left[\begin{array}{c}{\alpha }_{n-1,1}\hfill \\ \multicolumn{1}{c}{{\beta }_{n-1,1}}\end{array}\right]}& \left[\begin{array}{c}{\alpha }_{n-1,2}\hfill \\ \multicolumn{1}{c}{{\beta }_{n-1,2}}\end{array}\right]\hfill & \left[\begin{array}{c}{\alpha }_{n-1,3}\hfill \\ \multicolumn{1}{c}{{\beta }_{n-1,3}}\end{array}\right]\hfill & \left[\begin{array}{c}{\alpha }_{n-1,4}\hfill \\ \multicolumn{1}{c}{{\beta }_{n-1,4}}\end{array}\right]\hfill & \cdots \hfill & \left[\begin{array}{c}{\alpha }_{n-1,n}\hfill \\ \multicolumn{1}{c}{{\beta }_{n-1,n}}\end{array}\right]\hfill \end{array}\right]$$

Quantum decoding method

Population measurement is the decoding procedure of quantum individuals, which can obtain the assignment state P(t) and rotation matrix U(t). Based on the decoding method, the state of individual j can decode into A, and the relative rotation matrix is generated as B. The corresponding permutation P can be determined based on A because of the one-to-one mapping relationship between A and P.

The pseudo-code of the decoding procedure for generating A and B is as follows:

Determine the individual j and the relative rotation matrix after coding; for $i=1:(n-1)$  set l = 0  while l == 0    $j=\mathrm{randi}(i+1);$    $x=\mathrm{randi}(2);$   $\mathrm{if}x>{\left|{\beta }_{\mathrm{ij}}\right|}^2$  Set l = 1;   A(i) = j–1;   B(i,1: i + 1) = 0;   B(i, x) = 1;  end if  end while end for

Quantum rotation

The purpose of quantum rotation is to update populations to enlarge the diversity of the individuals, which is better to find the optimal solution. BIQGA does not need to consider the crossover and mutation operator because the quantum rotation has the same function to increase the diversity of individuals. The quantum rotation gate is used to renew the population. The update operation of the ijth quantum bit $[{\alpha }_{\mathrm{ij}},{\beta }_{\mathrm{ij}}{]}^T$ is shown as

$$\left[\begin{array}{c}\widetilde{{\alpha }_{\mathrm{ij}}}\hfill \\ \multicolumn{1}{c}{\widetilde{{\beta }_{\mathrm{ij}}}}\end{array}\right]=[\begin{array}{c}\cos {\theta }_{\mathrm{ij}}\hfill \\ \multicolumn{1}{c}{\sin {\theta }_{\mathrm{ij}}}\end{array}\begin{array}{c}-\sin {\theta }_{\mathrm{ij}}\hfill \\ \multicolumn{1}{c}{\cos {\theta }_{\mathrm{ij}}}\end{array}]\left[\begin{array}{c}{\alpha }_{\mathrm{ij}}\hfill \\ \multicolumn{1}{c}{{\beta }_{\mathrm{ij}}}\end{array}\right]$$

where the value of ${\theta }_{\mathrm{ij}}$ is shown in Table 1.

Table 1.

Reference value of ${\theta }_{\mathrm{ij}}$ .

${\alpha }_{\mathrm{ij}}$	${\beta }_{\mathrm{ij}}$	The element of the rotation matrix	Rotation angle ${\theta }_{\mathrm{ij}}$
>0	>0	1	+θ
>0	>0	0	–θ
<0	>0	1	–θ
<0	>0	0	+θ
>0	<0	1	–θ
>0	<0	0	+θ
<0	<0	1	+θ
<0	<0	0	–θ

The value of $\theta$ can affect the convergence speed directly, and the larger $\theta$ may cause premature convergence. Table 1 presents the method to determine the reference value of ${\theta }_{\mathrm{ij}}$ , which is based on the value of ${\alpha }_{\mathrm{ij}}$ , ${\beta }_{\mathrm{ij}}$ , and the element of the rotation matrix. According to a large number of numerical experiments, the advantage of the proposed algorithm can be entirely taken when $\theta =\pi /25$ .

Procedures of BIQGA

Quantum computing makes the encoding and decoding process efficiently. BI measure can find the weak link of the system directly, which can obtain better system reliability through the BI-based heuristics. Yao et al. ³⁰ proposed the BI-based local search in 2014, which is an effective BI-based heuristic to find the local optimal solution. BIQGA is proposed to solve CAP combing the advantages of quantum computing and BI-based local search, which can also reduce the coefficients such as the probability of crossover and mutation in the genetic algorithm. The procedures of BIQGA, as shown in Figure 1, are described as follows:

• Step 1: Determine the appropriate objective function and select the proper solution space of the CAP pattern.

• Step 2: Ascertain the decoding method and coding method.

• Step 3: Generate an initial population C(t) with N individuals. Where t=0, and the initial value of (α _ij , β _ij ) is set as $(1/\sqrt{2},1/\sqrt{2})$ .

• Step 4: Measure initial population; get the state P(t) and its rotation matrix U(t).

• Step 5: Evaluate the fitness of each state P(t).

• Step 6: Record the maximum fitness value F_m(t), the optimal state P_m(t), and the corresponding rotation matrix U_m(t).

• Step 7: Perform the BI-based local search on P_m(t).

• Step 8: After the local search, measure and record the state P_s(t), its fitness value F_s(t), and the corresponding rotation matrix U_s(t).

• Step 9: If the termination condition is satisfied, stop the algorithm and output P_s(t) and its fitness value F_s(t).

• Step 10: If the termination condition is not satisfied, perform rotation U_m(t) on C(t) to get the C(t + 1).

• Step 11: Measure C(t + 1) and the state P(t + 1).

• Step 12: Evaluate the fitness of each state in P(t + 1).

• Step 13: Perform the BI-based local search on the optimal state P_m(t + 1).

• Step 14: Record the state P_s(t + 1), its fitness value F_s(t + 1), and the corresponding rotation matrix U_s(t + 1).

• Step 15: If F_s(t + 1) > F_s(t), set P_s(t) = P_s(t + 1) and F_s(t) = F_s(t + 1). Otherwise, the optimal state will not be updated.

• Step 16: Set t = t + 1, and return to Step 9.

Figure 1.

Flowchart of BIQGA.

Comparative experiments

The numerical experiments are realized by MATLAB 2016b with the processor Intel(R) Core(TM) i7-7700HQ, CPU at 2.80 GHz, and RAM 8 GB. In this article, we set the elements of the first-generation ${{\alpha }_i}_j$ and ${{\beta }_i}_j$ as $\sqrt{2}/2$ at Step 3. In order to illustrate the effectiveness of BIQGA which introduces the BI heuristics, two experiments are implemented comparing with three algorithms (GA, QGA, and BIGLS). In this article, the standard GA is a common genetic algorithm to solve the CAP, including the steps of selection, crossover, and mutation. QGA is a simplified BIQGA by removing Steps 7, 8, 13, 14, and 15 associated with the BI-based local search method. The parameters, such as the maximum generation, and the population size, should be set as the same value. There are three important factors (the system structure, the reliabilities of components, and the positions of components) in CAP for determining the system reliability. For two comparative experiments, we need to select several systems with different k and n to illustrate the performance of BIQGA in each experiment. All the numerical experiments are performed in Lin/Con/k/n: F systems.

Experiment design

The system reliability ratio (SRR) is introduced here to evaluate the performance of QGA or BIQGA based on the optimal solution as follows

$$\mathrm{SRR}=\frac{R_{\mathrm{qga}}}{R_{\mathrm{op}}}$$

(7)

where $R_{\mathrm{qga}}$ represents the optimal system reliability obtained by QGA or BIQGA; $R_{\mathrm{op}}$ represents the system reliability with the optimal solution. The optimal solutions of small systems (the number of components is less than or equal to eight) are generated based on the enumeration method, and the optimal solutions of large systems are generated based on the GA.

The components with different reliabilities levels may impact on the performance of the algorithm. The components in this part include three types of reliability: low, high, and arbitrary reliability which are randomly distributed in the range [0.01, 0.2], [0.8, 0.99], and [0.01, 0.99], respectively. One hundred instances will be implemented and regarded as an experiment of the system. The mean of system reliability ratio (MSRR) is introduced to evaluate the performance of algorithms by eliminating the randomness for each system over the 100 instances.

In Experiment I, we select 15 typical Lin/Con/k/n: F systems shown in Table 2 and record four criteria including MSRR, Achievement, Time, and Fitness. “Achievement” counts the times that the solution of intelligent algorithms (such as QGA, BIQGA, and BIGLS) is better than the optimal solution. “Time” represents the average running time of each experiment with 100 instances. “Fitness” represents the median, maximum, minimum, and average of 100 instances. The population size of GA, QGA, BIQGA, and BIGLS is 50, and the maximum generation of four algorithms is 200. Note that in order to compare the performance of the proposed two algorithms with the fair condition, the population number of GA is 50, and the maximum generation is 200.

Table 2.

Symbol of 15 typical Lin/Con/k/n: F systems.

F system	Symbol	F system	Symbol
Lin/Con/2/5: F	F1	Lin/Con/3/5: F	F2
Lin/Con/2/6: F	F3	Lin/Con/3/6: F	F4
Lin/Con/2/10: F	F5	Lin/Con/3/10: F	F6
Lin/Con/3/20: F	F7	Lin/Con/4/20: F	F8
Lin/Con/5/20: F	F9	Lin/Con/3/30: F	F10
Lin/Con/4/30: F	F11	Lin/Con/5/30: F	F12
Lin/Con/3/50: F	F13	Lin/Con/4/50: F	F14
Lin/Con/5/50: F	F15

In Experiment II, we select four typical systems (Lin/Con/3/8: F system, Lin/Con/3/16: F system, Lin/Con/4/24: F system, and Lin/Con/5/32: F system) to compare the convergence of GA, QGA, and BIQGA. For each system, we record the fitness value of each generation and perform three algorithms 30 times with the same initial component reliability for the low, high, and arbitrary system, respectively. Finally, we draw the figure for average fitness value with the increase of generations for three kinds of systems. Based on the changes in fitness, we can analyze the convergence of three algorithms. The population size of GA, QGA, and BIQGA is 50, and the maximum generation of three algorithms is 500. In order to analyze the changes in fitness, we also revised the termination condition that the algorithm will stop when the generation reaches the maxima.

Results analysis of Experiment I

In order to illustrate the performance of the QGA, BIQGA, and BIGLS, the results of Experiment I are listed in Tables 3–5. The results of the 15 typical systems with low, high, and arbitrary reliable components are shown in these three tables, respectively, considering the achievement, MSRR, the fitness (median, maximum, minimum, and average).

Table 3.

Results of Experiment I for low reliable systems.

Systems	Algo.	Achi	MSRR	Median	Max	Min	Ave.	Time
F1	QGA	32	1	0.026885	0.044594	0.002518	0.025311	0.227569
	BIQGA	32	1	0.026885	0.044594	0.002518	0.025311	0.247204
	BIGLS	32	1	0.026885	0.044594	0.002518	0.025311	0.055093
F2	QGA	49	1	0.201552	0.247061	0.095517	0.190307	0.196099
	BIQGA	49	1	0.201552	0.247061	0.095517	0.190307	0.212038
	BIGLS	49	1	0.201552	0.247061	0.095517	0.190307	0.046476
F3	QGA	33	1	0.007003	0.018964	0.000681	0.007246	0.213218
	BIQGA	33	1	0.007003	0.018964	0.000681	0.007246	0.215027
	BIGLS	33	1	0.007003	0.018964	0.000681	0.007246	0.058469
F4	QGA	32	1	0.069463	0.124841	0.022866	0.070460	0.206127
	BIQGA	32	1	0.069463	0.124841	0.022866	0.070460	0.208775
	BIGLS	32	1	0.069463	0.124841	0.022866	0.070460	0.055856
F5	QGA	63	1.018629	0.000155	0.000557	0.000028	0.000212	0.309500
	BIQGA	97	1.046541	0.000157	0.000575	0.000029	0.000217	0.215291
	BIGLS	100	1.052735	0.000161	0.000575	0.000029	0.000218	0.157922
F6	QGA	73	1.019982	0.013585	0.026700	0.002421	0.013726	0.297699
	BIQGA	99	1.044007	0.013871	0.026896	0.002493	0.014031	0.209201
	BIGLS	100	1.044518	0.013871	0.026896	0.002493	0.014037	0.159477
F7	QGA	71	1.122465	0.000046	0.000197	0.000003	0.000054	0.560532
	BIQGA	100	1.592788	0.000067	0.000249	0.000005	0.000075	0.371733
	BIGLS	100	1.599664	0.000067	0.000249	0.000005	0.000075	0.949968
F8	QGA	68	1.037746	0.001966	0.005998	0.000707	0.002053	0.560788
	BIQGA	98	1.343878	0.002479	0.006538	0.000971	0.002619	0.352410
	BIGLS	100	1.354618	0.002479	0.006543	0.000998	0.002637	0.981922
F9	QGA	67	1.025413	0.014778	0.031406	0.005376	0.015217	0.577095
	BIQGA	100	1.232325	0.018017	0.035468	0.006322	0.018107	0.372703
	BIGLS	100	1.237629	0.018022	0.035468	0.006322	0.018187	1.039216
F10	QGA	69	1.119531	1.14E–07	8.61E–07	3.39E–09	1.61E–07	0.906615
	BIQGA	99	2.7709	2.97E–07	1.70E–06	9.90E–09	3.65E–07	0.600875
	BIGLS	100	2.811298	3.00E–07	1.71E–06	1.05E–08	3.69E–07	3.188760
F11	QGA	67	1.089817	0.000040	0.000126	0.000004	0.000044	0.872583
	BIQGA	100	2.036565	0.000077	0.000194	0.000009	0.000078	0.596126
	BIGLS	100	2.039067	0.000077	0.000194	0.000009	0.000078	3.287267
F12	QGA	61	1.0358	0.001004	0.003546	0.000141	0.001046	0.890543
	BIQGA	99	1.634412	0.001615	0.004967	0.000279	0.001595	0.609276
	BIGLS	100	1.651924	0.001625	0.004967	0.000279	0.001613	3.575562
F13	QGA	64	1.164358	6.59E–13	1.40E–11	3.28E–14	1.36E–12	1.497337
	BIQGA	100	9.430306	5.73E–12	4.32E–11	2.00E–13	7.98E–12	1.241025
	BIGLS	100	9.921049	6.03E–12	4.46E–11	5.98E–13	8.18E–12	17.101576
F14	QGA	74	1.119098	1.58E–08	1.41E–07	1.74E–09	2.36E–08	1.481712
	BIQGA	100	4.072464	5.78E–08	3.57E–07	7.55E–09	7.50E–08	1.249714
	BIGLS	100	4.178039	5.90E–08	3.60E–07	9.24E–09	7.61E–08	19.065585
F15	QGA	66	1.051558	0.000004	0.000017	0.000001	0.000005	1.499545
	BIQGA	99	2.842902	0.000010	0.000041	0.000002	0.000011	1.328074
	BIGLS	100	2.864608	0.000010	0.000041	0.000002	0.000011	21.983825

MSRR: mean of system reliability ratio; QGA: quantum genetic algorithm; BIQGA: Birnbaum importance–based quantum genetic algorithm; BIGLS: Birnbaum importance–based genetic local search.

Table 4.

Results of Experiment I for high reliable systems.

Systems	Algo.	Achi	MSRR	Median	Max	Min	Ave.	Time
F1	QGA	94	1	0.979554	0.995598	0.917261	0.975486	0.233423
	BIQGA	94	1	0.979554	0.995598	0.917261	0.975486	0.254233
	BIGLS	85	0.999985	0.979384	0.995598	0.917261	0.975471	0.057665
F2	QGA	89	1	0.999259	0.999894	0.990016	0.998584	0.211919
	BIQGA	89	1	0.999259	0.999894	0.990016	0.998584	0.230794
	BIGLS	81	0.999998	0.999259	0.999886	0.990016	0.998582	0.052182
F3	QGA	93	1	0.967702	0.993720	0.895721	0.962380	0.220503
	BIQGA	93	1	0.967702	0.993720	0.895721	0.962380	0.225769
	BIGLS	47	0.999814	0.967645	0.993720	0.895559	0.962200	0.062065
F4	QGA	93	1	0.998498	0.999966	0.991388	0.997873	0.231276
	BIQGA	93	1	0.998498	0.999966	0.991388	0.997873	0.233912
	BIGLS	58	0.999993	0.998491	0.999966	0.991388	0.997867	0.071040
F5	QGA	67	1.000433	0.937123	0.983203	0.856619	0.932689	0.308574
	BIQGA	74	1.000642	0.938313	0.983763	0.856108	0.932880	0.296991
	BIGLS	38	0.999118	0.935880	0.982241	0.855082	0.931457	0.168164
F6	QGA	61	1.000032	0.996272	0.999507	0.982417	0.995554	0.300487
	BIQGA	71	1.000053	0.996259	0.999489	0.982171	0.995576	0.292402
	BIGLS	32	0.999895	0.996106	0.999478	0.982207	0.995418	0.177582
F7	QGA	64	1.00012	0.990229	0.996523	0.963320	0.989414	0.585309
	BIQGA	79	1.000373	0.990491	0.996834	0.963494	0.989664	0.488282
	BIGLS	79	1.000499	0.990534	0.997218	0.963920	0.989789	0.764427
F8	QGA	60	1.000015	0.999135	0.999905	0.997242	0.999061	0.540515
	BIQGA	68	1.000031	0.999149	0.999903	0.997224	0.999077	0.470240
	BIGLS	83	1.000049	0.999200	0.999916	0.997299	0.999095	0.799731
F9	QGA	65	1.000002	0.999943	0.999990	0.999770	0.999927	0.542336
	BIQGA	80	1.000004	0.999945	0.999990	0.999773	0.999929	0.474398
	BIGLS	86	1.000006	0.999945	0.999990	0.999774	0.999931	0.891655
F10	QGA	67	1.000346	0.979999	0.991976	0.954826	0.979202	0.844908
	BIQGA	82	1.000904	0.980481	0.993123	0.956129	0.979747	0.718343
	BIGLS	92	1.001711	0.981700	0.993258	0.957129	0.980535	1.807833
F11	QGA	57	1.00002	0.998530	0.999657	0.995481	0.998459	0.884345
	BIQGA	78	1.000079	0.998600	0.999708	0.995769	0.998518	0.700263
	BIGLS	95	1.000152	0.998687	0.999736	0.995832	0.998591	2.250885
F12	QGA	58	1.000002	0.999870	0.999968	0.999545	0.999861	0.885784
	BIQGA	73	1.000007	0.999880	0.999968	0.999552	0.999866	0.710978
	BIGLS	94	1.000015	0.999881	0.999974	0.999573	0.999874	2.519134
F13	QGA	53	1.000146	0.966096	0.983186	0.942838	0.964799	1.571284
	BIQGA	82	1.001488	0.966867	0.984068	0.945747	0.966091	1.115712
	BIGLS	99	1.003702	0.969147	0.984488	0.945625	0.968225	6.458805
F14	QGA	72	1.000099	0.996900	0.998743	0.989534	0.996650	1.654612
	BIQGA	93	1.000235	0.997031	0.998887	0.989474	0.996785	1.183496
	BIGLS	100	1.000464	0.997339	0.998885	0.989885	0.997014	8.198621
F15	QGA	70	1.000006	0.999777	0.999932	0.999243	0.999754	1.544883
	BIQGA	85	1.000021	0.999792	0.999937	0.999295	0.999769	1.190743
	BIGLS	100	1.000043	0.999817	0.999946	0.999359	0.999791	10.112468

MSRR: mean of system reliability ratio; QGA: quantum genetic algorithm; BIQGA: Birnbaum importance–based quantum genetic algorithm; BIGLS: Birnbaum importance–based genetic local search.

Table 5.

Results of Experiment I for arbitrary reliable systems.

Systems	Algo.	Achi	MSRR	Median	Max	Min	Ave.	Time
F1	QGA	83	1	0.632879	0.982404	0.039799	0.617730	0.230743
	BIQGA	83	1	0.632879	0.982404	0.039799	0.617730	0.251470
	BIGLS	83	1	0.632879	0.982404	0.039799	0.617730	0.056103
F2	QGA	92	1	0.946027	0.998063	0.455200	0.905856	0.205428
	BIQGA	92	1	0.946027	0.998063	0.455200	0.905856	0.223320
	BIGLS	92	1	0.946027	0.998063	0.455200	0.905856	0.049249
F3	QGA	69	1	0.490860	0.894651	0.043217	0.479671	0.218283
	BIQGA	69	1	0.490860	0.894651	0.043217	0.479671	0.223147
	BIGLS	69	1	0.490860	0.894651	0.043217	0.479671	0.059164
F4	QGA	86	1	0.863857	0.998180	0.204944	0.815338	0.216353
	BIQGA	86	1	0.863857	0.998180	0.204944	0.815338	0.217534
	BIGLS	86	1	0.863857	0.998180	0.204944	0.815338	0.058941
F5	QGA	74	1.018842	0.293878	0.806132	0.037999	0.314286	0.300376
	BIQGA	96	1.041691	0.297372	0.830557	0.040454	0.320531	0.210146
	BIGLS	100	1.047195	0.299527	0.830566	0.040454	0.322063	0.170016
F6	QGA	68	1.005199	0.822740	0.990221	0.332955	0.771611	0.323373
	BIQGA	95	1.01266	0.827959	0.990621	0.332789	0.776888	0.226949
	BIGLS	100	1.014578	0.832078	0.990621	0.337705	0.778191	0.194308
F7	QGA	66	1.035835	0.409310	0.819819	0.097781	0.427389	0.577182
	BIQGA	99	1.246126	0.508597	0.866670	0.140943	0.497472	0.384234
	BIGLS	100	1.305409	0.518505	0.872751	0.140943	0.519852	1.249149
F8	QGA	59	1.00682	0.795332	0.943358	0.316516	0.777480	0.542296
	BIQGA	98	1.0649	0.841467	0.965065	0.372203	0.818295	0.376955
	BIGLS	100	1.085056	0.853703	0.967445	0.400100	0.832598	1.480918
F9	QGA	75	1.003812	0.932693	0.993333	0.621175	0.909475	0.557712
	BIQGA	99	1.022964	0.946650	0.994383	0.668487	0.925629	0.383560
	BIGLS	100	1.030089	0.949174	0.995912	0.708876	0.931609	1.676875
F10	QGA	70	1.067648	0.254774	0.715794	0.033937	0.266937	0.862708
	BIQGA	100	1.682744	0.396468	0.821376	0.066269	0.398534	0.623627
	BIGLS	100	1.819695	0.420059	0.825387	0.071838	0.423704	4.309355
F11	QGA	73	1.028436	0.668364	0.918541	0.137348	0.642766	0.851015
	BIQGA	99	1.204026	0.771443	0.959512	0.228564	0.737957	0.620924
	BIGLS	100	1.248121	0.793519	0.967691	0.229531	0.761901	5.224810
F12	QGA	61	1.005223	0.878863	0.979498	0.499170	0.857282	0.831720
	BIQGA	100	1.063911	0.921330	0.988940	0.620038	0.903997	0.655691
	BIGLS	100	1.074646	0.934681	0.989922	0.629941	0.912660	6.547727
F13	QGA	67	1.122053	0.059195	0.219885	0.003637	0.072611	1.541603
	BIQGA	97	3.817406	0.197847	0.497650	0.014403	0.211625	1.287523
	BIGLS	100	4.278911	0.225400	0.507815	0.025429	0.233818	21.014260
F14	QGA	67	1.035457	0.407347	0.766490	0.064650	0.387583	1.519906
	BIQGA	99	1.648356	0.614764	0.870065	0.200952	0.586269	1.388275
	BIGLS	100	1.722176	0.631626	0.907000	0.222333	0.611164	26.969958
F15	QGA	60	1.010156	0.741757	0.927541	0.298195	0.728570	1.484084
	BIQGA	99	1.190525	0.857905	0.969669	0.520540	0.846478	1.456502
	BIGLS	100	1.213953	0.871569	0.971831	0.531745	0.862345	36.284914

MSRR: mean of system reliability ratio; QGA: quantum genetic algorithm; BIQGA: Birnbaum importance–based quantum genetic algorithm; BIGLS: Birnbaum importance–based genetic local search.

From Table 3, the QGA, BIQGA, and BIGLS have the same results except for the running time in low reliable small systems. The running time of BIGLS is shortest, and that of BIQGA is the longest. For the low reliable large systems, the performance of QGA is the worst because the achievement and MSRR are much lower than those of BIQGA and BIGLS. BIGLS has a bit higher achievement and MSRR comparing with BIQGA; but the running time of BIGLS is much longer than QGA and BIQGA with the increase of system scale. The BIQGA has the shortest running time from F7 to F15 when the number of components in the system is larger than 10.

From Table 4, the QGA, BIQGA, and BIGLS have different performances in high reliable systems. From F1 to F6, BIGLS has a lower achievement, and the MSRR is also less than one. Although BIGLS has a shorter running time, the performance of BIGLS in small systems is a little worse for high reliable systems. However, the results of the three algorithms are the same as that of low reliable systems from F7 to F15.

From Table 5, the results of QGA, BIQGA, and BIGLS in arbitrary reliable systems are the same as the results of low reliable systems. From F1 to F4, these three algorithms have the same performance because they have the same achievement and MSRR. Compared with BIQGA, BIGLS has similar achievement and MSRR, but the running time of BIGLS is much longer than BIQGA and QGA for the large scale systems, especially from F10 to F15. Therefore, the BIQGA can obtain the solution as good as BIGLS with shorter running time, especially for large-scale systems.

In order to analyze the differences in the performance of QGA, BIQGA, and BIGLS, we compare the index in detail, such as achievement, MSRR, average running time, and the solution distribution, which are shown in Figures 2–5.

Figure 2.

The achievement of the three algorithms for 15 typical systems.

Figure 3.

The MSRR of the three algorithms for 15 typical systems.

Figure 4.

The average time of the three algorithms for 15 typical systems.

Figure 5.

The boxplots of the three algorithms for 15 typical systems.

From Figure 2, the achievements of three algorithms for small systems (F1, F2, F3, and F4) are the same in low reliable systems and arbitrary reliable systems, but the achievement of BIGLS in high reliable systems is less than QGA or BIQGA. For the large systems, the BIQGA and BIGLS have almost the same achievement in low reliable systems and arbitrary reliable systems, but the QGA has the lowest achievement. In high reliable systems, the achievement of BIGLS becomes better from F7 to F15, which is a little better than BIQGA.

From Figure 3, the MSRR of BIQGA is very close to that of BIGLS except for some individual cases such as in low reliable systems (F13), high reliable systems (F5, F10, and F13), and arbitrary reliable systems (F13). At the same time, the MSRR of both BIQGA and BIGLS is better than that of QGA except for F5 in high reliable systems. With the increase of system scale, the gap between BIQGA and QGA becomes larger.

From Figure 4, the average time of QGA is almost the same as that of BIQGA for any systems. With the increase of components in the systems, the running time of BIGLS increases quickly. For the low reliable systems, the running time of BIGLS is about 15 times than that of BIQGA in F15; for the high reliable systems, the running time is about eight times than that of BIQGA in F15; for the arbitrary reliable systems, the times increases to 25. Although the effectiveness of BIGLS is better than the other two algorithms, the solution of BIQGA is almost equal to that of BIGLS with short running time. The running time of BIQGA is shorter than that of QGA. This is because one of the termination conditions to stop the BIQGA or QGA is that the results remain unchanged for some continuous generations. The BIQGA has better convergence, which causes BIQGA to stop earlier than QGA.

The average fitness cannot compare the performance of these algorithms fully. Therefore, the boxplot is introduced to illustrate the distribution of solutions because the median, upper, and lower quartiles are also applied to measure the performance. From Figure 5, the fitness values vary with different systems. Therefore, the performance comparison of three algorithms should carry out when the system is determined. If the box area is narrow with high value, the performance of this algorithm is better because the algorithm can obtain the solution with high value and low variance.

For the low reliable systems, in order to illustrate the solution distribution of 15 typical systems, the systems are divided into four groups based on the difference of fitness value. From Figure 5, these three algorithms can obtain the same performance in low reliable small systems (F1, F2, F3, and F4), but the BIQGA and BIGLS can obtain the similar solution in low reliable large systems.

For the high reliable systems, there are three groups to illustrate the solution distribution of three algorithms. From Figure 5, the BIQGA can obtain better solutions in small systems (F1, F2, F3, F4, and F5). The BIGLS can obtain better solutions in large systems (from F10 to F15), but the performance of BIQGA and BIGLS is very close.

For the arbitrary reliable systems, the boxplots of 15 typical systems can be posted in a figure. From Figure 5, the performance of these three algorithms is the same in small systems (F1, F2, F3, and F4). The BIQGA and BIGLS have the same solution in systems (F6 and F9), which is also better than QGA. The solution of BIQGA in large systems (F5, F7, F8, F10, F11, F12, F13, F14, and F15) is much better than QGA, but it is a little worse than BIGLS.

According to the results of Experiment I, the BIQGA can solve CAP with high speed. The effectiveness of BIQGA is the same as BIGLS in small systems. Although the effectiveness of BIQGA is a bit worse than BIGLS, BIQGA can solve the CAP with a very short time when the system scale is large. Therefore, BIQGA can solve the CAP effectively and efficiently.

Results analysis of Experiment II

From the results of Experiment I, BIQGA can obtain better solutions when n is large, so we discuss the changes in fitness with the increasing of generation. The results of Experiment II are shown in Figure 6.

Figure 6.

The convergent tendency of four typical systems.

From Figure 6, the horizontal coordinate represents the generation of the algorithm, and the vertical coordinate represents the fitness value. For the Lin/Con/3/8: F system, GA, QGA, and BIQGA can converge to the optimal solution quickly, but the BIQGA and QGA can reach the optimal solution faster than GA for low, high, and arbitrary reliable systems. For the Lin/Con/3/16: F system and Lin/Con/4/24: F system, the changes in fitness have a similar tendency. The convergence speed of BIQGA is faster than that of QGA and GA, and the fitness of optimal solution for BIQGA is much better than that of GA and QGA. For the convergence of QGA and GA, the fitness has the similar tendency with the increasing of generation, and the fitness increases slowly which means that QGA and GA cannot find the optimal solution with the lower generation. However, the optimal solution of QGA also is much better than that of GA because the fitness of BIQGA is also larger than that of GA. For the Lin/Con/5/32: F system, the convergence speed of BIQGA is faster in the high reliable system, but the speed is slower in the low and arbitrary reliable system. However, the optimal solution of BIQGA and the convergence speed of BIQGA are much faster than that of GA and QGA. QGA can also obtain better solutions than GA. From Experiment II, we can find the convergence speed, and the optimal solution of QGA is a little better than that of GA. BIQGA can obtain the optimal solution much faster, and the solution also is much better than that of QGA and GA especially for the large-scale systems, which also illustrates the effectiveness of BI-based local search.

A case study of production monitor systems

The production monitoring system is a typical Lin/Con/k/n: F system, which is shown in Figure 7. If and only if at least consecutive k monitors failed, the monitoring system will have the blind area, which means the production monitor system is in failure because the system cannot have blind area during working. Assume all the monitors are the same in the system.

Figure 7.

The structure of the production monitoring system.

The capability of the monitors is their monitoring distance, which can be represented by the setting of k in the Lin/Con/k/n: F systems. The value of k is larger, the capability is higher. Since different types of monitors have different capabilities, these monitors have different requests for k in the system. However, the capability of monitors has no concern with the reliability of monitors. The lower reliable monitor may have higher capability in practical engineering. In this section, three types of monitors (Type I, Type II, and Type III) are selected; the capability of the monitors is 2, 3, and 4. The monitors are the high reliable components, and the parameters of the three monitors are shown in Table 6.

Table 6.

Parameters of four typical production monitoring systems.

System	n	Monitor parameters	The reliability of monitors
1	6	Type I, k = 2	[0.8212 0.9402 0.9423 0.9609 0.9869 0.9871]
2	10	Type II, k = 3	[0.8056 0.8166 0.8244 0.8292 0.8395 0.8465 0.9206 0.9262 0.9724 0.9845]
3	20	Type II, k = 3	[0.8088 0.8437 0.8447 0.8603 0.8769 0.8781 0.8821 0.8904 0.8934 0.9049 0.9222 0.9259 0.9323 0.9350 0.9532 0.9693 0.9700 0.9709 0.9827 0.9880]
4	30	Type III, k = 4	[0.8040 0.8082 0.8137 0.8159 0.8166 0.8250 0.8362 0.8366 0.8383 0.8422 0.8464 0.8471 0.8562 0.8844 0.8968 0.9097 0.9102 0.9128 0.9161 0.9200 0.9211 0.9236 0.9299 0.9504 0.9558 0.9594 0.9650 0.9703 0.9789 0.9803]

The optimal solution of BIQGA can also be used in the production monitoring systems, because the solution of BIQGA is better comparing with the BITA, ¹³ which is the classical heuristic algorithm for solving the CAP. The comparison results of optimal arrangements based on BITA and BIQGA are shown in Table 7. From the table, when the scale of the system is small such as n = 6 and 10, the optimal system reliability and the arrangements of BITA and BIQGA are the same; when the system scale becomes larger, BIQGA can obtain better solutions than BITA, but the system reliability of BIQGA is very close to that of BITA. Therefore, the BIQGA is a better method to obtain the optimal arrangement of production monitor system.

Table 7.

The comparison of optimal assignments for BITA and BIQGA.

System	Algorithm	Assignment	System reliability
1	BIQGA	[2-5-4-3-6-1]	0.9936199687
	BITA	[2-5-4-3-6-1]	0.9936199687
2	BIQGA	[1-3-10-4-7-8-6-9-5-2]	0.9955856134
	BITA	[1-3-10-4-7-8-6-9-5-2]	0.9955856134
3	BIQGA	[1-3-20-6-9-18-12-10-15-14-8-16-13-7-17-11-5-19-4-2]	0.9955404453
	BITA	[1-3-20-5-10-18-7-12-16-9-13-15-14-8-17-11-6-19-4-2]	0.9955352079
4	BIQGA	[2-4-13-29-16-5-19-25-18-6-24-22-17-7-26-20-15-8-27-23-12-11-28-21-9-10-30-14-3-1]	0.9986534610
	BITA	[2-4-14-30-10-9-20-28-11-13-23-26-7-17-22-24-6-18-25-21-5-16-27-19-8-12-29-15-3-1]	0.9986534270

BITA: Birnbaum importance–based two-stage approach; BIQGA: Birnbaum importance–based quantum genetic algorithm.

Conclusion

In this article, the performance of BIQGA is discussed by comparing with the GA, QGA, and BIGLS, and some results can be summarized based on the analysis of the results of comparative experiments as follows: (1) BIQGA can solve the CAP effectively and efficiently with a very short time and high objective when the system scale is large. (2) BIQGA can obtain the better solution than QGA and GA because the convergence speed is faster and the fitness is much better than other two algorithms. Through analyzing the optimal arrangements in the production monitoring systems, BIQGA can also find better arrangements for the large-scale system. In the future, the reliability optimization problem for multi-state consecutive k-out-of-n systems can be studied, and the novel intelligent algorithms based on machine learning can be considered to solve the optimization problem. Moreover, the reliability degradation of components with operation time should also be considered into the model of reliability optimization.