Control system reliability rapid prediction method based on minimum path recursive decomposition

Abstract

The invention relates to a method for rapidly predicting the reliability of a control system based on minimum path recursive decomposition. The invention relates to the technical field of reliability prediction of a control system, and the method comprises the steps: carrying out system reliability modeling, and determining system parameters; initializing a process, and setting a precision threshold value; recursive decomposition and cyclic calculation are carried out; and carrying out convergence to a reliability true value, and outputting a result. According to the method, recursive decomposition and node merging technologies are utilized, the problem of combinatorial explosion is effectively avoided, the whole topological structure does not need to be analyzed at a time, and the network is gradually decomposed. Besides, through continuous recursive decomposition of the minimum path of the system, when the reliability of the system is high, convergence to a true value can be faster, a preset precision requirement can be quickly met, and the reliability prediction speed of the high-reliability system is greatly improved.

Description

Technical Field

[0001] This invention relates to the field of reliability prediction technology for control systems, and is a method for rapid reliability prediction of control systems based on minimum path recursive decomposition. Background Technology

[0002] Currently, reliability prediction methods for complex control systems can be roughly divided into two categories: (1) reliability prediction based on analytical methods; and (2) reliability prediction based on Monte Carlo simulation.

[0003] Due to the extreme complexity of modern electronic control systems, reliability prediction based on analytical methods often falls into the "combinatorial explosion" trap. Furthermore, the high reliability requirements of control systems mean that system failures are rare occurrences, necessitating a massive number of Monte Carlo simulations to obtain sufficient failure samples for statistically significant results. Therefore, research into methods that simplify the reliability prediction process and achieve rapid reliability prediction becomes increasingly valuable. Summary of the Invention

[0004] To avoid the combinatorial explosion problem and eliminate the need for a one-time analysis of the entire topology, this invention provides a method for rapid reliability prediction of control systems based on minimum path recursive decomposition.

[0005] This invention provides the following technical solutions: A method for rapid reliability prediction of control systems based on minimum path recursive decomposition, the method comprising the following steps: Step 1: Perform system reliability modeling and determine system parameters; Step 2: Initialize the process and set the precision threshold; Step 3: Perform recursive decomposition and iterative calculation; Step 4: Converge to the reliability truth value and output the result.

[0006] Preferably, step 1 specifically comprises: Construct a graphical model of the control system, perform reliability modeling on the control system, and abstract the system's reliability model into a weighted directed graph: G = (V, E) In this system, vertex V represents a key functional unit or information node; edge E represents the functional dependency between units.

