SysML activity diagram verification method and system based on big language model collaborative intelligent agent

Abstract

The invention discloses a SysML activity diagram verification method and system based on a big language model collaborative intelligent agent, and belongs to the technical field of formal verification. The method comprises the following steps: extracting a structured description of a SysML activity diagram; performing semantic analysis on the natural language constraint and the structured description based on a large language model, and generating a semantic framework and a PlantUML code according to a semantic analysis result; the PlantUML code is provided for a large language model, and a PRISM model is generated; providing the SysML activity diagram and the semantic framework for a large language model, and generating a PCTL rule; and verifying the PRISM model according to a PCTL rule to obtain a verification result of the SysML activity diagram. According to the method, efficient, accurate and explainable automatic verification of the SysML activity diagram can be realized.

Description

Technical Field

[0001] This invention belongs to the field of formal verification technology, specifically relating to a SysML activity graph verification method and system based on a large language model collaborative intelligent agent. Background Technology

[0002] SysML Activity Diagrams are diagrams used in the System Modeling Language (SysML) to describe system behavior, workflows, or operational processes. They contain elements such as action nodes, control flow, object flow, decision nodes, and concurrent branches, and are a core tool for modeling the behavior of complex systems. With the increasing complexity of systems in fields such as aerospace and automotive electronics, SysML Activity Diagrams have become a core tool for behavioral modeling, but their verification process faces significant challenges. Formal verification of SysML Activity Diagrams uses mathematical methods (such as model checking and theorem proving) to rigorously prove the properties of the system model (such as deadlock-free operation, safety, and liveness), ensuring its compliance with specifications.

[0003] Traditional formal verification methods heavily rely on experts manually converting natural language requirements into formal rules (such as PCTL formulas), resulting in inefficiency, high technical barriers, and fragmented toolchains. In recent years, breakthroughs in Large Language Model (LLM) technology have provided new avenues for automating this conversion process. However, existing research in the specific domain of SysML activity graphs still suffers from shortcomings such as imprecise semantic parsing, insufficient capacity for handling complex logic, a black-box verification process, and poor integration with modeling tools.

[0004] Specifically, SysML, as the standard modeling language in systems engineering, supports the entire lifecycle modeling of systems, from requirements analysis to verification, through nine graphical methods, including activity diagrams. However, SysML is essentially a semi-formal language, and the natural language descriptions and probabilistic features contained in its activity diagrams are difficult to directly perform precise formal analysis and verification. Although existing methods attempt to verify through model transformation (such as converting to PRISM or time automata models), they still face challenges such as state explosion and insufficient coverage when dealing with concurrent structures, probabilistic branches, and the consistency verification between requirements and models. Although some studies have proposed converting natural language requirements into temporal logic formulas such as LTL or CTL, this process still relies on manual intervention and has poor universality.

[0005] The emergence of large language models (LLMs) has brought hope for improving the automation level of formal transformation of requirements, as they can understand natural language and generate code or logical formulas. However, directly applying LLMs to SysML activity graph verification still has significant problems: LLMs lack sufficient understanding of SysML-specific semantics (such as extended flow ports, probabilistic branches, and concurrent thread synchronization mechanisms), resulting in semantic biases in the generated PCTL formulas or PRISM code; for activity graphs containing complex logic (such as nested loops and multi-branch concurrency), LLMs struggle to guarantee the structural correctness and completeness of the generated rules; furthermore, the current lack of effective verification and feedback mechanisms makes the verification process like a black box, making it difficult to trace and correct errors; most studies have failed to deeply integrate with mainstream MBSE tools such as Cameo SystemsModeler, resulting in a broken flow from model export and transformation to result feedback, failing to form a closed loop. Summary of the Invention

[0006] This invention discloses a SysML activity graph verification method and system based on a large language model collaborative intelligent agent. By innovatively integrating a multi-agent collaborative architecture, a step-by-step rule generation strategy, and a structured intermediate representation and iterative feedback mechanism, it achieves efficient, accurate, and interpretable automated verification of SysML activity graphs.

[0007] To achieve the above objectives, the technical solution of the present invention includes the following:

[0008] A SysML activity graph verification method based on a large language model collaborative intelligent agent, the method comprising: Extract a structured description of the SysML activity graph; Semantic parsing of natural language constraints and the structured description is performed based on a large language model, and the semantic parsing results are used to generate a semantic framework and PlantUML code. The PlantUML code is provided to the large language model to generate the PRISM model. Provide SysML activity graphs and semantic frameworks to a large language model to generate PCTL rules; The PRISM model was validated according to the PCTL rules, and the validation results of the SysML activity graph were obtained.

[0009] Furthermore, semantic parsing is performed on the natural language constraints and the structured description based on the large language model, and the semantic parsing results are used to generate a semantic framework and PlantUML code, including: Natural language constraints are matched with templates of a large language model, and the natural language constraints are embedded after the matched templates. The semantic information of the natural language constraints is then obtained based on the recognition of the large language model. Transform semantic information constrained by natural language into a semantic framework; Based on structured description, key nodes and their attributes are identified in the SysML activity graph to obtain semantic information of the SysML activity graph; wherein, the key nodes include action nodes, decision nodes, control flow, and probabilistic branches; Based on the semantic framework, PlantUML code is generated according to the semantic information of the SysML activity graph.

[0010] Furthermore, the PlantUML code is provided to the large language model to generate the PRISM model, including: Based on the mapping rule base, SysML elements contained in PlantUML code are converted into PRISM syntax components; wherein, the mapping rule base includes: state mapping, transition mapping, and concurrency processing; wherein, the state mapping is used to map action nodes to PRISM state variables and define the value range of the PRISM state variables, the transition mapping includes converting control flow into PRISM commands and converting probabilistic branches into probabilistic transition commands, and the concurrency processing is used to map Fork / Join nodes to PRISM parallel process modules and coordinate the execution order between different process modules through synchronization tags; Based on the PRISM syntactic components and the system behaviors contained in the SysML activity graph, PRISM model code is generated; wherein, the system behaviors include: loops and conditional statements.

[0011] Furthermore, when the SysML activity graph contains probabilistic behavior, the process of generating PRISM model code also includes: Extract probability values ​​from probability decision nodes; Fill the probability into the probability transfer command.

[0012] Furthermore, the SysML activity graph and semantic framework are provided to the large language model to generate PCTL rules, including: Extract logical patterns from the semantic framework, and generate a PCTL formula framework containing only logical operators and placeholders based on the constraint types in the semantic framework. Parameters are extracted from the SysML activity graph and semantic framework, and then populated into the PCTL formula framework to obtain PCTL rules.

[0013] Furthermore, after filling this parameter into the PCTL formula framework to obtain the PCTL rules, it also includes: Perform logical completeness checks on PCTL rules; If the PCTL rule fails the logical completeness check, the process of extracting the logical pattern from the semantic framework will be re-executed based on the error types generated during the logical completeness check, until the PCTL rule passes the logical completeness check.

[0014] Furthermore, the PRISM model was validated according to PCTL rules, and the validation results of the SysML activity graph were obtained, including: The PCTL rules and the PRISM model are fed into the PRISM model checker, which performs probabilistic model detection to obtain the verification result of the SysML activity graph; wherein, the probabilistic model detection process includes: Convert the PRISM model into an internal representation; Convert PCTL rules into computational tasks; Construct a linear equation based on the internal representation and computational task; The linear equation is solved using an iterative algorithm, and the probability model detection result is obtained based on the solution result; wherein, the iterative algorithm includes: Jacobi algorithm and Gauss-Seidel algorithm.

[0015] Furthermore, after validating the PRISM model according to PCTL rules and obtaining the validation results of the SysML activity graph, the following steps are also included: The validation results of the SysML activity graph are compared with the expected results, and the comparison results are displayed on the front-end interface.

[0016] A SysML activity graph verification system based on a large language model collaborative intelligent agent, the system comprising: The preprocessing module is used to extract a structured description of the SysML activity graph; A semantic parsing agent is used to perform semantic parsing on natural language constraints and the structured description based on a large language model, and to generate a semantic framework and PlantUML code from the semantic parsing results; The model transformation agent is used to provide the PlantUML code to the large language model to generate the PRISM model. A rule-generating agent is used to provide SysML activity graphs and semantic frameworks to a large language model to generate PCTL rules. The validation module is used to validate the PRISM model according to PCTL rules and obtain the validation result of the SysML activity graph.

