Are Diagnostic Concepts Within the Reach of LLMs?

Model-based diagnosis (MBD) is a cornerstone of system health monitoring, allowing for the identification of faulty components based on observed behavior and a formal system model. One common approach within MBD is structural analysis [8]. Structural analysis is used to obtain Analytical Redundancy Relations (ARRs) for fault diagnosis. Performing structural analysis means abstracting the system model by keeping only the links between equations and variables. The main advantages are that it can be applied to large-scale systems, linear or non-linear, and even under uncertainty. Structural analysis uses the computation of Minimal Structurally Overdetermined sets (MSOs), i.e. sets that contain one equation more than the number of variables. Due to this overdetermined property, they play a key role in detecting and isolating faults [4]. Traditionally, the computation of MSOs is performed using dedicated tools such as the Fault Diagnosis Toolbox (FDT) [5], which apply algorithmic methods grounded in analytical redundancy and structural analysis. On the other hand, the main disadvantage of using tools such as the FDT is that they require a correct and reliable model of the underlying system.

With the recent rise of large language models (LLMs), which demonstrate impressive capabilities in reasoning, synthesis, and symbolic manipulation, a question naturally arises: can these models be repurposed to perform structured engineering tasks, such as generating MSO sets directly from system diagrams, thus reducing the need to rely on manually specified models? If so, this could open new avenues for intuitive, rapid prototyping and integration of natural language interfaces into diagnostic systems.

In this work, we propose an exploratory evaluation of LLMs’ ability to generate MSO sets from engineering documentation, comparing its outputs to those produced by the Fault Diagnosis Toolbox [5]. We aim to assess both the correctness and completeness of the MSO sets proposed, as well as to identify the strengths and limitations of using LLMs in such a formal and structured context. We perform a similar analysis for the generation of conflicts and diagnoses. Our goal is not only to measure performance, but also to understand the potential and boundaries of LLMs in a field traditionally dominated by rule-based and algorithmic approaches.

We carry out the test on the OpenAI models: 4o-mini, o1¹¹1https://openai.com/o1/, and o3-mini²²2https://openai.com/index/openai-o3-mini/, as the o-series of models shows leading performance in math, coding, and science questions³³3Shortly before the submission of the paper the new models were released: o3 and o4-mini, so further improvement can be expected., and 4o-mini is a time and cost effective alternative.

Recent advancements in LLMs have spurred their application in fault diagnosis across a range of complex systems. These models are being explored not only for their fault detection capabilities but also for their ability to provide interpretability, adaptability, and generalization in data-driven diagnostics. Several works have proposed hybrid frameworks that integrate LLMs with traditional diagnosis tools to improve explainability and operator support. For instance, the authors of [3] combine a physics-based diagnostic tool with an LLM to enhance fault interpretability in nuclear power plants, demonstrating improved transparency and operator interaction through natural language explanations. In software engineering, AutoFL [6] employs LLMs for fault localization, enhancing developer trust by providing rationales for fault hypotheses and navigating large code-bases using prompt engineering. Similarly, LLMAO [21] introduces a fine-tuned LLM architecture capable of fault localization at a line level without relying on test coverage data, surpassing traditional ML-based methods. From an industrial systems perspective, various methods have been proposed to adapt LLMs to multi-modal and time-series data. FD-LLM [11] aligns LLMs with engineering data using modal alignment and prompt learning to handle overlapping features in complex equipment diagnostics. FaultExplainer [7] uses LLMs to generate plausible and actionable explanations, but also highlights its limitations, including reliance on PCA-selected features and some hallucinations. In cyber-physical systems, FLEX [13] and FaultLines [14] demonstrate how open-source LLMs can perform anomaly and fault detection using retrieval-augmented generation and prompt engineering. These works reveal that model performance is closely tied to prompt design and textual encoding strategies.