[0007] Preferably, step 2 specifically comprises: Prepare initial conditions to initiate the recursive decomposition process and initialize the overall system reliability. R _ sys = 0, Create a task queue QUsed to store subproblems to be processed, where each subproblem consists of a tuple ( C _ k , G _ k )express, G _ k For a sub-network graph, C _ k To reach this subnetwork G _ k Path conditional probability; The initial state of the system is (1, G Add to queue Q In the middle, and set a precision threshold. ε This is used to control the accuracy and termination conditions of the calculation.

[0008] Preferably, step 3 specifically comprises: Step 3.1: From the queue Q Take a subproblem from the task queue and iterate through it. Q If it is not empty, continue to perform the following operations, from Q Take a subproblem from ( C _ k , G _ k ) to perform analysis; Step 3.2: Find the shortest minimum path In the current subnetwork G _ k In the process, a breadth-first search algorithm is used to find a path from the source node. s to the remittance point t Shortest minimum path ,in ,in e _ i These are the edges that make up this path. m It is the path length; Step 3.3: Accumulate the reliability of disjoint paths to determine the correct path. It is mutually exclusive with all previously processed paths; Using formula = R _ sys + C _ k * P ( The reliability contribution is added to the total reliability. It is the overall reliability of the updated system. C _ k This is the current subproblem G _ k The probability of existence of the prerequisite condition: ; Where p_i represents the reliability of edge assignment; Step 3.4: Path-based The failure is decomposed and new subproblems are generated. Failure events It is decomposed into a series of mutually exclusive sub-events:

[0009] right For each mutually exclusive sub-event, generate a new, simplified sub-problem and add it to a queue. Q For path The first j Strip edge e _ j ( j =1 tom ).

[0010] Preferably, a failure event is defined, which is " e _1 to e _{ j -1} both work, but e _ j fail"; Calculate the path-conditional probability of the new subproblem C _{ new}: 。

[0011] Preferably, a new subnetwork is constructed. G _{ new},from G _ k Begin by removing invalid edges, then... e _ j Permanently delete and merge the working nodes from the graph; The generated new subproblem ( C _{ new}, G _{ new}) Add to queue Q middle.

[0012] Preferably, step 4 specifically includes: After each loop or every N loops, check if the algorithm can be terminated early. Calculate the sum of remaining probabilities P_rem = Σ C_k, and determine whether P_rem < ε is true. If it is true, terminate the loop; otherwise, continue the loop. If the loop terminates due to an empty queue or the convergence condition being met, the output should be displayed. As a measure of system reliability.

[0013] A rapid reliability prediction method for a control system based on minimum path recursive decomposition, the system comprising: The system modeling module performs system reliability modeling and determines system parameters; An initialization module initializes the process and sets a precision threshold. A recursive loop module, which performs recursive decomposition and iterative calculation; The output module converges to the reliability truth value and outputs the result.

[0014] A computer-readable storage medium having a computer program stored thereon, which is executed by a processor to implement a method for rapid prediction of the reliability of a control system based on minimum path recursive decomposition.

[0015] A computer device includes a memory and a processor, the memory storing a computer program, and the processor executing the computer program to implement a method for rapid reliability prediction of a control system based on minimum path recursive decomposition.

[0016] The present invention has the following beneficial effects: This invention utilizes recursive decomposition and node merging techniques to effectively avoid the combinatorial explosion problem. It eliminates the need for a one-time analysis of the entire topology, instead gradually decomposing the network. Furthermore, by continuously recursively decomposing the system's minimum path, it can converge to the true value more quickly when the system reliability is high, and can rapidly achieve the preset accuracy requirements, significantly improving the reliability prediction speed for high-reliability systems. Attached Figure Description

[0017] To more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0018] Figure 1 The flowchart shown is an example of the improved minimum path decomposition algorithm of this invention. Detailed Implementation

[0019] The technical solution of the present invention will now be clearly and completely described with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0020] The present invention will be described in detail below with reference to specific embodiments. Specific Implementation Example 1: according to Figure 1 As shown, the specific optimization technical solution adopted by the present invention to solve the above-mentioned technical problems is: The present invention relates to a method for rapid prediction of the reliability of a control system based on minimum path recursive decomposition.

[0022] This invention provides a method for rapid reliability prediction of control systems based on minimum path recursive decomposition, the method comprising the following steps: Step 1: Perform system reliability modeling and determine system parameters; Step 2: Initialize the process and set the precision threshold; Step 3: Perform recursive decomposition and iterative calculation; Step 4: Converge to the reliability truth value and output the result.