[0017] Furthermore, the system also includes: The results parsing module is used to compare the verification results of the SysML activity diagram with the expected results and display the comparison results on the front-end interface.

[0018] Compared with the prior art, the present invention has at least the following beneficial effects.

[0019] 1) Multi-agent collaborative SysML semantic parsing and rule generation architecture: By dividing tasks among multiple agents and having them specialize in specific areas, the accuracy of understanding complex semantics in SysML activity graphs and the accuracy of PCTL rule generation are significantly improved. The collaborative mechanism among agents effectively avoids single points of failure and enhances the system's robustness when handling mixed constraints.

[0020] 2) Step-by-step PCTL generation strategy: The step-by-step generation strategy of "logic first, details later" greatly reduces the cognitive load of LLM when performing complex logical reasoning, effectively solves the structural error problem of PCTL formulas (such as operator errors and improper nesting), and ensures the executability and logical completeness of the generation rules.

[0021] 3) Structured intermediate representation: The PCTL skeleton and PRISM code serve as intermediate representations, making each step of the verification process inspectable and traceable. The feedback and repair mechanism can quickly locate and correct errors (such as PRISM syntax errors and model conversion deviations), greatly improving development and debugging efficiency and the overall reliability of the system, breaking the black box dilemma.

[0022] 4) A full-stack integrated platform with front-end and back-end separation: It provides a one-stop solution from model input and constraint description to visualization of verification results, greatly reducing the barrier to entry for formal verification. Its excellent integration with the MBSE toolchain allows it to be seamlessly integrated into existing systems engineering processes, giving it high engineering application value. Attached Figure Description

[0023] Figure 1 A flowchart of an automated verification method for SysML activity graphs based on a large language model-based collaborative intelligent agent.

[0024] Figure 2 The JSON structure of the probabilistic decision node.

[0025] Figure 3 Example diagram of semantic parsing prompt words. Detailed Implementation

[0026] To further illustrate the technical solutions of the present invention, the present invention will be described in further detail below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0027] To address the challenges faced by traditional single-model transformation methods in processing complex SysML models, such as semantic information loss, accumulated rule generation errors, and unreliable verification results, this invention constructs a multi-agent collaborative framework. Through the division of labor and cooperation among three specialized agents (semantic parsing agent, model transformation agent, and rule generation agent) and preprocessing, verification, and result parsing modules, it achieves accurate transformation from natural language requirements to formal verification throughout the entire process. The agent organization in this architecture adopts a hierarchical collaborative design, with each agent undertaking specialized responsibilities.

[0028] Specifically, the overall technical solution of the present invention is as follows: Figure 1 As shown, the system adopts a front-end and back-end separation design, and completes the entire process from natural language constraint input to visual verification result output through multi-agent collaboration.

[0029] I. Preprocessing Module.

[0030] The preprocessing module is mainly responsible for obtaining natural language constraints and SysML activity graphs, as well as preprocessing natural language constraints and generating structured descriptions of SysML activity graphs.

[0031] (1) Obtain natural language constraints and SysML activity graphs.

[0032] Users input natural language constraints (such as "charging success rate is not less than 95%) and SysML activity diagrams through the Vue front-end interface. The input data is received and temporarily stored through the Node.js back-end service.

[0033] (2) Preprocessing natural language constraints.

[0034] Clean and standardize natural language constraints, remove ambiguous expressions, and unify terminology (e.g., map "success rate" to "probability", and "not less than" to "≥").

[0035] (3) Obtain a structured description of the SysML activity graph.

[0036] SysML activity graph elements (action nodes, decision nodes, control flow, probabilistic branches, etc.) are mapped to a standardized JSON format. The mapping rules include: 1) Node type: Identified by the nodeType field (e.g., "probabilisticDecision" indicates a probabilistic decision node); 2) Probability Branching: The outgoingFlows array is used to describe the branch objectives and probability values; 3) Control flow: Define the connection between nodes using sourceId and targetId.