LLMs also show promise in handling challenges such as cross-domain generalization and data scarcity. The authors of [19] present an LLM-based framework for bearing fault diagnosis that combines textual representation of sensor data with fine-tuning strategies to achieve superior performance across different datasets and operational conditions. The AAD-LLM framework [17] further extends this adaptability by enabling multi-modal, zero-shot anomaly detection in manufacturing systems, using pre-trained LLMs without requiring retraining or finetuning. They also propose a very interesting state of the art on LLMs use for Time Series forecasting. Overall, the field is evolving toward more robust, interpretable, and adaptive diagnostic solutions leveraging LLMs. However, none of these works really links LLM results to concepts developed in the field of model-based diagnostics. This is the major contribution of our article.

This article is organized as follows: Section 2 recalls some important concepts for diagnosis. Section 4 briefly details previous work. Section 5 presents our two main contributions. The road approach for creating MSOs from piping and instrumentation diagrams, and a Dedicated Approach for arithmetic and logic circuits. Finally, Section 6 presents our empirical evaluation. At the end of the article we discuss our results and present some future research directions.

Figure 1 illustrates our methodology. Input to the methodology are P&ID diagrams and circuit diagrams, i.e. a common form of engineering documentation for use-cases in the process industry and hardware design. Block 1 “Model Generation” has been described in [12]. It generates a set of equations that can be used by the Fault Diagnosis Toolbox to obtain MSO sets. Section 4 briefly recalls the model generation process.

For our solution in this article, we used two independent prompting approaches:

1. 1.

   A Broad Approach (in green box), able to handle continuous systems described by the differential equations that generates MSO sets from a set of differential equations

2. 2.

   A Dedicated Approach to arithmetic and logic circuits (in orange box) that generates MSO sets, conflicts, and finally obtains diagnoses for the considered system.

Blocks 2 and 3 are used for the Broad Approach, described in Section 5.2. Blocks 4, 5, and 6 are used for the Dedicated Approach to arithmetic and logic circuits, described in Section 5.1. Each block uses an LLM for its reasoning.

In the case of arithmetic and logic circuits, checking the consistency of observations with the model is straightforward and leads to unambiguous answers. In the case of continuous, dynamical systems, in the presence of noise and dynamical fault profiles residual evaluation is more challenging. Therefore, for circuits, we perform all the steps that result in diagnoses (Blocks 4 to 6), and in the Broad Approach we only generate MSO sets (Blocks 2 and 3).

A system model $ℳ(z,x,f)$ typically comprises both unknown variables, denoted by $x$, and known variables $z$, which are measured using sensors.

The variables $x$ are partitioned into two categories: differential variables $x_1$ and algebraic variables $x_2$. Faults affecting the system are explicitly represented by a dedicated vector of parameters $f$. We denote the sets of known variables, unknown variables, and faults by $𝒵$, $𝒳$, and $ℱ$, respectively.

A commonly used representation, known as a semi-explicit Differential Algebraic system of Equations (semi-explicit DAE), for general systems in the continuous-time domain is as follows:

Here, $x_1(t)\in {ℝ}^{n_{x_1}}$ and $x_2(t)\in {ℝ}^{n_{x_2}}$ denote the vectors of unknown variables. The vectors $z_s(t)\in {ℝ}^{n_{z_s}}$ and $z_c(t)\in {ℝ}^{n_{z_c}}$ represent the measured outputs and controlled inputs, respectively, both considered known. In systems without external actuation, $z_c(t)$ may be zero.

The functions $h$, $l$, and $g$ can be linear or nonlinear and typically depend on a set of system parameters, denoted by ${𝒵}_p$ (e.g., tank diameter, nominal flow rate, etc.).

Interestingly, dynamic systems (represented by differential equations) and static systems (represented by algebraic equations) are sub-classes of DAEs.

For any vector $\nu$, we define $\overline{\nu }$ as the augmented vector comprising $\nu$ and its time derivatives up to a certain (unspecified) order.

${ℳ}^{\prime }(\overline{z})$ defines a set of ARRs. A single ARR takes the form $ar{r}_i({\overline{z}}^{\prime })=r_i$, where $r_i$ is a scalar signal named residual and ${\overline{z}}^{\prime }$ a subvector of $\overline{z}$. It can be used as residual generator.