[0023] This invention utilizes recursive decomposition and node merging techniques to effectively avoid the combinatorial explosion problem. It eliminates the need for a one-time analysis of the entire topology, instead gradually decomposing the network. Furthermore, by continuously recursively decomposing the system's minimum path, it can converge to the true value more quickly when the system reliability is high, and can rapidly achieve the preset accuracy requirements, significantly improving the reliability prediction speed for high-reliability systems. Specific Implementation Example 2: The only difference between Embodiment 2 and Embodiment 1 of this application is that: Step 1 specifically involves: Construct a graphical model of the control system, perform reliability modeling on the control system, and abstract the system's reliability model into a weighted directed graph: G = (V, E) In this system, vertex V represents a key functional unit or information node; edge E represents the functional dependency between units. Specific Implementation Example 3: The only difference between Embodiment 3 and Embodiment 2 of this application is that: Step 2 specifically involves: Prepare initial conditions to initiate the recursive decomposition process and initialize the overall system reliability. R _ sys = 0, Create a task queue Q Used to store subproblems to be processed, where each subproblem consists of a tuple ( C _ k , G _ k )express, G _ k For a sub-network graph,C _ k To reach this subnetwork G _ k Path conditional probability; The initial state of the system is (1, G Add to queue Q In the middle, and set a precision threshold. ε This is used to control the accuracy and termination conditions of the calculation. Specific Implementation Example 4: The only difference between Embodiment 4 and Embodiment 3 of this application is that: Step 3 specifically involves: Step 3.1: From the queue Q Take a subproblem from the task queue and iterate through it. Q If it is not empty, continue to perform the following operations, from Q Take a subproblem from ( C _ k , G _ k ) to perform analysis; Step 3.2: Find the shortest minimum path In the current subnetwork G _ k In the process, a breadth-first search algorithm is used to find a path from the source node. s to the remittance point t Shortest minimum path ,in ,in e _ i These are the edges that make up this path. m It is the path length; Step 3.3: Accumulate the reliability of disjoint paths to determine the correct path. It is mutually exclusive with all previously processed paths; Using formula = R _ sys + C _ k P ( The reliability contribution is added to the total reliability. It is the overall reliability of the updated system. C _ k This is the current subproblem G _ k The probability of existence of the prerequisite condition: ; Where p_i represents the reliability of edge assignment; Step 3.4: Path-based The failure is decomposed and new subproblems are generated. Failure events It is decomposed into a series of mutually exclusive sub-events:

[0027] right For each mutually exclusive sub-event, generate a new, simplified sub-problem and add it to a queue. Q For path The first j Strip edge e _ j ( j =1 tom ). Specific Implementation Example 5: The difference between Embodiment 5 and Embodiment 4 of the present invention lies only in: Define a failure event, which is " e _1 to e _{ j -1} both work, but e _ j fail"; Calculate the path-conditional probability of the new subproblem C _{ new}: 。 Specific Implementation Example Six: The difference between Embodiment Six and Embodiment Five of the present invention lies only in: Constructing new subnetworks G _{ new},from G _ k Begin by removing invalid edges, then... e _ j Permanently delete and merge the working nodes from the graph; The generated new subproblem ( C _{ new}, G _{ new}) Add to queue Q middle. Specific Implementation Example 7: The difference between Embodiment Seven and Embodiment Six of the present invention lies only in: Step 4 specifically involves: After each loop or every N loops, check if the algorithm can be terminated early. Calculate the sum of remaining probabilities P_rem = Σ C_k, and determine whether P_rem < ε is true. If it is true, terminate the loop; otherwise, continue the loop. If the loop terminates due to an empty queue or the convergence condition being met, the output should be displayed. As a measure of system reliability. Specific Implementation Example 8: The difference between Embodiment 8 and Embodiment 7 of the present invention lies only in: This invention provides a rapid reliability prediction method for a control system based on minimum path recursive decomposition, the system comprising: The system modeling module performs system reliability modeling and determines system parameters; An initialization module initializes the process and sets a precision threshold. A recursive loop module, which performs recursive decomposition and iterative calculation; The output module converges to the reliability truth value and outputs the result. Specific Implementation Example Nine: The difference between Embodiment Nine and Embodiment Eight of the present invention lies only in: The present invention provides a computer-readable storage medium having a computer program stored thereon, which is executed by a processor to implement a method for rapid prediction of the reliability of a control system based on minimum path recursive decomposition. Specific Implementation Example 10: The only difference between Embodiment 10 and Embodiment 9 of the present invention is that: The present invention provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement a method for rapid prediction of the reliability of a control system based on minimum path recursive decomposition. Specific Implementation Example Eleven: The only difference between Embodiment Eleven and Embodiment Ten of this invention is that: Invention process: Step 1: System Reliability Modeling and Parameter Definition Building a graph model G = ( V , E To perform reliability modeling on the control system, the reliability model of the system is abstracted into a weighted directed graph, and the reliability p_i is assigned to the edges.

[0035] Among them: vertex ( Nodes ) V Represents a functional unit or component in the system; edge ( Edges ) E This represents the functional dependencies between units.

[0036] Step 2: Algorithm Initialization Prepare initial conditions to initiate the recursive decomposition process and initialize the overall system reliability. R _ sys = 0, Create a task queue Q Used to store subproblems to be processed, where each subproblem consists of a tuple ( C _ k , G _ k The initial state of the system is represented as (1, ). G Add to queue Q Next, we set the precision threshold. ε This is used to control the accuracy and termination conditions of the calculation.

[0037] in R _ sys This is the total system reliability that we will gradually accumulate. Initially, since we have not yet found any successful paths, its value is 0. G _ k For a sub-network graph, C _ k To reach this subnetwork G _ k The path conditional probability.

[0038] Step 3: Recursive Decomposition and Iterative Calculation Loop (as long as the task queue) Q If the value is not empty, continue performing the following operations: (1) From the queue Q Take a subproblem from it: from Q Take a subproblem from ( C _ k , G _ k ) to perform analysis; (2) Find the shortest minimum path A 1: In the current subnetwork G _ k In this context, breadth-first search is used. BFS The algorithm finds a path from the source point s to the remittance point t Shortest minimum path ,in ,in e _ i These are the edges that make up this path. m It is the path length; (3) The reliability of cumulative non-intersecting paths: The path found A 1 is mutually exclusive (disjoint) with all previously processed paths. Therefore, the formula can be used... = R _ sys + C _ k P ( The reliability contribution is directly added to the total reliability. It is the overall reliability of the updated system. C _ k This is the current subproblem G _ k The probability of the existence of the prerequisite conditions ; (4) Path-based A The failure of 1 is decomposed and new subproblems are generated: Failure events It can be decomposed into a series of mutually exclusive sub-events: right For each mutually exclusive sub-event, we generate a new, simpler sub-problem and add it to a queue. Q For path The first j Strip edge e _ j ( j =1 tom ): a Define failure events: The event is " e _1 to e _{ j -1} both work, but e _ j fail".

[0039] b Calculate the path-conditional probability of the new subproblem. C _{ new}:

[0040] c Constructing new subnetworks G _{ new (Node merging): from G _ k Begin by removing invalid edges: Remove the invalid edges... e _ j Permanently delete and merge the working nodes from the graph.

[0041] d Add the new subproblem to the queue: The generated new subproblem ( C _{ new}, G _{ new}) Add to queue Q middle.

[0042] Step 4: Convergence Judgment and Termination In each cycle (or every N After each iteration (nth loop), check if the algorithm can be terminated early.

[0043] Calculate the sum of remaining probabilities P _ rem = ΣC _ k ,judge P _ rem < ε Check if the condition is true. If it is true, the loop terminates; otherwise, the loop continues.

[0044] Step 5: Output Results If the loop terminates due to an empty queue or the convergence condition being met, the output should be displayed. As a measure of system reliability.

[0045] Compared to the traditional minimum path analytical algorithm, this algorithm gradually converges to the reliability truth by continuously recursively decomposing the data. It is more likely to converge for high-reliability electronic systems, which greatly improves the calculation speed.

[0046] The pseudocode for this application is as follows: # Improved Minimum Path Recursive Decomposition Algorithm Pseudocode ## Part 1: Hierarchical System Calculator This controller is the entry point for the entire computation process and is responsible for handling complex system models with hierarchical structures (subsystems).

[0047] ``` FUNCTION CalculateSystemReliability(ToplevelNetwork, Time): / / Calculate the end-to-end reliability of the entire system RETURN CalculateNetworkValue(ToplevelNetwork, 'reliability', Time) FUNCTION CalculateNetworkValue(NetworkDefinition, CalcType, Time): / / Recursive function to calculate end-to-end values ​​(reliability / availability) at any network layer 1. / / Check the cache; if the network value has already been calculated, return directly. IF NetworkDefinition.ID in Cache: RETURN Cache[NetworkDefinition.ID] 2. / / Parse the values ​​of all components within the network. ResolvedComponentValues ​​= {} FOR each Component in NetworkDefinition.Components: IF Component.Type == "ATOMIC": / / Atomic components: Calculate their values ​​based on their failure distribution (e.g., exponential, Weibull) and time. Value = CalculateAtomicComponentValue(Component.FailureModel, Time) ELSE IF Component.Type == "SUBSYSTEM": / / Subsystem: This function is called recursively to calculate the values ​​of its internal network. Value = CalculateNetworkValue(Component.InternalStructure, CalcType,Time) END IF ResolvedComponentValues[Component.ID] = Value END FOR 3. / / Construct a "flattened" network graph for solving the problem. / / Treat all components (whether atoms or subsystems) as edges with resolved values. FlatGraph = CreateGraphFromResolvedValues(NetworkDefinition,ResolvedComponentValues) 4. / / Call the core solver to perform calculations Solver = new ImprovedDecompositionSolver(FlatGraph, Network.Source,Network.Sink) NetworkValue = Solver.solve() 5. / / Cache the results and return them Cache[NetworkDefinition.ID] = NetworkValue RETURN NetworkValue END FUNCTION ``` ## Part Two: Improved Decomposition Solver (Minimum Path Recursive Decomposition Algorithm) ### Algorithm Overview The core idea of ​​this algorithm is the SUM-of-Disjoint-Products method. It decomposes the successful events of the system into a series of disjoint sub-events by finding the shortest path.

[0048] The conditions for the system to work successfully can be expressed as follows: `Sys_OK = (P1_OK) U (P1_fail_decomposed_OK)` Where `P1` is a shortest path between the source and sink. `P1_OK` indicates that all components on path `P1` are functioning correctly. `P1_fail_decomposed_OK` indicates a complex event where `P1` is not functioning correctly, but the system remains connected through other redundant paths.

[0049] The algorithm further decomposes `P1_fail_decomposed_OK` through the following recurrence relation: `P1_fail_decomposed_OK = (e1_fail AND Sys_OK_in_G') U (e1_OK AND e2_fail AND Sys_OK_in_G'') U ...` Where `ei` is the `i`th component on path `P1`.

[0050] ### Numerical Computation Pseudocode ``` FUNCTION solve(Graph, Source, Sink): / / Entry function 1. / / Handling of special cases IF Source == Sink: RETURN 1.0 IF Graph has no path from Source to Sink: RETURN 0.0 IF Graph is a simple Parallel Structure: RETURN CalculateParallelValue(Graph) / / P = 1 - ∏(1-Pi) END IF 2. / / Initialization DisjointPaths = [] / / Store disjoint path items DisjointCuts = [] / / Store disjoint set items InitialPrefix = {positive: {}, negative: {}} / / Initial condition is empty 3. / / Begin recursive decomposition RecursiveDecomposition(Graph, Source, InitialPrefix) 4. / / Calculate the final result based on non-intersecting paths and non-intersecting sets. LowerBound = SUM(Probability(path) FOR path in DisjointPaths) UpperBound = 1.0 - SUM(Probability(cut) FOR cut in DisjointCuts) / / If an exact solution is required, return the lower bound; otherwise, return the mean of the upper and lower bounds. RETURN (LowerBound + UpperBound) / 2 END FUNCTION FUNCTION RecursiveDecomposition(CurrentGraph, CurrentSource,PrefixTerm): / / Recursive Core 1. / / Find the shortest path (BFS) from CurrentSource to Sink in the current graph. ShortestPath = FindShortestPath(CurrentGraph, CurrentSource, Sink) 2. / / If the path cannot be found, it means the system has failed under this condition, and the recursion terminates. IF ShortestPath is NULL: / / Treat the current prefix conditions as a non-intersection set ADD PrefixTerm to DisjointCuts RETURN END IF 3. / / Find a new non-intersecting route / / The condition for this non-intersecting path to occur is: PrefixTerm is true, and all edges on ShortestPath are true. NewDisjointPath = PrefixTerm + {positive: ShortestPath.edges} ADD NewDisjointPath to DisjointPaths 4. / / Decompose along the shortest path, creating a series of new subproblems. FOR i FROM 0 TO ShortestPath.length - 1: Edge_i = ShortestPath.edges[i] / / a. Prefix conditions for constructing subproblems / / This assumes that the first i-1 edges of ShortestPath are true and the i-th edge is false. NextPrefix = PrefixTerm + {positive: {Edge_0..Edge_i-1}} + {negative:{Edge_i}} / / b. Constructing a subgraph / / - Contract the first i-1 edges of ShortestPath / / - Remove the i-th edge of ShortestPath SubGraph, NewSource = CreateSubGraph(CurrentGraph, ShortestPath, i) / / c. If the source and sink nodes in the subproblem may still be connected, then recursively call... IF HasPath(SubGraph, NewSource, Sink): RecursiveDecomposition(SubGraph, NewSource, NextPrefix) ELSE: Otherwise, the prefix conditions of this subproblem constitute a disjoint set. ADD NextPrefix to DisjointCuts END IF END FOR END FUNCTION ``` ### Symbolic Computation Pseudocode The logic of symbolic computation is almost identical to that of numerical computation, except that it does not calculate probability values, but instead constructs an expression tree.

[0051] ``` FUNCTION solve_symbolic(Graph, Source, Sink): / / The logic is similar to solve(), but it ultimately returns an expression object. / / ... Omitted initialization and special case handling identical to solve()... / / Start recursive decomposition RecursiveDecomposition_Symbolic(Graph, Source, InitialPrefix) / / Encapsulate the collected non-intersecting paths and non-crossing items into an expression object. RETURN new DisjointPathsExpression(DisjointPaths, DisjointCuts) END FUNCTION FUNCTION RecursiveDecomposition_Symbolic(CurrentGraph, CurrentSource,PrefixTerm): / / The only difference is that it does not calculate and update the upper and lower bounds, but only collects paths and cuts. / / Other logic (finding the shortest path, decomposition, creating subgraphs, recursion) is exactly the same as the numerical version. / / ... FindShortestPath ... / / ... Add to DisjointPaths ... / / ... Loop over ShortestPath ... / / ... Create SubGraph ... / / ... RecursiveCall or Add to DisjointCuts ... / / ... End Loop ... END FUNCTION ``` The above description is merely a preferred embodiment of a method for rapid reliability prediction of a control system based on minimum path recursive decomposition. The scope of protection for this method is not limited to the above embodiments; all technical solutions falling within this framework are within the scope of protection of this invention. It should be noted that for those skilled in the art, any improvements and variations made without departing from the principles of this invention should also be considered within the scope of protection of this invention.

Claims

1. A method for rapid reliability prediction of control systems based on minimum path recursive decomposition, characterized by: The method includes the following steps: Step 1: Perform system reliability modeling and determine system parameters; Step 2: Initialize the process and set the precision threshold; Step 3: Perform recursive decomposition and iterative calculation; Step 4: Converge to the reliability truth value and output the result.

2. The method according to claim 1, characterized in that: Step 1 specifically involves: Construct a graphical model of the control system, perform reliability modeling on the control system, and abstract the system's reliability model into a weighted directed graph: G = (V, E) In this system, vertex V represents a key functional unit or information node; edge E represents the functional dependency between units.

3. The method according to claim 2, characterized in that: Step 2 specifically involves: Prepare initial conditions to initiate the recursive decomposition process and initialize the overall system reliability. R _ sys=0, Create a task queue Q Used to store subproblems to be processed, where each subproblem consists of a tuple ( C _ k , G _ k )express, G _ k For a sub-network graph, C _ k To reach this subnetwork G _ k Path conditional probability; The initial state of the system is (1, G Add to queue Q In the middle, and set a precision threshold. ε This is used to control the accuracy and termination conditions of the calculation.

4. The method according to claim 3, characterized in that: Step 3 specifically involves: Step 3.1: From the queue Q Take a subproblem from the task queue and iterate through it. Q If it is not empty, continue to perform the following operations, from Q Take a subproblem from ( C _ k , G _ k ) to perform analysis; Step 3.2: Find the shortest minimum path In the current subnetwork G _ k In the process, a breadth-first search algorithm is used to find a path from the source node. s to the remittance point t Shortest minimum path ,in ,in e _ i These are the edges that make up this path. m It is the path length; Step 3.3: Accumulate the reliability of disjoint paths to determine the correct path. It is mutually exclusive with all previously processed paths; Using formula = R _ sys + C _ k P ( The reliability contribution is added to the total reliability. It is the overall reliability of the updated system. C _ k This is the current subproblem G _ k The probability of existence of the prerequisite condition: ； Where p_i represents the reliability of edge assignment; Step 3.4: Path-based The failure is decomposed and new subproblems are generated. Failure events It is decomposed into a series of mutually exclusive sub-events: right For each mutually exclusive sub-event, generate a new, simplified sub-problem and add it to a queue. Q For path The first j Strip edge e _ j ( j =1 tom ).

5. The method according to claim 4, characterized in that: Define a failure event, which is " e _1 to e _{ j -1} both work, but e _ j fail"; Calculate the path-conditional probability of the new subproblem C _{ new }: 。 6. The method according to claim 4, characterized in that: Constructing new subnetworks G _{ new },from G _ k Begin by removing invalid edges, then... e _ j Permanently delete and merge the working nodes from the graph; The generated new subproblem ( C _{ new }, G _{ new }) Add to queue Q middle.

7. The method according to claim 5 or 6, characterized in that: Step 4 specifically involves: After each loop or every N loops, check if the algorithm can be terminated early. Calculate the sum of remaining probabilities P_rem = Σ C_k, and determine whether P_rem < ε is true. If it is true, terminate the loop; otherwise, continue the loop. If the loop terminates due to an empty queue or the convergence condition being met, the output should be displayed. As a measure of system reliability.

8. A method for rapid reliability prediction of control systems based on minimum path recursive decomposition, characterized by: The system includes: The system modeling module performs system reliability modeling and determines system parameters; An initialization module initializes the process and sets a precision threshold. A recursive loop module, which performs recursive decomposition and iterative calculation; The output module converges to the reliability truth value and outputs the result.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that, The program is executed by the processor to implement the method as claimed in claims 1-7.

10. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that: When the processor executes the computer program, it implements the method of claims 1-7.

Images