Online Test Strategy Generation Based on Delayed-Feedback Value Learning

Abstract

Design for testability configures test points and plans tests during product design to support fault detection and isolation in service. Existing test strategy generation (TSG) methods mainly address offline diagnosis. As demand for uninterrupted operation grows, downtime and economic losses become more significant, shifting maintenance toward online diagnosis. However, offline methods optimize complete diagnostic processes without directly accounting for isolation gains within a limited time. Their direct application can therefore yield a low fault isolation rate (FIR). To address this problem, this paper proposes an online TSG method based on delayed-feedback value learning (DFVL). First, an optimization problem is formulated using a multi-signal flow graph and a finite time constraint. Second, a DFVL framework is developed using value recursion and feasible subtree returns. It comprises Bellman-based features, balanced feasible completions, delayed updates with unweighted normalized residuals, historical-tree retention, model-derived MAP candidates, and bounded local search. Across 90 synthetic models and 12 budgets, mean FIR was 83.53%, compared with 77.96% for Mix1 and 73.24% for DIG. At normalized Time 36, device-model FIR was 75.90%, versus 53.15% for Mix1 and 61.86% for DIG. FIR denotes a model-based correct terminal MAP decision probability under single-fault, deterministic-response, and fixed-duration assumptions.

1. Introduction

1.1. Research Motivation

Design for testability involves configuring test points and planning tests during product design to generate diagnostic strategies [1,2]. Traditional design for testability mainly addresses offline fault diagnosis [3,4]. Under offline conditions, test strategy generation (TSG) generally does not require strict time limits. Its main objective is to reduce the average test cost by optimizing test selection and sequencing while achieving complete fault isolation [5,6].

However, as the demand for continuous equipment operation and the cost of downtime increase, offline TSG has become less able to meet the requirements of online fault diagnosis. This has driven the development of TSG for online applications. Unlike offline TSG, online TSG must account for explicit time constraints. Its primary objective is no longer complete isolation, but the highest possible fault isolation rate (FIR) within a limited time. Traditional offline methods mainly optimize the complete diagnostic process. They generally do not use the isolation gains obtainable within a limited time as a basis for decision making. Consequently, applying offline methods directly to online problems can yield low fault isolation gains within the available test time.

1.2. Literature Review

Existing offline TSG methods can be broadly divided into two categories: greedy algorithms based on local test evaluation functions, and global planning algorithms based on intelligent optimization and combinatorial search.

The basic idea of a greedy algorithm is to select the locally optimal test at each decision node according to the current evaluation values of candidate tests. It does not search the entire strategy space globally, and is therefore fast and straightforward to implement [7,8]. Tian et al. combined the fault detection weight with information entropy and proposed two greedy algorithms, Mix1 and Mix2. These algorithms improve the applicability of a single evaluation metric across different D-matrices [7]. For diagnostic test selection in multimode systems, Krysander et al. used a fault signature matrix and a greedy algorithm to select residual sets progressively. Their method reduces the number of tests while preserving diagnosability in each operating mode [8]. Zhang et al. combine information gain with fault-detection weighting in DIG [9]. Related greedy sensor-selection methods address experimental design [10] and observability-Gramian optimization [11]. Such methods generally select the next test using an evaluation function at the current node or limited look-ahead, and offer high computational efficiency. However, if the evaluation does not account for isolation gains before the deadline, directly truncating the generated strategy may fail to use the diagnostic window effectively.

Global planning algorithms typically use intelligent optimization or combinatorial search to jointly optimize the test set, test sequence, and diagnostic tree structure [12,13,14,15,16,17,18,19]. Yu et al. encoded diagnostic strategies using a fault–test dependency matrix. They used a quantum-inspired genetic algorithm to jointly optimize the expected test cost and the number of tests used [12]. Li et al. developed a data-driven test selection model and used an improved discrete binary particle swarm optimization algorithm to solve test selection under multiple faults [13]. They subsequently described test dependencies using a conditional joint distribution and a deep copula to reduce detection and maintenance costs [14]. Hu et al. developed a test point selection framework based on a fault response matrix to obtain high fault coverage with fewer test points [15]. Zhu et al. established a four-valued dependency matrix for systems with complex multivalued attributes and designed a diagnostic strategy optimization method. This further integrates testability modeling with TSG [16]. Li et al. model dependent test outcomes and multiple-fault ambiguity for test selection [20]. Kulkarni et al. developed a multiobjective sensor selection framework to improve the fault detection rate (FDR) while reducing the total sensor cost [17]. Wang et al. further formulated a test selection optimization model with FDR and FIR constraints for multivariable and multifault scenarios [18]. Li et al. developed a sequential fault diagnosis strategy for high-speed train traction systems with unreliable tests [19]. These sensor-selection and unreliable-test studies consider FDR/FIR requirements or response uncertainty, but their objectives differ from maximizing the terminal MAP return under a separate deadline on every diagnostic path. Ash and Hayes-Roth associate diagnostic-tree nodes with actions that remain available when a deadline is reached [21]. Bayer-Zubek formulates test selection and stopping as a Markov decision process and uses AO* search to minimize expected test and misdiagnosis costs [22]. Liang et al. apply Q-learning to diagnostic policies with imperfect tests [23]. Yang et al. use a deep Q-network for analog-circuit test-point selection under a cost constraint [24]. Zhang et al. apply deep reinforcement learning to multi-valued dependency matrices to reduce the steps or expected cost of complete isolation [25]. These methods improve the adaptability of test selection and TSG under complex conditions.

Although the above TSG methods have been widely applied, they do not share a single objective. Complete-process cost optimization and finite-window MAP return need not select the same test sequence. The present work plans a separate budget-feasible strategy for each given binary D/P/C model and time limit, using achieved feasible subtree returns as feedback.

1.3. Research Content and Contributions

To address these problems, this paper proposes an online TSG method based on delayed-feedback value learning. First, an online TSG optimization problem is formulated by combining a multi-signal flow graph model with a finite time constraint. The basic FIR monotonicity identity supports feasible return bounds. Further, a delayed-feedback value learning (DFVL) framework is developed by combining value recursion with feasible subtree feedback. The framework constructs features from Bellman recursion, generates training samples through subtree completion and return records, and updates the network using a delayed-feedback equation with whole-tree backup. Historical feasible trees, model-derived MAP candidates, state-matched subtree reuse, and bounded local search are integrated into the final strategy construction. The main contributions are as follows:

• A TSG optimization problem is formulated for online fault diagnosis with limited test time, explicitly defining the objective of maximizing FIR within that time.
• Bounded action-value features and delayed feedback from completed feasible subtrees provide normalized learning targets, using balanced completions and unweighted residuals.
• The learned values are combined with historical feasible-tree retention, model-derived candidates and bounded search to construct a feasible diagnostic strategy for each known model and budget.

The remainder of this paper is organized as follows. Section 2 formulates the online TSG optimization problem and checks its motivating approximation. Section 3 states the return identity used by feasible bounds. Section 4 presents the proposed DFVL framework. Section 5 reports the evaluations, and Section 6 concludes the paper.

2. MSFG Model and Formulation of the Online TSG Problem

2.1. MSFG

The model assumes that exactly one of the listed faults is active during a diagnosis. The priors describe these mutually exclusive fault hypotheses; a healthy-state detection problem and simultaneous multiple faults are not evaluated.

The multi-signal flow graph (MSFG) model describes system fault states, available tests, and their relationships. It provides a basis for TSG and diagnostic decision tree construction [26,27], and is usually represented by the tuple $\{S,P,T,C,D\}$ [28,29]:

• The candidate fault set is $S=\{s_1,s_2,\dots ,s_m\}$, where $s_i$ denotes the ith system fault state and m is the total number of candidate fault states.
• The prior fault probability vector is $P={(p_1,p_2,\dots ,p_m)}^{\mathsf{T}}$. The designer determines $p_i$ from system information and failure mode, effects, and criticality analysis (FMECA). It represents the prior probability that the system is in state $s_i$, conditional on a fault having occurred, and satisfies $p_i\ge 0$ and ${\sum }_{i=1}^m{p}_i=1$.
• The available test set is $T=\{t_1,t_2,\dots ,t_n\}$. Here, $t_j$ denotes the jth test that can be performed on the system, and n is the total number of available tests.
• The test time vector is $C={(c_1,c_2,\dots ,c_n)}^{\mathsf{T}}$. The designer specifies $c_j$ according to the actual measurement conditions. It represents the time required to perform test $t_j$ and satisfies $c_j>0$.
• The fault–test dependency matrix is $D={\left(d_{ij}\right)}_{m\times n}$, where $d_{ij}\in \{0,1\}$. If test $t_j$ responds to fault $s_i$, then $d_{ij}=1$; otherwise, $d_{ij}=0$.