In simple terms, a residual generator produces a signal called a residual, which ideally remains zero when the system operates correctly. Any deviation from zero may indicate the presence of a fault.

From the system model, it is possible to derive Analytical Redundancy Relations (ARRs) by exploiting the inherent analytical redundancy. This is typically achieved through variable elimination techniques, resulting in relations that involve only the known variables. ARRs serve as the foundation for diagnosis tests, enabling the verification of whether the measurements $z$ are consistent with the system model $ℳ(z,x,f)$. If a fault is present in the system, it is expected to affect some of the measurements, and consequently, the residuals. If no such influence is observable, the fault is said to be non-detectable, and as such, it cannot be identified [9].

Building on the foundational work by Cassar and Staroswiecki [1], and Travé-Massuyès et al. [20], structural analysis has emerged as a powerful tool for deriving ARRs. This method abstracts the system model by focusing solely on the structural relationships between equations and variables, disregarding the specific functional forms. One of the key advantages of structural analysis is its applicability to large-scale systems, whether linear or nonlinear, and even in the presence of model uncertainty. Along the structural approach, the structure of a system $ℳ(z,x,f)$, or structural system, can be represented by a biadjacency matrix crossing variables and equations, named the Incidence Matrix.

When applied to fault diagnosis, structural analysis helps identify subsets of equations that exhibit redundancy. The structural redundancy ${\rho }_{{ℳ}^{\prime }}$ of a set of equations ${ℳ}^{\prime }\subseteq ℳ$ is defined as the difference between the number of equations and the number of unknown variables within that subset.

Of particular diagnostic relevance are the Proper Structurally Overdetermined (PSO) sets, which are sets of equations that together contain just enough redundancy to allow fault detection through consistency checks.

A just determined part refers to a set of equations where the number of equations matches the number of unknown variables, allowing for a unique solution. In contrast, an underdetermined part has fewer equations than unknowns, making it impossible to uniquely determine the values of all variables.

Another interesting concept are the minimal subsets of equations $\psi \subseteq ℳ(z,x,f)$ that possess exactly one degree of structural redundancy, i.e., ${\rho }_{\psi }=1$. Such subsets are referred to as Minimal Structurally Overdetermined (MSO) sets.

Certain MSO sets have been shown to support the formulation of diagnostic tests [9], making them essential components for residual generation and fault detection. These particular subsets are called Fault-Driven Minimal Structurally Overdetermined (FMSO) sets [15].

Let ${ℱ}_{\phi }$ denote the set of faults involved in a given subset of equations $\phi \subseteq ℳ(z,x,f)$, then FMSO sets can be defined as follows.

Given an FMSO set $\phi$, ${ℱ}_{\phi }$ is defined as the fault support of $\phi$ and the physical components modeled by the equations in $\phi$ define its component support $COM{P}_{\phi }$.

In most cases, FMSO sets can be transformed into Analytical Redundancy Relations (ARRs) through sequential elimination. Due to their structural properties, all unknown variables appearing in an FMSO set $\phi$ can be algebraically resolved using $|\phi |-1$ equations. These expressions can then be substituted into the remaining $|\phi |$-th equation, yielding an ARR formulated off-line. This ARR is subsequently employed on-line as a diagnostic test.

Building upon the findings in [2], which establish a connection between model-based approaches from the control community (FDI) and those from the artificial intelligence community (DX), the concept of an R-conflict, originally introduced by Reiter [16], can be related to FMSO sets under the assumption of Model Representation Equivalence.

An R-conflict indicates that at least one component within the R-conflict must be faulty to explain the observed behavior; equivalently, it is not possible for all components in the R-conflict to be functioning normally. Interestingly, the set of minimal diagnoses can be generated from the set of minimal R-conflicts.

Figure 2 illustrates the different concepts that have been introduced on the well-known polybox example.