[0037] in, Figure 2 This is the JSON structure for probabilistic decision nodes.

[0038] II. Semantic parsing intelligent agents.

[0039] The semantic parsing agent receives natural language constraints and activity graph structure information. Employing few-shot learning techniques, it identifies constraint types (probability / time / concurrency) using predefined prompt templates. The agent resolves complex constraints through chain of thought reasoning, transforming the semantics into PlantUML code. Finally, the Node.js backend calls the PlantUML API via an HTTP POST request, passing in the generated code. The API returns SVG / PNG format image data, which the frontend then renders and loads the SysML activity image. Figure 3 This is an example diagram of semantic parsing prompts.

[0040] Step 1: Receive the preprocessed natural language constraints and the structured description of the SysML activity graph.

[0041] The second step involves constraint type identification and template matching based on few-shot learning, as well as generating a semantic framework for natural language constraints.

[0042] The semantic parsing agent internally maintains a rich library of PlantUML code generation hint templates, which pre-define parsing paradigms for different constraint types (such as probability, time, concurrency, etc.). It employs few-shot learning techniques to quickly match preprocessed natural language constraints with the template library, identifying the corresponding PlantUML code generation hint template for the constraint type (probability, time, concurrency, etc.). The constraint types in the hint template library include: probability constraint template: [System] should [operator] [value] under [condition]; time constraint template: [System] should complete [action] within [time], etc.

[0043] Subsequently, the present invention embeds natural language constraints into the corresponding prompt templates and obtains the semantic information of the natural language constraints based on a large language model.

[0044] Finally, the semantic information of the natural language constraint is converted into a semantic framework. In one example, this invention can accurately extract key elements from informal constraints such as "the system should complete initialization within 5 seconds with a success rate of no less than 99.9%" and convert them into a standardized semantic framework representation. Step 3: Based on the structured description, identify the key nodes of the SysML activity graph and the attributes of the key nodes to obtain the semantic information of the SysML activity graph.

[0045] The large language model semantically decomposes the structured description of SysML activity graphs. Specifically, it identifies key nodes (action nodes, decision nodes, control flow, and probabilistic branches, etc.) and their attributes (such as guard conditions and probability values). For example, for probability requirements, it actively scans the JSON description, locates the probabilistic decision node in the graph (nodeType is "probabilisticDecision"), and precisely extracts the probability values ​​of each branch from its outgoingFlows array, comparing and associating them with numerical values ​​in natural language.

[0046] Step 4: Based on the semantic framework, generate PlantUML code according to the semantic information of the SysML activity graph.

[0047] During the generation process, the AI ​​performs self-verification, reviewing the parsing process through thought chain reasoning to ensure that the generated semantic framework is logically consistent with the original requirements.

[0048] III. Model-to-Intelligent Agent.

[0049] The model transformation agent is responsible for generating complete PRISM model code. This agent possesses a mapping rule base from PlantUML code to PRISM, capable of mapping nodes in the activity graph to PRISM states and transition probabilities to PRISM probability commands. Notably, this agent can correctly generate synchronization mechanisms between process modules when handling concurrent systems. Its thought process emphasizes structural mapping and adherence to syntax rules. Step 1: Structured mapping of model elements The agent systematically converts SysML elements into PRISM syntactic components based on a built-in mapping rule library. Its core mapping logic includes: State mapping: Map SysML action nodes (such as initialization, charging) to PRISM state variables (such as state_init, state_charging), and define their value range.

[0050] Transition mapping: For example, control flow → PRISM command: [action] state=s -> state=s', and probability branch → probability transition: [] state=s -> p1: state=s1' + p2: state=s2', and ensure that the sum of probabilities is 1.

[0051] Concurrent processing: Fork / Join nodes are mapped to parallel modules (||) of PRISM, and the execution order between different process modules is coordinated by synchronization tags (such as act).

[0052] Step 2: Integrating probabilistic logic with system behavior.

[0053] For systems involving probabilistic behavior, the agent extracts probability values ​​from probabilistic decision nodes and accurately populates them into the PRISM probability transition commands. Simultaneously, it needs to handle complex system behaviors, such as loops and conditional statements, to ensure that the generated PRISM model is behaviorally equivalent to the original SysML activity graph.