2.2. Formulation of the Online TSG Optimization Problem

At a node with candidate fault set $A\subseteq S$, the maximum a posteriori (MAP) rule is the optimal diagnostic decision rule when misclassification costs are equal [30]. The candidate fault with the highest probability in A should be selected as the diagnostic result. In this paper, FIR is measured by the probability of a correct MAP decision. The conditional probability of a correct decision at this node is ${\max }_{s_i\in A}{p}_i/{\sum }_{s_i\in A}{p}_i$, and its contribution to the overall FIR is

$$\mathrm{FIR}\left(A\right)=\underset{s_i\in A}{\max }{p}_i.$$

(1)

Throughout this paper, FIR denotes the prior-weighted probability that the terminal MAP decision is correct under the supplied model. A leaf containing several candidate faults contributes the prior of its MAP representative. This criterion does not require every terminal candidate set to be a singleton.

Offline TSG generally minimizes the average test cost subject to complete fault isolation. By contrast, online tests must be completed within an engineering-defined diagnostic window, and their objective is to maximize FIR within a limited time. Let $\pi$ denote a diagnostic decision tree, $\mathcal{P}\left(\pi \right)$ the set of all root-to-leaf paths, and $\mathcal{L}\left(\pi \right)$ the collection of candidate fault sets at its leaves. Let $\mathrm{Time}$ be the maximum allowable diagnostic time. Because the candidate fault sets at different leaves are disjoint, the overall FIR equals the sum of their contributions. Therefore, the online TSG optimization problem can be expressed as

$$\begin{array}{cc}\hfill \underset{\pi }{\max }& \mathrm{FIR}\left(\pi \right)=\sum _{A\in \mathcal{L}\left(\pi \right)}\mathrm{FIR}\left(A\right),\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& \sum _{t_j\in \xi }{c}_j\le \mathrm{Time},\forall \xi \in \mathcal{P}\left(\pi \right).\hfill \end{array}$$

(2)

A calculation example is shown in Figure 1. The dashed line indicates the test deadline. Tests that have not been completed before this deadline are excluded from the fault decision at the leaf node.

Figure 1. Diagnostic tree under a time constraint and an example FIR calculation.

2.3. Loss in the Return of Complete Diagnostic Strategies Under Time Limits

The supplied priors are inputs to strategy generation. For the controlled simulations, three fault grades use relative weights 100:10:1, which are normalized to obtain P. This mapping is a modeling choice, rather than a numerical ratio prescribed by MIL-STD-1629A, whose probability classes provide a qualitative classification [31]. The engineering case uses the supplied grade assignments; an alternative uniform prior is evaluated separately.

Let the numbers of faults in the three levels be $\mathbf{m}=(m_1,m_2,m_3)$, with weights $w_1>w_2>w_3$, and let $q\in \{1,2,3\}$ index the prior probability levels. Tests are divided into $L_C$ cost levels. The cost and number of tests at level ℓ are $c_{\mathcal{\ell }},n_{\mathcal{\ell }}$, respectively, with $\mathbf{n}=(n_1,\dots ,n_{L_C})$ and $n={\sum }_{\mathcal{\ell }=1}^{L_C}{n}_{\mathcal{\ell }}$. Define $Z={\sum }_q{w}_q{m}_q$ and $W\left(\mathbf{r}\right)={\sum }_q{w}_q{r}_q$. Let $M\left(\mathbf{r}\right)$ be the largest fault weight in composition $\mathbf{r}$, with a value of 0 for an empty node. Each fault has prior probability $w_q/Z$, and the same Z is used at every child node. The true loss is defined as the difference between the optimal online FIR and the FIR of a truncated entropy tree under the same deadline. The expectation is taken over random dependency matrices whose entries independently follow $\mathrm{Bernoulli}\left(\rho \right)$, and over uniform selection when entropy values are tied. Let ${\pi }_{\mathrm{ent}}^{\left(t\right)}$ denote the feasible strategy obtained by truncating a complete entropy tree at budget t. Let $\widehat{G}\left(t\right)$ estimate the unnormalized mean return of the truncated entropy tree, and let $\widehat{U}(\mathbf{m},\mathbf{n},t)$ estimate the optimal unnormalized return of online planning. Then,

$$\begin{array}{cc}\hfill \overline{\epsilon }\left(t\right)& =\mathbb{E}\left[\underset{\begin{array}{c}\pi \mathrm{satisfies}\mathrm{Equation}\left(2\right)\\ \mathrm{with}\mathrm{budget}t\end{array}}{\max }\mathrm{FIR}\left(\pi \right)-\mathrm{FIR}\left({\pi }_{\mathrm{ent}}^{\left(t\right)}\right)\right]\ge 0,\hfill \\ \hfill \overline{\epsilon }\left(t\right)& \approx \tilde{\epsilon }\left(t\right)={\displaystyle \frac{\widehat{U}(\mathbf{m},\mathbf{n},t)-\widehat{G}\left(t\right)}{Z}}.\hfill \end{array}$$

(3)

The truncated strategy is itself feasible, so the true difference is nonnegative. The analytical estimate assumes node independence, independence of the remaining columns, and closure based on the conditional means of successor returns. The derivation is given below.

For a node with composition $\mathbf{r}$, $r_q$ is the number of faults at prior level q. Let $\mathbf{k}$ denote the composition of faults with test response 1, where $k_q$ is the number of such faults at that level. The composition for response 0 is $\mathbf{r}-\mathbf{k}$. Define ${\mathcal{K}}_{\mathbf{r}}={\prod }_q\{0,\dots ,r_q\}$ and the outcome entropy as $h_{\mathbf{r}}\left(\mathbf{k}\right)=H_2[W\left(\mathbf{k}\right)/W\left(\mathbf{r}\right)]$. Let $F_{\mathbf{r}}$ be the distribution function of this entropy. Among $N_{\mathrm{cand}}$ candidate tests, the probability that the maximum-entropy test has response-1 composition $\mathbf{k}$ is

$$\begin{array}{cc}\hfill p_{\mathbf{r}}\left(\mathbf{k}\right)& ={\displaystyle \prod _{q=1}^3}\left({\displaystyle \genfrac{}{}{0pt}{}{r_q}{k_q}}\right){\rho }^{{\sum }_q{k}_q}{(1-\rho )}^{{\sum }_q(r_q-k_q)},\hfill \\ \hfill {\omega }_{\mathbf{r},N_{\mathrm{cand}}}\left(\mathbf{k}\right)& ={\displaystyle \frac{p_{\mathbf{r}}\left(\mathbf{k}\right)}{F_{\mathbf{r}}\left(h\right)-F_{\mathbf{r}}\left(h^{-}\right)}}\left[F_{\mathbf{r}}{\left(h\right)}^{N_{\mathrm{cand}}}-F_{\mathbf{r}}{\left(h^{-}\right)}^{N_{\mathrm{cand}}}\right],h=h_{\mathbf{r}}\left(\mathbf{k}\right).\hfill \end{array}$$

(4)

Here, $H_2$ is the binary entropy, and $F_{\mathbf{r}}\left(h^{-}\right)$ is the probability of an entropy value strictly below h. Tests with tied entropy values are selected with equal probability. Define ${\mathcal{K}}_{\mathbf{r}}^{+}={\mathcal{K}}_{\mathbf{r}}\setminus \{\mathbf{0},\mathbf{r}\}$. Let ${\alpha }_d\left(\mathbf{r}\right)$ be the mean number of nodes with this composition at depth d in the complete entropy tree. The initial values are ${\alpha }_0\left(\mathbf{m}\right)=1$ and 0 for all other compositions. Let ${\mathbf{r}}^{\prime }$ be the composition to be counted at the next depth, and let ${\gamma }_{d+1}$ be the mean increment in the unnormalized MAP return at test $d+1$. Dividing this increment by Z gives the FIR increment. The indicator ${\mathbf{1}}_{\{·\}}$ equals 1 when its condition holds and 0 otherwise. From the binary tree structure and the additivity of MAP returns,