The notion of FMSO set also plays a pivotal role in the formal definitions of structural detectable and structural isolable faults. In the following, we revisit these fundamental definitions as presented in [9].

The Fault Diagnosis Toolbox (FDT) [5] is a software framework designed for the analysis and synthesis of fault diagnosis in systems that are typically modeled with differential-algebraic equations. By leveraging a structural representation of the system, the toolbox enables the automatic extraction of FMSO sets. From these sets, it allows one to generate Analytical Redundancy Relations (ARRs), which can subsequently be used as diagnosis tests.

Previous work [12] proposes an approach to create mathematical models for process industry systems using multi-modal large language models (MLLM). It presents a five-step prompting approach that uses a piping and instrumentation diagram (P&ID) and natural language prompts as its input. For clarity, we will briefly sketch the previous approach in this section.

The five steps of the prompting approach are the following:

1. 1.

   Read Diagram – Let the MLLM read the diagram image data and represent it in some partially specified intermediate format. Partial specification is performed in the prompt.

2. 2.

   Identify Sensors – The LLM creates a table containing existing sensors, their type, and their placement from the input diagram and from the output from step 1 in the form of $CompsConnections$. Context about P&IDs, possibly occurring sensors, and the placement of the sensors in the diagram are provided in the system message.

3. 3.

   Create the mathematical Equations – The mathematical equations are created by the LLM using provided variable names and assumptions.

4. 4.

   Sensor Matching and Variable Assignment – In this step, all the results from the previous steps are merged, the faults are added to the equations and the resulting mathematical model $ℳ$ is created.

5. 5.

   Format Model for Fault Diagnosis Toolbox – In the final step, the mathematical model $ℳ$ is transformed to be suitable for the FDT into $\widetilde{ℳ}$.

All steps provide the MLLM with the P&ID as input. In addition, the steps take a system message and a user prompt as input. The system message contains the generic task for the respective step. However, taking current abilities of MLLMs into account, it is still domain dependent. The user message contains a subset of the external information ${ℐ}^{\prime }\subset ℐ$ which is specific for the system, where $ℐ$ is denotes all available external information. The prompts can be found on GitHub⁵⁵5https://github.com/silkeme/DX24_Model_Creation_LLMs
The repository contains the prompts, all mentioned information about the systems used for the evaluation, the resulting mathematical models, and all intermediate outputs.. The approach aims to work for water tank systems with standard components, such as tanks, pumps, valves, flow indicators, and level indicators.

As described before, for our solution in this article, we use two independent prompting approaches:

1. 1.

   Dedicated approach – designed to handle arithmetic and logic circuits,

2. 2.

   Broad approach – able to handle continuous systems described by differential equations.

While the Dedicated Approach outputs proper diagnoses, the Broad Approach outputs the more general FMSO sets from which diagnoses can be computed using actual observations and tools such as the Fault Diagnosis Toolbox.

All approaches were evaluated through OpenAI API. We evaluated the following models: gpt-4o-mini-2024-07-18 (referred in the following as 4o-mini), o3-mini-2025-01-31 (referred in the following as o3-mini), and o1-2024-12-17 (referred in the following as o1). 4o-mini was evaluated with the access to the code interpreter, therefore the model could write Python code and run it to generate the answer⁸⁸8We tried gpt-4o and gpt-4o-mini but the accuracy was close to zero on unseen examples. Performance of gpt-4o and gpt-4o-mini with code interpreter was similar in initial experiments, so we decided to evaluate full set of examples on gpt-4o-mini because of costs.. o1 and o3-mini are reasoning models⁹⁹9https://openai.com/index/learning-to-reason-with-llms/, trained with reinforcement learning to perform complex reasoning, and performing all computations in internal chain of thought. Note that we cannot tell for sure that these models did not use a code interpreter in the background as well.

Experiments were performed with temperature 0 and top_p = 0 for 4o-mini. The reasoning effort for o1 and o3-mini was ’high’ for the Dedicated Approach and ’medium’ for the Broad Approach. Tests were repeated 10 times for each test case (test case including example description and the set of observations) for 4o-mini and o3-mini. Tests for o1 were performed only once, because of costs¹⁰¹⁰10One iteration costed around 30$.