[0054] Step 3: Automated validation of model syntax and semantics.

[0055] Check the syntax correctness of the PRISM code (such as the completeness of variable declarations and the normalization of probabilities). If an anomaly is detected (such as the sum of probabilities ≠ 1), automatically trigger the repair mechanism (such as normalization).

[0056] Step 4: Generate an executable formal model.

[0057] Output complete and syntactically correct PRISM model code, which includes module definitions, state variable declarations, transition commands, and attribute labels to be verified. This code can be directly loaded and executed by the PRISM model detector, preparing the computational model for subsequent formal verification.

[0058] IV. Rule-generating intelligent agents.

[0059] PCTL rule generation is a crucial bridge connecting system requirements and formal verification, but directly generating complete PCTL formulas has a low success rate. The step-by-step generation strategy proposed in this invention decouples this complex process into two distinct and interconnected stages, significantly improving generation quality.

[0060] The first stage, logical framework generation, focuses on extracting the logical essence from the requirement description. The rule-generating agent initially ignores specific numerical values ​​and state description details, concentrating on analyzing logical patterns in natural language. For example, for a vague requirement like "the system should complete the operation within a reasonable time in most cases," the agent will identify the probability threshold pattern "(P≥p [F≤t φ])" and generate the abstract framework "P≥probability threshold [F≤time constraint "state description"]". This stage employs a combination of pattern matching and logical reasoning. The agent internally builds a knowledge base containing dozens of PCTL templates, enabling it to quickly match the most suitable logical structure for the current requirement.

[0061] Phase Two: Detailed Filling and Validation. After the logical framework is determined, the agent extracts specific parameter values ​​from the SysML model and requirement description to fill the framework. This process is not a simple text replacement, but intelligent filling based on type checking and range validation. For example, the agent will ensure that the probability parameter p∈[0,1], the time parameter t≥0, and the state description φ must have a corresponding definition in the PRISM model. After filling, the agent will also perform a consistency check to ensure that there is a correspondence between the generated PCTL formula and the SysML model elements.

[0062] Specifically, after receiving the semantic framework, the rule-generating agent focuses on generating Probabilistic Computation Tree Logic (PCTL) formulas that conform to grammatical and semantic specifications. This agent integrates a PCTL formal syntax knowledge base, enabling it to intelligently select applicable logical operators and temporal operators, ensuring that the generated PCTL formulas accurately reflect the original requirements while also meeting the input requirements of the model detector. For example, it converts the semantic framework into a canonical expression such as "P≥0.999 [F≤5 "Initialization successful"]". Its thought process employs a step-by-step generation and logical verification strategy. PCTL rule generation is a crucial bridge connecting system requirements and formal verification, but directly generating complete PCTL formulas has a low success rate. The step-by-step generation strategy proposed in this invention decouples this complex process into two distinct and interconnected stages, significantly improving generation quality.

[0063] The rule-generating agent is based on semantic metadata and employs a step-by-step generation strategy: first, a PCTL logical skeleton is generated, and then specific parameters are filled in. For example, the logical skeleton P≥threshold [F "state"] is generated first, and then specific parameter names P≥0.95 [F "Charging successful"] are added. Finally, logical correctness is ensured through thought chain reasoning to generate the final PCTL formula.

[0064] Step 1: Logic skeleton generation.

[0065] Extract logical patterns from the semantic framework, and generate a PCTL formula framework containing only logical operators and placeholders based on the constraint types in the semantic framework. For example, probability constraint → P≥threshold [F "state"], time constraint → P≥p [F≤t "state"].

[0066] Step 2: Parameter filling and type validation.

[0067] Specific parameters are extracted from the SysML activity graph model and semantic framework and populated into the logical skeleton generated in the previous step. For example: threshold → 0.95 and state_label → state labels already defined in PRISM (such as charging_success). Finally, the validity of the parameters is verified: probability values ​​∈ [0,1], time values ​​≥ 0, and state labels exist in the PRISM model.

[0068] Step 3: Logical completeness and semantic correctness check.