$$\begin{array}{cc}\hfill {\alpha }_{d+1}\left({\mathbf{r}}^{\prime }\right)& =\sum _{\mathbf{r}}{\alpha }_d\left(\mathbf{r}\right)\sum _{\mathbf{k}\in {\mathcal{K}}_{\mathbf{r}}^{+}}{\omega }_{\mathbf{r},n-d}\left(\mathbf{k}\right)\left[{\mathbf{1}}_{\{{\mathbf{r}}^{\prime }=\mathbf{k}\}}+{\mathbf{1}}_{\{{\mathbf{r}}^{\prime }=\mathbf{r}-\mathbf{k}\}}\right],\hfill \\ \hfill {\gamma }_{d+1}& =\sum _{\mathbf{r}}{\alpha }_d\left(\mathbf{r}\right)\sum _{\mathbf{k}\in {\mathcal{K}}_{\mathbf{r}}^{+}}{\omega }_{\mathbf{r},n-d}\left(\mathbf{k}\right)[M\left(\mathbf{k}\right)+M(\mathbf{r}-\mathbf{k})-M\left(\mathbf{r}\right)].\hfill \end{array}$$

(5)

The sums include only nodes that can be split further, and the maximum depth is $d_{\max }=\min \{n,{\sum }_q{m}_q-1\}$. Because the entropy criterion does not use costs, test costs along a path are sampled without replacement from a finite population. Let $z_{\mathcal{\ell }}$ be the number of tests drawn from cost level ℓ among the first d tests. The probability that these d tests are completed within $\mathrm{Time}$ and the estimated mean return of the truncated entropy tree are

$$\begin{array}{cc}\hfill B_d\left(\mathrm{Time}\right)& ={\left({\displaystyle \genfrac{}{}{0pt}{}{n}{d}}\right)}^{-1}\sum _{\begin{array}{c}0\le z_{\mathcal{\ell }}\le n_{\mathcal{\ell }},{\sum }_{\mathcal{\ell }}{z}_{\mathcal{\ell }}=d\\ {\sum }_{\mathcal{\ell }}{c}_{\mathcal{\ell }}{z}_{\mathcal{\ell }}\le \mathrm{Time}\end{array}}{\displaystyle \prod _{\mathcal{\ell }=1}^{L_C}}\left({\displaystyle \genfrac{}{}{0pt}{}{n_{\mathcal{\ell }}}{z_{\mathcal{\ell }}}}\right),\hfill \\ \hfill \widehat{G}\left(\mathrm{Time}\right)& =M\left(\mathbf{m}\right)+{\displaystyle \sum _{d=1}^{d_{\max }}}{\gamma }_d{B}_d\left(\mathrm{Time}\right).\hfill \end{array}$$

(6)

Online planning, in contrast, considers both the test-induced partition and the remaining time. Let $\mathbf{u}=(u_1,\dots ,u_{L_C})$ denote the remaining numbers of tests at each cost level. Let $\widehat{U}(\mathbf{r},\mathbf{u},t)$ estimate the optimal return with remaining time t, and define $\mathcal{A}=\{\mathcal{\ell }:u_{\mathcal{\ell }}>0,c_{\mathcal{\ell }}\le t\}$. For a candidate test at cost level ℓ, the successor return is $R_{\mathcal{\ell }}\left(\mathbf{k}\right)$; when no effective partition is obtained, it is set to $M\left(\mathbf{r}\right)$. Define $A_{\mathcal{\ell }}\left(v\right)={\sum }_{\mathbf{k}}{p}_{\mathbf{r}}\left(\mathbf{k}\right){\mathbf{1}}_{\{R_{\mathcal{\ell }}\left(\mathbf{k}\right)\le v\}}$. Sort $M\left(\mathbf{r}\right)$ and all distinct candidate return values as $v_0=M\left(\mathbf{r}\right)<\cdots <v_J$, giving $J+1$ distinct values. The mean of the discrete maximum then gives the recursion

$$\begin{array}{cc}\hfill R_{\mathcal{\ell }}\left(\mathbf{k}\right)& =\widehat{U}(\mathbf{k},\mathbf{u}-{\mathbf{e}}_{\mathcal{\ell }},t-c_{\mathcal{\ell }})+\widehat{U}(\mathbf{r}-\mathbf{k},\mathbf{u}-{\mathbf{e}}_{\mathcal{\ell }},t-c_{\mathcal{\ell }}),\mathbf{k}\in {\mathcal{K}}_{\mathbf{r}}^{+},\hfill \\ \hfill \widehat{U}(\mathbf{r},\mathbf{u},t)& =v_0+{\displaystyle \sum _{j=0}^{J-1}}(v_{j+1}-v_j)\left[1-\prod _{\mathcal{\ell }\in \mathcal{A}}{A}_{\mathcal{\ell }}{\left(v_j\right)}^{u_{\mathcal{\ell }}}\right].\hfill \end{array}$$

(7)

Here, ${\mathbf{e}}_{\mathcal{\ell }}$ is a unit vector. The return is 0 for an empty node, and $M\left(\mathbf{r}\right)$ when only one fault remains or no feasible test is available. Under the approximations of node independence, independence of the remaining columns, and conditional-mean closure of successor returns, this recursion estimates the online return in the random-matrix model.

For example, consider four faults with prior probabilities $(100,10,1,1)/112$. A test of duration 1 partitions the faults into $\{s_1,s_3\}$ and $\{s_2,s_4\}$. A test of duration 3 partitions them into $\left\{s_1\right\}$ and $\{s_2,s_3,s_4\}$. The latter has an outcome entropy of approximately $0.49$ bits, exceeding the former’s $0.46$ bits. Thus, a pure entropy criterion selects the duration-3 test first. With a budget of 1, that test remains incomplete, and FIR stays at $100/112$. Performing the duration-1 test first instead gives $110/112$. This example shows that directly truncating a strategy generated by an entropy criterion for the complete process can be suboptimal.

The approximation was checked on 30 independent $8\times 8$ matrices with $\rho =0.50$, fault-grade counts $(1,2,5)$, weights $(100,10,1)$, test-cost counts $(1,2,5)$ for costs $(1,3,10)$, and the fixed absolute budget $\mathrm{Time}=6$. Complete exact dynamic programming supplied the optimum for each matrix; the entropy-tree comparison used uniform selection among tied entropy values. The approximate optimal and entropy-tree mean FIR values were 94.86% and 83.93%, compared with Monte Carlo means of 93.41% and 83.01%. Their 95% t intervals across 30 independent models (29 degrees of freedom) were $[91.87,94.96]\%$ and $[81.13,84.90]\%$, respectively. The estimated loss was 10.93 percentage points, versus an observed mean of 10.40 points, with an interval of $[7.97,12.83]$. The approximation-minus-Monte-Carlo discrepancies were therefore $1.45$, $0.92$ and $0.53$ points. This check quantifies error for this setting and does not establish accuracy at larger sizes.

3. Mathematical Properties of the Online TSG Problem

Monotonicity of the Fault Isolation Rate

Feasible diagnostic-tree expansion cannot reduce terminal MAP return. The identity below supports the lower bounds and stopping rules used by DFVL.

First, consider how the objective changes as a diagnostic tree expands. For any leaf with candidate set A, suppose a feasible test $t_j$ splits it into $A_j^0$ and $A_j^1$, corresponding to responses 0 and 1. Equation (1) gives

$$\begin{array}{cc}\hfill \Delta (A,j)& =\mathrm{FIR}\left(A_j^0\right)+\mathrm{FIR}\left(A_j^1\right)-\mathrm{FIR}\left(A\right)\hfill \\ \hfill & =\min \{\mathrm{FIR}\left(A_j^0\right),\mathrm{FIR}\left(A_j^1\right)\}\ge 0.\hfill \end{array}$$

(8)