Each LLM reasoning step was evaluated independently, i.e. for each blue box in Figure 1 we provided correct inputs, irrespective of the result of the previous step. That way, we can evaluate the accuracy of each algorithm step reliably.

We carried out tests on 23 arithmetic and logic circuits with different levels of complexity (Figure 5). The circuits contain adders, multipliers, and AND, OR, NOR, NAND, and XOR gates. Table 4 summarizes examples’ characteristics¹¹¹¹11You can find image for each example here https://github.com/jadlownik/FaultDiagnosis/tree/develop/images and descriptions here https://github.com/asztyber/LLM_diagnostic_concepts/tree/main/examples. The number of minimal conflicts and diagnoses can vary for a given example depending on the observations¹²¹²12The results contain readable Excel files containing generated and correct MSOs, conflicts and diagnoses.. For each example, we assumed all inputs and outputs are measured. We only considered components faults. Sensor faults and sensor equations were omitted.

As shown in Figure 6, we evaluate the models’ performance using complementary metrics that capture different aspects of accuracy in incidence matrix generation. For each equation, precision measures how many of the model’s predicted variables are correct, while recall measures how many of the correct variables the model identified. The F1 score combines these into a single metric, penalizing both missing and spurious variables. The accuracy metric is the strictest, requiring perfect variable sets for each equation.

4o-mini often includes known variables and faults as variables involved in incidence matrix, resulting in the poor scores.

Ground truth for incidence matrices, MSO sets, and residual evaluation was computed using Fault Diagnosis Toolbox [5]. Correct minimal diagnoses were computed with the implementation of minimal hitting sets algorithm.

The evaluation metrics (Precision, Recall, and F1 score) were computed by comparing the generated MSO sets with the ground truth MSO sets. Precision measures the fraction of correctly identified MSO sets among all generated sets ($\frac{TP}{TP+FP}$), while Recall indicates the fraction of ground truth MSO sets that were successfully found ($\frac{TP}{TP+FN}$)¹³¹³13In the case where the number of ground truth solutions is zero ($P=0$), and the generated solution is also empty ($FP=0$) we set Precision and Recall to 1, to avoid penalizing correct answers for the empty solutions.. The F1 score is the harmonic mean of Precision and Recall ($2\cdot \frac{Precision\cdot Recall}{Precision+Recall}$). The metrics for conflicts and diagnoses were computed in an analogous way.

The Figures 8, 10, and 12 show F1 scores for different model versions (4o-mini, o1, and o3-mini). Each data point represents the mean F1 score for examples with the same number of solutions (MSOs, conflicts, or diagnoses), with error bars indicating the standard deviation across these examples. The dashed lines show the linear trend of performance as the number of solutions increases. The Figures 7, 9, and 11 show F1 scores sorted by the number of relations in the example.

The bar plots (Figures 13, 14, 15) show the aggregated performance metrics (F1 score, Precision, and Recall) for each model (4o-mini, o1, and o3-mini) across all test examples. Each bar represents the mean value of the corresponding metric, with error bars indicating the standard deviation.

An analysis of the obtained results leads to the following conclusions.

For incidence matrix generation (Figure 6), we can observe that o1 and o3-mini achieve perfect accuracy. 4o-mini tends to include additional variables (not in $X$ but correctly assigned to the equations); otherwise, the results are correct. Incidence matrix generation is the simplest algorithmic task.

For MSO generation (Figure 7), 4o-mini has problems with examples containing only one relation. Otherwise, the performance is relatively stable with an increasing number of examples. 4o-mini has access to a code interpreter, making handling different input sizes easier. The performance of o1 and o3-mini decreases with the number of relations in the example. We can observe similar tendencies depending on the number of MSOs to be generated (Figure 8). Plots on Figure 7 and Figure 8 show results aggregated over two prompting approaches (Dedicated and Broad). Figure 13 compares the performance of different models and prompting approaches. The performance of the Dedicated and Broad Approach is similar despite much more domain knowledge included in the dedicated prompts. Additionally, the Broad Approach includes a correct incidence matrix as an input for MSO generation, but it does not influence the results significantly. o1 shows the best performance across all metrics, while 4o-mini is the worst despite the access to the code interpreter.