[0069] By using thought chain reasoning to perform a logical completeness check on the complete PCTL formula, we can verify whether it accurately reflects the meaning of the original natural language requirements and ensure the correctness of the logical relationships.

[0070] Step 4: Iterative optimization.

[0071] If PRISM verification returns an error (e.g., state undefined), feedback is sent to the agent to readjust parameters or logical structure. This invention supports the nested generation of complex logic (e.g., multiple condition combinations: P≥0.9 [F (state_A&state_B)]). V. Verification Module. The validation part calls the PRISM model checker, taking the Prism model and the PCTL rules as attribute reduction as input. The backend calls the Python interface to perform probabilistic model detection and obtain the validation results (satisfaction probability, counterexample paths, etc.).

[0072] PRISM performs probabilistic model checks through the following steps: Model parsing: Converting the model described in the PRISM language into an internal representation (such as a matrix).

[0073] Attribute parsing: Converts logical formulas into computational tasks (such as probability and expected value).

[0074] Numerical computation: Solving linear equations using iterative methods (such as Jacobi and Gauss-Seidel).

[0075] It should be noted that, in addition to using PRISM as the verification engine, it can be replaced with other tools that support probabilistic model detection (such as MRMC, Storm, etc.) or tools that support temporal automata verification (such as UPPAAL). As long as the alternative tools support similar model description and attribute reduction languages, the core idea of ​​multi-agent collaborative generation of PCTL and model transformation in this invention remains applicable.

[0076] VI. Result Analysis Module.

[0077] The results parsing compares the PRISM output with the expected results, highlights the output in the front-end interface, and supports exporting all validation results as text. The results parsing specification includes automatically deriving the model's reachability attributes (which states are reachable) and automatically deriving the model's reachability attributes (which states are reachable).

[0078] In summary, each agent in this invention is driven by LLM and implemented through API calls or local deployment. Specifically, the semantic parsing agent uses predefined prompt templates to parse SysML semantic elements (such as Fork / Join and probabilistic branches) in natural language; the rule generation agent employs a step-by-step generation strategy, first generating the PCTL framework and then filling in specific parameters to ensure logical correctness; and the model conversion agent maps SysML elements to PRISM syntax to generate executable model code.

[0079] This invention avoids logical errors in single-step generation through a two-stage generation process: logical skeleton generation and parameter filling. Logical skeleton generation generates PCTL expressions containing only operators and propositional frameworks; parameter filling fills in detailed content based on specific elements of the activity graph (node ​​IDs, probability values).

[0080] To ensure the controllability and correctness of the SysML to PRISM conversion process, this invention designs a two-layer verification system based on structured intermediate representations. Combined with an iterative feedback mechanism, this constructs an intelligent conversion process with self-correcting capabilities. The structured intermediate representation comprises two layers: the PCTL framework as the intermediate representation for rule generation, and the PRISM code as the intermediate representation for model conversion. The PCTL framework employs an Abstract Syntax Tree (AST) structure, clearly expressing the hierarchical structure of PCTL formulas and marking the positions of variables that need to be filled. The PRISM code adheres to strict syntax specifications, with each module, variable, and command having a clearly defined structural template. Both representations possess good machine readability, providing a foundation for automated verification.

[0081] Although specific embodiments of the invention have been disclosed for illustrative purposes to aid in understanding and implementing the invention, those skilled in the art will understand that various substitutions, variations, and modifications are possible without departing from the spirit and scope of the invention and the appended claims. Therefore, the invention should not be limited to the content disclosed in the preferred embodiments, and the scope of protection claimed by the invention is defined by the claims.

Claims

1. A SysML activity graph verification method based on a large language model collaborative intelligent agent, characterized in that, The method includes: Extract a structured description of the SysML activity graph; Semantic parsing of natural language constraints and the structured description is performed based on a large language model, and the semantic parsing results are used to generate a semantic framework and PlantUML code. The PlantUML code is provided to the large language model to generate the PRISM model. Provide SysML activity graphs and semantic frameworks to a large language model to generate PCTL rules; The PRISM model was validated according to the PCTL rules, and the validation results of the SysML activity graph were obtained.