The fault with the highest probability in A must belong to one of the child nodes. That child therefore retains the original maximum, while the other child adds a nonnegative isolation gain. Since the tree FIR is the sum of its leaf contributions, expanding any leaf without violating the time constraint makes the whole-tree FIR monotonically nondecreasing.

Each diagnostic path can be expanded using feasible tests until no effective test can be completed within the remaining time, or the candidate faults have been completely isolated. If different faults have identical response signatures across all remaining tests, the node cannot obtain any further isolation gain and should also terminate.

4. An Online TSG Method Based on Delayed-Feedback Value Learning

Online TSG can be formulated as a time-constrained finite-horizon decision process. The state x consists of the current ambiguous fault set, the remaining tests, and the remaining time; an executable test $t_j$ is an action; and the reward is the probability that the terminal MAP decision is correct. The ideal heuristic evaluation function (HEF) is the optimal long-term value $Q^{*}(x,j)$ of a state–test pair within the remaining time and can be evaluated recursively using the Bellman optimality principle.

DFVL learns bounded action values from the returns of completed feasible subtrees. Those returns update a strategy archive and provide delayed labels for multiple state–test pairs. The complete planning procedure also includes model-derived MAP candidates, state-matched subtree reuse, and bounded local search. Figure 2 summarizes the procedure.

Figure 2. DFVL planning for a known model and budget, followed by online traversal of the stored feasible tree.

4.1. Construction of Action-Value Features

The inputs to the action-value network must first be specified. Let the current node state be $x=(A,U,b)$, where A is the ambiguous fault set, U is the set of available tests that have not yet been performed, and b is the remaining time. Let $w\left(A\right)={\sum }_{s_i\in A}{p}_i$ denote the probability mass of this candidate set. Its FIR contribution is defined by Equation (1). The index set of currently feasible tests is $\mathcal{J}\left(x\right)=\{j:t_j\in U,w\left(A\right)>0,c_j\le b,A_j^0\ne ⌀,A_j^1\ne ⌀\}$. For a candidate first test $t_j$, let $\mathcal{T}(x,j)$ be the set of all feasible binary subtrees that start with $t_j$ and whose remaining duration on every path does not exceed b. The ideal HEF is then

$$Q^{*}(x,j)=\underset{\pi \in \mathcal{T}(x,j)}{\max }{\displaystyle \frac{{\sum }_{A^{\prime }\in \mathcal{L}\left(\pi \right)}\mathrm{FIR}\left(A^{\prime }\right)}{w\left(A\right)}},x_j^y=(A_j^y,U\setminus \left\{t_j\right\},b-c_j),$$

(9)

where $A_j^y=\{s_i\in A:d_{ij}=y\}$ and $y\in \{0,1\}$. Let $V^{*}\left(x\right)$ denote the optimal conditional FIR at state x when immediate stopping is allowed. The Bellman optimality principle gives