Performance in conflict generation, depending on the number of relations and conflicts, is presented respectively in Figure 9 and Figure 10. Trend lines show increasing performance with increasing complexity, but this is caused by poor performance when the number of conflicts is zero (i.e. there are no inconsistencies in the system description and observation). o1 performs best for conflict generation (Figure 14).

Diagnoses generation is the most computation-heavy task. We observe a clear decrease in the performance with increasing complexity (Figure 11 and Figure 12). o3-mini performs best for diagnoses generation (Figure 15).

As LLMs were not primarily designed to handle algorithmic and computational tasks, the performance of reasoning models is surprisingly good. o3-mini achieves $F1=0.917\pm 0.249$ on conflicts generation and $F1=0.784\pm 0.322$ on diagnoses generation. The examples were generated manually and were unavailable in the training data (correct solutions were released after the tested models’ release).

This paper explores the use of large language models (LLMs) as a novel tool for performing structural analysis in model-based diagnosis (MBD), specifically focusing on the automatic generation of Minimal Structurally Overdetermined (MSO) sets, from which diagnosis tests can be obtained, from engineering documentation. The generation of conflicts and diagnoses is also explored. The authors evaluate the performance of various OpenAI LLMs (including o1, o3-mini, and 4o-mini) by comparing their generated MSOs, conflicts, and diagnoses against those produced by traditional tools. The paper situates its contribution within a growing body of work on LLM-based fault diagnosis but emphasizes its unique connection to foundational MBD concepts. An empirical evaluation highlights both the potential and limitations of LLMs in structured engineering tasks, offering insights into their applicability and future integration into hybrid diagnostic frameworks.

The main goal of this work is to evaluate LLM capabilities in the context of MBD fault diagnosis. While we find some results surprisingly good, at this point, LLMs do not provide an alternative to diagnosis algorithms. The current level of accuracy is not sufficient to replace traditional tools. Additionally, as the results are obtained by API calls, the time to achieve the results depends on the network load and other factors and cannot be bounded robustly. Another practical consideration is the cost. Lastly, it can be observed that the quality of the results vary highly in different runs.

Several avenues can be explored to extend this work. First, broader benchmarking on more diverse and complex systems, including hybrid systems or distributed systems, would help assess the generalization capabilities and scalability of LLMs in diagnostic tasks. Another promising direction involves fine-tuning or instruction-tuning language models on domain-specific corpora to improve their performance. Additionally, integrating multi-modal inputs – such as P&ID diagrams, circuit schematics, or CAD models – via vision-language models may allow more intuitive and direct processing of engineering data.

Furthermore, future work could explore the use of the recent Model Context Protocol (MCP) in diagnostic frameworks involving distributed architectures. MCP provides a structured way to manage model contexts and execution flows across different computational components. By integrating MCP with language models, it becomes possible to coordinate diagnostic reasoning over a set of specialized servers, each responsible for distinct functionalities – such as structural analysis, variable elimination, or diagnosis generation from conflicts. This would enable a modular and scalable diagnostic pipeline, where LLMs interact with context-aware services rather than operating as monolithic agents. On the other hand, this modular structure is particularly well suited for diagnosis in distributed systems, where different subsystems may operate independently, expose only partial observability, or follow different modeling paradigms. MCP can enable seamless orchestration of context-aware services across these subsystems, allowing LLMs to query relevant components dynamically and integrate partial diagnosis results into a coherent global view. Such an approach enhances scalability, reusability, and flexibility in large-scale or heterogeneous diagnosis environments, while also opening new opportunities for intelligent fault management across distributed infrastructures.