2. The method according to claim 1, characterized in that, Semantic parsing is performed on natural language constraints and the structured description based on a large language model, and the semantic parsing results are used to generate a semantic framework and PlantUML code, including: Natural language constraints are matched with templates of a large language model, and the natural language constraints are embedded after the matched templates. The semantic information of the natural language constraints is then obtained based on the recognition of the large language model. Transform semantic information constrained by natural language into a semantic framework; Based on structured description, key nodes and their attributes are identified in the SysML activity graph to obtain semantic information of the SysML activity graph; wherein, the key nodes include action nodes, decision nodes, control flow, and probabilistic branches; Based on the semantic framework, PlantUML code is generated according to the semantic information of the SysML activity graph.

3. The method according to claim 1, characterized in that, The PlantUML code is provided to the large language model to generate the PRISM model, including: Based on the mapping rule base, SysML elements contained in PlantUML code are converted into PRISM syntax components; wherein, the mapping rule base includes: state mapping, transition mapping, and concurrency processing; wherein, the state mapping is used to map action nodes to PRISM state variables and define the value range of the PRISM state variables, the transition mapping includes converting control flow into PRISM commands and converting probabilistic branches into probabilistic transition commands, and the concurrency processing is used to map Fork / Join nodes to PRISM parallel process modules and coordinate the execution order between different process modules through synchronization tags; Based on the PRISM syntactic components and the system behaviors contained in the SysML activity graph, PRISM model code is generated; wherein, the system behaviors include: loops and conditional statements.

4. The method according to claim 3, characterized in that, When the SysML activity graph contains probabilistic behavior, the process of generating PRISM model code also includes: Extract probability values ​​from probability decision nodes; Fill the probability into the probability transfer command.

5. The method according to claim 1, characterized in that, The SysML activity graph and semantic framework are provided to the large language model to generate PCTL rules, including: Extract logical patterns from the semantic framework, and generate a PCTL formula framework containing only logical operators and placeholders based on the constraint types in the semantic framework. Parameters are extracted from the SysML activity graph and semantic framework, and then populated into the PCTL formula framework to obtain PCTL rules.

6. The method according to claim 5, characterized in that, After filling this parameter into the PCTL formula frame to obtain the PCTL rules, it also includes: Perform logical completeness checks on PCTL rules; If the PCTL rule fails the logical completeness check, the process of extracting the logical pattern from the semantic framework will be re-executed based on the error types generated during the logical completeness check, until the PCTL rule passes the logical completeness check.

7. The method according to claim 1, characterized in that, The PRISM model was validated according to PCTL rules, and the validation results of the SysML activity graph were obtained, including: The PCTL rules and the PRISM model are fed into the PRISM model checker, which performs probabilistic model detection to obtain the verification result of the SysML activity graph; wherein, the probabilistic model detection process includes: Convert the PRISM model into an internal representation; Convert PCTL rules into computational tasks; Construct a linear equation based on the internal representation and computational task; The linear equation is solved using an iterative algorithm, and the probability model detection result is obtained based on the solution result; wherein, the iterative algorithm includes: Jacobi algorithm and Gauss-Seidel algorithm.

8. The method according to any one of claims 1 to 7, characterized in that, After validating the PRISM model according to PCTL rules and obtaining the validation results of the SysML activity graph, the following steps are also included: The validation results of the SysML activity graph are compared with the expected results, and the comparison results are displayed on the front-end interface.

9. A SysML activity graph verification system based on a large language model collaborative intelligent agent, characterized in that, The system includes: The preprocessing module is used to extract a structured description of the SysML activity graph; A semantic parsing agent is used to perform semantic parsing on natural language constraints and the structured description based on a large language model, and to generate a semantic framework and PlantUML code from the semantic parsing results; The model transformation agent is used to provide the PlantUML code to the large language model to generate the PRISM model. A rule-generating agent is used to provide SysML activity graphs and semantic frameworks to a large language model to generate PCTL rules. The validation module is used to validate the PRISM model according to PCTL rules and obtain the validation result of the SysML activity graph.

10. The system according to claim 9, characterized in that, The system also includes: The results parsing module is used to compare the verification results of the SysML activity diagram with the expected results and display the comparison results on the front-end interface.

Images