$$\begin{array}{cc}\hfill Q^{*}(x,j)& =\sum _{\begin{array}{c}y=0,1\\ w\left(A_j^y\right)>0\end{array}}{\displaystyle \frac{w\left(A_j^y\right)}{w\left(A\right)}}{V}^{*}\left(x_j^y\right),\hfill \\ \hfill V^{*}\left(x\right)& =\left\{\begin{array}{cc}\mathrm{FIR}\left(A\right)/w\left(A\right),\hfill & \mathcal{J}\left(x\right)=⌀,\hfill \\ \max \{\mathrm{FIR}\left(A\right)/w\left(A\right),{\max }_{j\in \mathcal{J}\left(x\right)}{Q}^{*}(x,j)\},\hfill & \mathcal{J}\left(x\right)\ne ⌀,\hfill \end{array}\right.\hfill \\ \hfill V^{*}\left((S,T,\mathrm{Time})\right)& =\underset{\pi \mathrm{satisfying}\mathrm{Equation}\left(2\right)}{\max }\mathrm{FIR}\left(\pi \right).\hfill \end{array}$$

(10)

The root probability mass is $w\left(S\right)=1$, so the local conditional value agrees with the overall objective in Equation (2). Branches with zero probability mass are excluded from the weighted sum. Equation (10) decomposes the long-term value of a test into the gain from the current partition and the future values of the two child states. The latter are jointly constrained by the remaining time and fault separability. Accordingly, the input features are extracted from three aspects: immediate gain, remaining time and feasible testing depth, and future separability.

(1) 

Immediate gain. The size of the current ambiguous fault set determines the scope for improvement. After a test divides the set into two subsets, the MAP returns of the two child nodes constitute the achieved FIR. The immediate gain $\Delta (A,j)$ relative to the value before testing is calculated using Equation (8).

(2) 

Remaining time and feasible testing depth. The current remaining time b, the duration $c_j$ of the candidate test, and the tests that remain executable at the child nodes jointly determine the depth of subsequent expansion. For any child state $x^{\prime }=(A^{\prime },U^{\prime },b^{\prime })$, arrange the durations of all remaining tests in $U^{\prime }$ in ascending order as $c_{\left(1\right)},c_{\left(2\right)},\dots$. The remaining time imposes the following upper bound on the number of tests along a path:

$$d\left(x^{\prime }\right)=\min \left\{|A^{\prime }|-1,\max \left\{r\in \{0,\dots ,|U^{\prime }\left|\right\}:{\displaystyle \sum _{\mathcal{\ell }=1}^r}{c}_{\left(\mathcal{\ell }\right)}\le b^{\prime }\right\}\right\}.$$

(11)

(3) 

Future separability. Even when sufficient time is available, faults with identical responses cannot be distinguished using the available tests. Faults with the same response vector over $U^{\prime }$ belong to the same signature class. Suppose there are $k\left(x^{\prime }\right)$ such classes, and let $a_{\left(1\right)}\left(x^{\prime }\right),\dots ,a_{\left(k\right)}\left(x^{\prime }\right)$ be their maximum prior probabilities in descending order. A binary subtree with depth no greater than $d\left(x^{\prime }\right)$ can have at most $2^{d\left(x^{\prime }\right)}$ leaves, and faults within the same signature class cannot be separated further. An upper bound on the subtree FIR is therefore

$$F\left(x^{\prime }\right)={\displaystyle \sum _{r=1}^{\min \{k\left(x^{\prime }\right),2^{d\left(x^{\prime }\right)}\}}}{a}_{\left(r\right)}\left(x^{\prime }\right).$$

(12)

With the first test $t_j$ fixed, a one-step look-ahead at each of the two child nodes provides a feasible lower bound. Summing their bounds from Equation (12) gives an upper bound:

$$\begin{array}{cc}\hfill {\mathcal{\ell }}_j\left(x\right)& ={\displaystyle \frac{1}{w\left(A\right)}}{\displaystyle \sum _{y=0}^1}\left[\mathrm{FIR}\left(A_j^y\right)+\underset{k\in \mathcal{J}\left(x_j^y\right)}{\max }\Delta (A_j^y,k)\right],\hfill \\ \hfill u_j\left(x\right)& ={\displaystyle \frac{F\left(x_j^0\right)+F\left(x_j^1\right)}{w\left(A\right)}},{\mathcal{\ell }}_j\left(x\right)\le Q^{*}(x,j)\le u_j\left(x\right).\hfill \end{array}$$

(13)

If a child node has no feasible test, the corresponding maximum immediate gain in this expression is set to 0.

The information from these three aspects is normalized and supplied to the network. For $x^{\prime }=(A^{\prime },U^{\prime },b^{\prime })$, define the five-dimensional child-node feature vector as

$$\psi (x^{\prime };x)=\left({\displaystyle \frac{w\left(A^{\prime }\right)}{w\left(A\right)}},{\displaystyle \frac{\mathrm{FIR}\left(A^{\prime }\right)}{w\left(A^{\prime }\right)}},{\displaystyle \frac{\left|\mathcal{J}\right(x^{\prime }\left)\right|}{\max \{1,|U^{\prime }\left|\right\}}},{\displaystyle \frac{d\left(x^{\prime }\right)}{\max \{1,|A^{\prime }|-1\}}},{\displaystyle \frac{k\left(x^{\prime }\right)}{|A^{\prime }|}}\right).$$

(14)

These five quantities represent, respectively, the child-branch probability mass, the current MAP return, the proportion of feasible subsequent tests, the remaining feasible testing depth, and the proportion of distinguishable fault classes. The two child branches are ordered by increasing probability mass. When their masses are equal, they are ordered by response value, 0 before 1. The resulting vectors are denoted by ${\psi }^{\left(1\right)}$ and ${\psi }^{\left(2\right)}$. Combining them with the parent-node size and remaining time, the current test duration and immediate gain, and the value bounds gives

$$\begin{array}{cc}\hfill \varphi (x,j)=(& \left|A\right|/\left|S\right|,b/\mathrm{Time},c_j/b,\Delta (A,j)/w\left(A\right),{\mathcal{\ell }}_j\left(x\right),u_j\left(x\right),\hfill \\ \hfill & {\psi }^{\left(1\right)},{\psi }^{\left(2\right)})\in {\mathbb{R}}^{16}.\hfill \end{array}$$

(15)

The vector contains 16 normalized features. If $\mathrm{Time}=0$ or no feasible test is available, the procedure terminates without computing action features. The ratio $c_j/b$ is computed only when $b>0$ and $t_j$ is executable. Conditional values and their features are defined for states with positive probability mass. A branch with zero probability mass terminates immediately, contributes 0 to the FIR, and has its conditional features set to a zero vector.

4.2. Training Sample Generation and Archive Retention

Training samples are generated through state sampling, tree completion, and return recording. Their coverage is controlled by the starting states, exploratory tree completions, and fixed per-state completion quotas.

(1) 

State coverage and exploration. Starting states alternate between the root and a reachable intermediate state of the same supplied model. Intermediate states use feasible prefixes whose target depths cycle from one to six; tests are drawn uniformly and branches according to their prior mass. Each training round collects fresh initial completions for feasible first tests, stopping early if a root tree attains a valid upper bound. Network parameters and exploration probability remain fixed within that round. Each round generates fresh feasible completions, while the feasible-tree archives and feedback labels persist across rounds. With probability $\epsilon$, a completion selects uniformly among feasible tests other than its current highest-scoring test, when alternatives exist; otherwise it uses that highest-scoring test.

(2) 

Tree feedback and the archive. Let $\pi$ denote the feasible subtree obtained from each completion; it satisfies the time constraint on every path. Let v denote a tree node, $v_y$ its child for response y, and $A_v$ its candidate fault set. For nodes with positive probability mass, the achieved return is backed up from the leaves to the root:

$$Y_v=\left\{\begin{array}{cc}\mathrm{FIR}\left(A_v\right)/w\left(A_v\right),\hfill & v\mathrm{is}\mathrm{a}\mathrm{leaf}\mathrm{node},\hfill \\ {\displaystyle \sum _{\begin{array}{c}y=0,1\\ w\left(A_{v_y}\right)>0\end{array}}\frac{w\left(A_{v_y}\right)}{w\left(A_v\right)}{Y}_{v_y},}\hfill & v\mathrm{is}\mathrm{an}\mathrm{internal}\mathrm{node}.\hfill \end{array}\right.$$

(16)

If a completion starts from $x=(A,U,b)$, then $Y_{\mathrm{root}\left(\pi \right)}=\mathrm{FIR}\left(\pi \right)/w\left(A\right)$. For a completion from the root state, this value is the overall FIR of the tree. Branches with zero probability mass contribute zero and are excluded from the conditional-value backup. For each state–first-test pair, the highest achieved conditional value is retained as the label $B(x,j)$. Separately, the state archive retains a highest-return feasible completed subtree for each state. The root archived tree is a final candidate independently of the current greedy network tree. The best achieved value at a state is

$$B(x,j)\leftarrow \max \left\{B(x,j),Y_{\mathrm{root}\left(\pi \right)}\right\},B\left(x\right)=\max \left\{{\displaystyle \frac{\mathrm{FIR}\left(A\right)}{w\left(A\right)}},\underset{j\in \mathcal{J}\left(x\right)}{\max }B(x,j)\right\}.$$

(17)

The achieved conditional FIR of each node is backed up according to Equation (16). For an internal node v, let $x_v=(A_v,U_v,b_v)$ be its state, $j_v$ the index of its selected test, and $A_v$ its candidate fault set. Each node provides a sample $i=(x_v,j_v)$, which is stored in the sample repository $\mathcal{D}$ together with $\varphi (x_v,j_v)$, $B(x_v,j_v)$, and the completion indicator $h_i$. Only when all feasible completions for the state–first-test pair have been enumerated or the archived value reaches the upper bound $u_{j_v}\left(x_v\right)$ is $h_i=1$ assigned; otherwise, $h_i=0$. Thus, one tree provides feedback for multiple nodes. In this method, all feedback is backed up together after tree completion.

(3) 

Balanced additional completions. After initial coverage, let $B_0\left(x\right)$ be the best achieved conditional value at the sampled state. The eligible first tests are those whose valid upper bounds exceed $B_0\left(x\right)$ by the numerical tolerance. This eligibility set and $B_0\left(x\right)$ remain fixed throughout the additional-completion stage. The eligible tests are visited cyclically in increasing test-index order, up to a total quota $\beta \left|\mathcal{J}\right(x\left)\right|$. This rule balances attempts among the fixed eligible actions. An empty eligible set ends this stage. A feasible root tree attaining the valid root upper bound may end routine completion early. Every achieved subtree is backed up to the archive and label repository.

The network and exploration probability remain fixed within the round. Let K be the maximum number of sampled starting states. Exploration decreases linearly with round k:

$${\epsilon }_k={\epsilon }_{\max }-({\epsilon }_{\max }-{\epsilon }_{\min }){\displaystyle \frac{k-1}{\max \{1,K-1\}}}.$$

(18)

Maximum completion quotas need not equal realized work because eligibility and valid optimality certificates can stop completion.

4.3. Delayed Feedback and Action-Value Network Updates

The action-value network uses a valid return interval and distinguishes achieved feasible lower bounds from certified complete targets. All eligible normalized residuals have equal weight.

(1) 

Value interval constraint. Let the network output be $z_{\theta }\left(\varphi \right)\in [0,1]$, and let the interval width be $r_j\left(x\right)=u_j\left(x\right)-{\mathcal{\ell }}_j\left(x\right)$. The estimated action value of a candidate test is

$${\widehat{Q}}_{\theta }(x,j)={\mathcal{\ell }}_j\left(x\right)+r_j\left(x\right)z_{\theta }\left(\varphi (x,j)\right).$$

(19)

(2) 

Feedback completion status. For a state–action sample $i=(x_v,j_v)$, write ${\varphi }_i=\varphi (x_v,j_v)$, ${\mathcal{\ell }}_i={\mathcal{\ell }}_{j_v}\left(x_v\right)$, $u_i=u_{j_v}\left(x_v\right)$, and $r_i=u_i-{\mathcal{\ell }}_i=r_{j_v}\left(x_v\right)$. Construct the error using the latest archived value $B_i=B(x_v,j_v)$. The indicator $h_i=1$ means that all feasible completions have been exhaustively searched or the archived value has reached the upper bound; $h_i=0$ means that the archive remains a feasible lower bound on the long-term value:

$${\xi }_i=\left\{\begin{array}{cc}{z}_{\theta }\left({\varphi }_i\right)-(B_i-{\mathcal{\ell }}_i)/r_i,\hfill & h_i=1(\mathrm{optimum}\mathrm{determined}),\hfill \\ \min \{z_{\theta }\left({\varphi }_i\right)-(B_i-{\mathcal{\ell }}_i)/r_i,0\},\hfill & h_i=0(\mathrm{optimum}\mathrm{not}\mathrm{yet}\mathrm{determined}).\hfill \end{array}\right.$$

(20)

When $r_i=0$, the interval value is already determined, and the sample need not be included in network fitting through Equation (20). The achieved archived value, optimal value, and valid bounds satisfy

$$\max \{{\mathcal{\ell }}_i,B_i\}\le Q^{*}(x_v,j_v)\le u_i,h_i=1⟹B_i=Q^{*}(x_v,j_v).$$

Complete feedback is used to fit the determined optimal conditional value. Partial feedback is an achieved feasible lower bound, so the one-sided loss corrects predictions below that bound. Certified complete feedback gives a two-sided target. Interval parameterization restricts predictions to valid lower–upper bounds, but a prediction need not be the return of a realizable tree and can exceed the unknown $Q^{*}$. Thus, the current loss does not guarantee elimination of overestimation.

(3) 

Unweighted normalized residuals. Draw a mini-batch from the label repository $\mathcal{D}$, remove duplicate state–action labels from the same original model, and exclude samples with $r_i\le {10}^{-12}$ as numerically fixed intervals. Denote the remaining nonempty batch by ${\mathcal{D}}_{\mathrm{batch}}$. The factor $r_i$ remains in the target normalization in Equation (20); it is not used as a sample weight. Fault priors still define the terminal MAP objective and the achieved subtree returns. The loss and update are  

$$\begin{array}{cc}\hfill {\mathcal{L}}_{\mathrm{data}}\left(\theta \right)& ={\displaystyle \frac{1}{2|{\mathcal{D}}_{\mathrm{batch}}|}}\sum _{i\in {\mathcal{D}}_{\mathrm{batch}}}{\xi }_i^2,\hfill \\ \hfill \mathcal{L}\left(\theta \right)& ={\mathcal{L}}_{\mathrm{data}}\left(\theta \right)+{\displaystyle \frac{\kappa }{2}}\sum _l{\parallel W_l\parallel }_F^2,\hfill \\ \hfill g& ={\nabla }_{\theta }\mathcal{L}\left(\theta \right),\tilde{g}={g\min \{1,5/\max (\parallel g\parallel }_2,{ϵ}_{\mathrm{num}}\left)\right\},\hfill \\ \hfill v^{+}& =0.90v+\tilde{g},{\theta }^{+}=\theta -{\eta }_{\theta }{v}^{+}.\hfill \end{array}$$

No update is made for an empty eligible batch. The implementation uses $\kappa ={10}^{-5}$ on weight matrices, momentum 0.90, and global gradient clipping at 5. Biases are not regularized; v is the momentum buffer.

4.4. Algorithm Workflow and Complexity Analysis

Algorithm 1 summarizes the offline planning procedure for a given MSFG and time budget.

Planning is performed offline for each known MSFG and budget. Two model-derived MAP trees are constructed using immediate and feasible two-step gain per cost. They are retained as candidates for final selection. Only when such a candidate reaches the valid root upper bound is it inserted before routine training, providing a certified shortcut that avoids further completions; eligible candidate feedback can still support at most two network updates. Otherwise, training starts from its own feasible completions. After training, a greedy network tree is added to the archive. Candidates are evaluated using the supplied model, archived subtrees are combined only at matching states $(A,U,b)$, and bounded local search retains improvements. The final DFVL output is the best feasible tree found, rather than necessarily the greedy network tree. Mix1/DIG trees and their returns do not enter this construction.

The final search uses at most two passes, considers three candidate first tests at a visited search state, and allows 100 additional completions. Exact local search is restricted to at most six candidate faults and 3000 expanded nodes overall. Search may stop when a feasible tree attains a valid model-derived upper bound. These are planning limits; no wall-clock cutoff selects the reported trees.

Once a fault occurs, online execution directly uses the tree $\widehat{\pi }$ stored offline. Algorithm 2 obtains the response to the test specified at the current node and follows the corresponding branch until it outputs the MAP decision stored at a leaf.

Let $W_{\mathrm{ANN}}$ denote the number of elementary operations in one network forward pass. In a naive implementation, evaluating child-node separability for each candidate test requires scanning the remaining test responses. Sorting the maximum prior probabilities of signature classes introduces an additional logarithmic factor. Including network scoring of candidate actions gives the cost at a single node. Each nonempty binary split adds at least one leaf, so a complete tree contains at most $m-1$ internal nodes. The time complexities for processing one node and generating the complete tree are therefore

$$\begin{array}{cc}\hfill {\mathcal{C}}_{\mathrm{node}}& =O(m{n}^2+nm\log m+n{W}_{\mathrm{ANN}}),\hfill \\ \hfill {\mathcal{C}}_{\mathrm{tree}}& =O(m^2{n}^2+n{m}^2\log m+mn{W}_{\mathrm{ANN}}).\hfill \end{array}$$

(21)

The total offline cost includes model-derived candidate construction, balanced training completions, network updates, and final tree search. If round k uses $R_k$ completions and $U_k$ updates, its cost can be decomposed as

$${\mathcal{C}}_{\mathrm{off}}={\mathcal{C}}_{\mathrm{cand}}+{\displaystyle \sum _{k=1}^{K_{\mathrm{actual}}}}\left(R_k{\mathcal{C}}_{\mathrm{tree}}+U_k{\mathcal{C}}_{\mathrm{SGD}}\right)+{\mathcal{C}}_{\mathrm{final}}.$$

(22)

Here ${\mathcal{C}}_{\mathrm{final}}$ includes network-tree construction, archive combination and bounded local/exact search. Maximum configuration values need not equal realized work. The online representation stores only a test index, two child addresses and a MAP decision per node. Consequently, pure traversal costs $O\left(\right|\xi \left|\right)$ and compact tree storage costs $O\left(m\right)$. The full research archive also contains candidate sets and is distinct from this compact deployment representation.

$${\mathcal{C}}_{\mathrm{on}}=O\left(\right|\xi \left|\right),\left|\xi \right|\le \min \left\{m-1,⌊{\displaystyle \frac{\mathrm{Time}}{{\min }_j{c}_j}}⌋\right\}.$$

(23)

Algorithm 1 DFVL planning for one known MSFG and time budget

Require:  Given $(D,P,C)$, budget $\mathrm{Time}$, fixed parameters and seed Ensure:  A stored feasible diagnostic tree $\widehat{\pi }$   1: Initialize network $\theta$, archive B and label repository $\mathcal{D}$   2: Construct immediate and two-step MAP-gain/cost candidate trees from $(D,P,C,\mathrm{Time})$   3: If a candidate attains the root upper bound, record it; use eligible certified feedback for at most two network updates and skip routine completions   4: if no initial candidate certifies the optimum then   5:     for $k=1,\dots ,K$ do   6:         Sample a root or reachable intermediate state $x=(A,U,b)$   7:         Compute feasible first tests and valid value bounds; freeze $\theta ,{\epsilon }_k$   8:         Collect up to $N_{\mathrm{init}}$ completions per feasible first test, stopping if the root optimum is certified   9:         Back up each feasible tree to update B and state–action labels in $\mathcal{D}$ 10:         Freeze $B_0\left(x\right)$ and eligible first tests; set quota $\beta \left|\mathcal{J}\right(x\left)\right|$ 11:         for each permitted balanced completion do 12:            Visit the eligible tests cyclically in increasing index order; stop if none remain 13:            Complete the selected first test; back up feasible feedback and labels 14:            if a root tree attains the valid upper bound then 15:                Stop routine completion 16:            end if 17:         end for 18:         Mark feedback complete only when proved by exhaustive search or a valid upper bound 19:         Update the network from eligible archived labels after all current-round feedback 20:         if the root optimum has been certified then 21:            break 22:         end if 23:     end for 24: end if 25: Build a greedy network tree; add it and the model-derived candidates to the archive 26: Combine archived subtrees only at matching $(A,U,b)$ states 27: Perform bounded local search and small-substate exact search, retaining feasible improvements 28: Select the largest-FIR feasible tree found; ties prefer smaller maximum path duration 29: Store test indices, child addresses and terminal MAP decisions

Algorithm 2 Online fault diagnosis along a pregenerated diagnostic tree

Require:  Stored diagnostic tree $\widehat{\pi }$ Ensure:  Diagnosis $\widehat{s}$, executed test sequence $\mathcal{E}$, and cumulative duration t 1: $v\leftarrow \mathrm{root}\left(\widehat{\pi }\right)$; $t\leftarrow 0$; $\mathcal{E}\leftarrow \left(\right)$ 2: whilev is an internal node do 3:     Read from v the stored test index j; execute $t_j$ and wait for completion 4:     Obtain the test response $y\in \{0,1\}$; $t\leftarrow t+c_j$ 5:     Append $t_j$ to $\mathcal{E}$; $v\leftarrow \mathrm{child}(v,y)$ 6: end while 7: $\widehat{s}\leftarrow v$’s stored MAP fault index 8: return$(\widehat{s},\mathcal{E},t)$

5. Experimental Validation

5.1. Experimental Setup

The evaluations comprise simulations and an engineering-model calculation for a power-grid measurement device. Simulations compare FIR across problem sizes and time budgets. The engineering case considers a single acquisition resource and a limited diagnostic window. FIR is the sole performance measure; timings and storage describe implementation cost. Calculations used MATLAB R2018b on 64-bit Windows 11 Pro, with an Intel Core i5-12400 processor and approximately 16 GB RAM.

DFVL is trained separately for each supplied D/P/C model and time budget, including the device model. Two training settings were compared: $K=12$ with at most two updates per eligible round, and $K=32$ with at most eight updates per eligible round. The 18 model–budget conditions comprised three sizes ($m=n=30,60,100$), two models per size, and three relative budgets ($\alpha =0.20,0.26,0.40$). These conditions form a subset of the formal evaluation. Both settings achieved a mean full-pipeline FIR of 77.09%; the ${10}^{-10}$ tie rule selected the smaller setting, which was then fixed for the formal evaluations. The final parameters are listed in Table 1, and state sampling and stopping rules are specified in Section 4.2.

Table 1. Experimental settings for the algorithms.

Algorithm	Main Parameters and Training Settings
DFVL	Network $16\to 64\to 32\to 1$, ReLU hidden and Sigmoid output; $K=12$, $N_{\mathrm{init}}=2$, $\beta =2$, at most two updates per eligible round; ${\epsilon }_{\max }=0.30$, ${\epsilon }_{\min }=0.05$; balanced additional completions and unit-weight normalized residuals; learning rate 0.01, batch 256, momentum 0.90, $\kappa ={10}^{-5}$, gradient clip 5; final limits: two passes, width 3, 100 completions, local exact states with at most six faults and 3000 node expansions overall
Mix1	Mixing weight ${\alpha }_{\mathrm{Mix}1}\left({\rho }_D\right)=0.01+0.67/[1+{({\rho }_D/0.40)}^{10}]$, where ${\rho }_D={\sum }_i{\sum }_j{d}_{ij}/\left(mn\right)$ is the empirical proportion of entries in the initial D matrix that equal 1
DIG	Node-conditional information score per cost, defined in the text; deterministic lowest-index tie breaking

Mix1 and DIG receive the same $D,P,C$ and use the same terminal MAP decisions as DFVL. DIG uses node-conditional probabilities $q_i=p_i/w\left(A\right)$ and $q_0=w\left(A_j^0\right)/w\left(A\right)$, with score $[-q_0{\log }_2{q}_0-{\sum }_{i\in A_j^1}{q}_i{\log }_2{q}_i]/c_j$ and $0{\log }_{2}0=0$; tied scores select the smallest test index. Budget-aware variants first exclude tests that cannot finish. Two further references maximize immediate MAP gain per cost and feasible two-step MAP gain per first-test cost; they also supply DFVL’s model-derived candidate trees.

The independent sampling unit is the D/P/C model. Overall comparisons average the 12 paired budget differences within each of the 90 models before constructing paired t intervals (89 degrees of freedom) and two-sided exact sign tests, with Holm adjustment for the two DFVL–baseline comparisons. Pointwise intervals use ten models (9 degrees of freedom), conditional on recorded algorithm seeds. Repeated budgets or seeds are not independent model replicates.

5.2. Simulation Experiments

This subsection examines the effects of problem size and time budget on algorithm performance. Nine sizes, $m=n=20,30,\dots ,100$, were considered, with 10 independently generated MSFG instances for each size. For each instance, all algorithms use the same D, P, C, and actual time budget, and their mean FIR is compared at different budget levels.

The simulation data were generated as follows. The entries of D are independently Bernoulli distributed. Faults are assigned to grades B, C, and D in specified count ratios, and the grade weights in Section 2.3 are normalized to obtain P. Tests are assigned to three duration levels in specified count ratios to obtain C. The same distribution parameters and grade ratios are used for all sizes. When the specified ratios do not yield integer counts, the largest remainder method is used. The settings are listed in Table 2.

Table 2. Simulation data and time budget settings.

Setting	Value
Numbers of faults and tests	$m=n=20,30,\dots ,100$
Instances per problem size	10
Bernoulli parameter $\mathrm{Pr}(d_{ij}=1)$	$0.50$
Prior weights of individual faults in the three grades	$100:10:1$
Fault count ratio across the three grades	$2:5:10$
Test durations at the three levels	1, 3, and 10
Test count ratio across the three duration levels	$1:5:10$
Common reference time $T_{\max }$	Maximum path duration among the trees of the two comparison baselines, Mix1 and DIG
Relative time budget levels $\alpha$	$0.20,0.22,0.23,0.24,0.25,0.26,$ $0.28,0.30,0.40,0.44,0.50,0.60$

For comparison baseline a, let ${\pi }_a^{\mathrm{ref}}$ denote its complete diagnostic tree, and let $\mathcal{P}\left({\pi }_a^{\mathrm{ref}}\right)$ denote its set of root-to-leaf paths. For each instance, the common reference time is the maximum path duration among the Mix1 and DIG trees. The budget at each level is defined as

$$\begin{array}{cc}\hfill T_{\max }& =\underset{a\in \{\mathrm{Mix}1,\mathrm{DIG}\}}{\max }\left\{\underset{\xi \in \mathcal{P}\left({\pi }_a^{\mathrm{ref}}\right)}{\max }\sum _{t_j\in \xi }{c}_j\right\},\hfill \\ \hfill \mathrm{Time}& =\alpha T_{\max }.\hfill \end{array}$$

(24)

For each model, Mix1 and DIG retain their complete-tree test order. The next response is included only when its test finishes by the deadline; equality is included within the numerical tolerance ${10}^{-10}\max \{1,{\sum }_j{c}_j\}$. If the next test cannot finish, the strategy stops at the current node and makes its stored MAP decision; it does not skip to another test. DFVL instead plans a feasible tree directly under the same budget. Zero and repeated response rows are retained for every method.

For each problem size, the result at each budget level is the mean over the 10 instances:

$${\overline{\mathrm{FIR}}}_a\left(\alpha \right)={\displaystyle \frac{1}{10}}{\displaystyle \sum _{s=1}^{10}}{\mathrm{FIR}}_{a,s}\left(\alpha T_{\max }^{\left(s\right)}\right),$$

(25)

where a and s index the algorithm and instance, respectively. At zero budget, the initial MAP decision is retained. If D contains identical fault-response rows, the corresponding indistinguishable ambiguity sets are retained. Figure 3 presents the results for the nine sizes; the horizontal and vertical axes in each panel show $\alpha$ and mean FIR, respectively.

Figure 3. Mean terminal MAP FIR at nine problem sizes and twelve relative budgets. Lines connect the observed means across ten independent D/P/C models per size. Shaded bands are pointwise 95% t intervals ($n=10$, 9 degrees of freedom), conditional on the recorded algorithm seeds. Methods share the model inputs and deadline $\alpha T_{\max }$.

(1) 

Effect of the time budget. As shown in Figure 3, the mean FIR of each algorithm generally increases in steps with $\alpha$ at all nine sizes. At small budgets, whether a test finishes before the deadline directly changes the terminal ambiguity sets, producing plateaus and increases in the curves. As the budget increases, more tests can be completed, and the isolation rates of the three methods gradually increase. Separate finite planning runs at different budgets need not return nested DFVL trees, so its observed curve need not be monotone.

(2) 

Effect of problem size. From $20\times 20$ to $100\times 100$, the differences between algorithms vary with both problem size and budget. DFVL and Mix1 differ more clearly under some tight-budget conditions, while Mix1 approaches DFVL over some intervals at the larger sizes. Changing the problem size alters the possible fault partitions and time allocations; consequently, the differences in isolation gain do not simply increase monotonically with the number of faults or tests.

(3) 

Performance differences between algorithms. Across the 1080 model–budget conditions, mean FIR was 83.53% for DFVL, 77.96% for Mix1 and 73.24% for DIG. The model-level mean paired gains were 5.58 percentage points over Mix1 (95% interval 4.88–6.27) and 10.29 over DIG (8.79–11.80), with Holm-adjusted $p=3.23\times {10}^{-27}$ for both comparisons. The budget-aware Mix1 and DIG means were 77.96% and 73.58%; the two-step and immediate MAP references gave 82.47% and 81.58%. These comparisons evaluate the complete hybrid DFVL procedure, which combines value learning, historical-tree retention, model-derived MAP candidates, and bounded search.

The Bernoulli $\left(0.50\right)$ simulations are controlled randomized comparisons; they do not reproduce the sparse response structure or fault-grade composition of the device model.

Retained-history ablation. The control starts from the same learned prefix, network, feedback labels, and random-generator state as DFVL. Before final search, only the control clears inherited feasible-tree entries and removes the root archived candidate. The two MAP candidates, current network tree, subsequent new archiving and final-search limits are retained. This comparison evaluates the joint effect of retaining historical feasible trees and their archived root candidate.

Figure 4 compares Mix1, DIG, DFVL and this control on all ten $60\times 60$ models at all twelve budgets, giving 120 paired conditions. After averaging the twelve paired differences within each model, the mean DFVL-minus-control difference was 0.63 percentage points (95% t interval $[-0.01,1.27]$, ten models, 9 degrees of freedom). The condition-level win/tie/loss count was 23/95/2. The interval includes zero, and the observed effects vary across models and budgets.

Figure 4. Four-strategy retained-history ablation on ten $60\times 60$ models at twelve relative budgets. Lines connect the observed means; shading gives pointwise 95% t intervals across the ten models (9 degrees of freedom), conditional on recorded seeds. The four strategies use the same $D,P,C$ and deadline $\alpha T_{\max }$. The shading colors match the curves: orange for DIG, blue for Mix1, red for DFVL, and purple for DFVL without retained history.

On 30 independent $8\times 8$ models at an absolute budget of 6, DFVL attained the independent Bellman optimum in all cases: mean FIR 93.41%, versus 93.07% for Mix1 and 92.43% for DIG. The exact solutions were not supplied to DFVL.

Three-seed repeats on twenty additional $60\times 60$ models at $\alpha \in \{0.20,0.26,0.40\}$ gave a mean within-model/budget FIR sample SD of 0.13 percentage points (maximum 1.96); 45 of 60 groups tied across seeds.

At $m=n=60$ and $\alpha =0.20$, changing ${\epsilon }_{\max }$ from 0.30 to 0.15 or $\beta$ from 2 to 1 left all ten matched FIR values unchanged (mean 68.94%). This local check describes the stated setting.

5.3. Engineering-Model Evaluation of a Power-Grid Measurement Device

An engineering-model calculation was performed for a $\mu$PMU measurement device installed in a distribution cabinet; the platform is shown in Figure 5. The reported FIR values are calculated from supplied D/P/C inputs, not hardware fault-injection outcomes. This device is susceptible to faults during continuous operation, so BIT must be incorporated at the design stage to support fault detection and diagnosis during service. The device continuously acquires and analyzes current, voltage, and phasor data. Fault diagnosis uses measurements obtained under load and the relationships among them. Once the device is taken offline or unloaded, the response data for the corresponding load conditions are unavailable, and the criteria for the relevant in-service tests lose their required data basis. Therefore, faults within the device must be diagnosed during normal load operation.

Figure 5. Measurement device and existing test access used to define the engineering model.

Because of space and resource constraints, the device uses a single-channel acquisition card connected to different test points through multiplexed switching. Switching during acquisition affects the waveform being recorded. Each test must therefore complete the prescribed acquisition interval and decision process before the system switches to the next test point. Tests require different numbers of waveform cycles; together with switching, settling, and analysis times, these requirements produce different execution costs. BIT therefore uses sequential tests that share a single acquisition resource.

The internal diagnostic window is $\mathrm{Time}=36$ in normalized units; its physical conversion is not disclosed. Costs $1,3,9$ use the same normalization and include switching, settling, acquisition, analysis, and diagnostic decision time.

The fixed model contains 57 faults, 43 tests and 18 test points. The supplied fault grades contain 19, 23 and 15 faults, with weights $100,10,1$ and a total weight of 2145. The cost levels contain 8, 30 and 5 tests. Input elicitation and inter-expert agreement are outside this strategy-generation study. Appendix A provides every model entry and the fault/test definitions.

There are 176 nonzero entries in D, a density of 7.18%. The existing test access produces nine zero-response rows ($s_8,s_9,s_{10},s_{14},s_{15},s_{22},s_{43},s_{52},s_{53}$), with a total weight of 441, and five additional repeated-signature pairs. All faults are retained. The 44 response-equivalence classes give an unlimited-time MAP ceiling of $1673/2145$ (78.00%). These are coverage and discrimination limits of the fixed test-point layout.

Figure 6 shows the multi-signal flow graph and available test points of the measurement device.

Figure 6. Multi-signal flow graph and available test points of the measurement device. The red arrows indicate the data bus.

Table 3 compares the four strategies at normalized budgets 12, 24, and 36. The retained-history control uses the matched-prefix definition in Section 5.2.

Table 3. Model-based FIR under nominal priors at three normalized device budgets.

Time	Mix1 (%)	DIG (%)	DFVL (%)	DFVL w/o Retained History (%)
12	15.43	19.63	34.08	30.91
24	38.51	42.66	57.11	50.63
36	53.15	61.86	75.90	66.71

At Time 36, DFVL gave FIR 75.90%, versus 53.15% for Mix1 and 61.86% for DIG. Their correct-decision weights were 1628, 1140, and 1327 out of 2145, respectively. DFVL remained 2.10 percentage points below the unlimited-time ceiling. Historical-tree retention increased FIR by 3.17, 6.48 and 9.18 percentage points at budgets 12, 24 and 36, respectively. Appendix B shows the three nominal-Time36 trees.

Prior sensitivity. With D, C, and Time = 36 unchanged, all four strategies were regenerated using uniform priors $p_i=1/57$, and DFVL was retrained for this model and budget. FIR was 59.65% for Mix1 and DIG, 66.67% for DFVL and 59.65% for the control. The corresponding unlimited-time ceiling was $44/57$ (77.19%).

Implementation resources. Nominal-Time36 offline planning took 180.46 s: candidate construction 0.11 s, training 178.45 s, network-tree construction $5.80\times {10}^{-3}$ s and final search 1.89 s. Training included 170.19 s of completion and 0.27 s of batch updates. The 69-node deployment table used 1104 B (494 B serialized); the network object used 26,840 B, or 53,656 B with optimizer buffers. After one untimed traversal of all 57 fault cases, software traversal was measured using MATLAB’s tic/toc functions over five batches, each repeating the 57 cases 1000 times. Traversal used the preconstructed deployment table and deterministic responses stored in D. The mean batch duration divided by 57,000 was $2.14\times {10}^{-7}$ s/path. These are software timing and object-size measurements, not peak process RAM or a conversion of normalized Time to physical seconds. Decision time is already included in C.

6. Conclusions

Traditional offline methods generally optimize diagnostic cost while satisfying isolation requirements, rather than directly optimizing the time-constrained FIR defined in this study. To address this problem, an online TSG optimization formulation was established using an MSFG. DFVL combines value recursion and delayed feasible-subtree feedback with historical-tree retention, model-derived MAP candidates, and bounded search. Balanced completions and unweighted normalized residuals define its sampling and learning rules.

Across nine problem sizes and twelve budgets, mean FIR was 83.53% for DFVL, 77.96% for Mix1 and 73.24% for DIG. At a normalized device budget of 36, the respective FIR values were 75.90%, 53.15% and 61.86%. Historical-tree retention improved device FIR by 3.17–9.18 percentage points; its model-averaged simulation effect was 0.63 points, with a 95% interval spanning zero.

The study assumes one listed fault at a time, given D/P/C, deterministic responses, and fixed durations. Each model and budget requires its own offline planning. The device results are model calculations, not field diagnostic accuracy. The effects of test errors and duration fluctuations on strategy performance remain to be investigated. Future work will incorporate unreliable tests and random durations and evaluate the method in more complex engineering systems.