System-level requirement modeling and analysis method and platform based on LLM

Abstract

The application discloses a kind of system-level demand modeling and analysis method and platform based on LLM, belong to demand engineering and system modeling field.Aiming at the problem that natural language system-level software demand is difficult to accurately model and consistent verification, an automatic demand behavior model construction and conflict detection method driven by LLM is proposed.The method simulates the hierarchical analysis process of experts, recursively analyzes the control flow logic in the demand text, and automatically generates the behavior model.The modeling process includes identifying atomic activities, extracting hierarchical relationships and constructing behavior models.On this basis, based on the precondition and postcondition of the behavior node, a system-level behavior tree is constructed, and multiple demand models are analyzed comprehensively to realize behavior consistency analysis and conflict detection at the system level.The application can realize the automatic expansion from the demand-level behavior model to the system-level behavior model, and provides an effective technical solution for system-level demand automatic modeling and analysis.

Description

Technical Field

[0001] This invention relates to the field of requirements engineering technology, and more specifically to a system-level requirements modeling and analysis method and platform based on LLM. Background Technology

[0002] As software systems become increasingly larger and more complex, modern software requirements specifications are no longer limited to describing single functions or localized behaviors. Instead, they generally exhibit system-level behavioral characteristics involving multiple requirements, stages, and roles working together. In this context, a single requirement document can often only depict the localized behavior of the system in a specific scenario or stage, while the overall system operation needs to be characterized through the collaborative organization and constraint relationships between multiple behavioral models. Therefore, constructing a requirements model that reflects the relationships between multiple behavioral models at the system level has become a crucial foundation for supporting requirements analysis, architecture design, and early verification of complex software systems.

[0003] Requirements models not only need to describe the control logic within a single behavioral model, but also accurately express the preconditions, postconditions, and triggering relationships between multiple behavioral models generated from different requirement texts. This ensures that the system-level behavior as a whole possesses logical consistency, structural integrity, and verifiability. The quality of the requirements model directly affects the correctness of subsequent design decisions, the reliability of system behavior analysis results, and the feasibility of model reuse and evolution during model-driven development. However, requirements models typically have characteristics that span requirements, stages, and logical levels, making their quality assurance issues far more complex than those of a single behavioral model.

[0004] In practice, the construction and maintenance of requirement models mainly rely on domain experts to manually analyze and synthesize multiple requirement texts. This approach is not only costly and inefficient, but also highly dependent on the experience level of the modelers, making it difficult to maintain the consistency and correctness of requirement models in large-scale requirement scenarios or rapid iterative development models. Once there are problems such as missing preconditions, incomplete behavioral dependencies, or logical conflicts between models in the requirement model, it will directly lead to the distortion of system-level behavioral analysis results, and may even cause design flaws to be amplified in subsequent development stages.

[0005] To improve the level of automated modeling, existing technologies have proposed various automatic modeling methods based on natural language requirements. Generally speaking, existing methods mainly fall into three categories: The first category is rule-based or template-based modeling methods, which convert requirement elements into behavioral models through predefined grammatical rules or mapping templates. These methods rely on fixed sentence structures and explicit structural markers, and have limited adaptability to the expressive diversity and implicit semantics of natural language requirement texts, making it difficult to support system-level modeling of complex system requirements. The second category is machine learning-based modeling methods, which train models to learn the mapping relationship between requirement text and model structure. However, these methods are highly dependent on high-quality labeled data, lack generalization ability in cross-domain and cross-system requirement scenarios, and struggle to explicitly guarantee system-level consistency among generated models. The third category is LLM-based automatic modeling methods. These methods have significant advantages in natural language understanding and text generation, and can effectively automate the generation of behavioral models from single requirement texts. However, their applications are mostly concentrated at the single-model generation level, lacking mechanisms for explicit modeling and quality control of the organizational relationships of multiple behavioral models at the system level.

[0006] Specifically, existing LLM-based methods typically generate complete behavioral models directly from requirement texts, lacking a hierarchical decomposition process for complex control flow logic, and also lacking the ability to structure and verify the consistency of multiple behavioral models at the system level. When the number of requirement texts increases or there are implicit dependencies between requirements, existing methods struggle to guarantee that the generated behavioral models do not suffer from issues such as missing preconditions, logical conflicts, or unreachable paths at the system level, leading to uncontrollable overall quality of the requirement models.

[0007] From a cognitive perspective, when performing system-level requirement modeling, human domain experts typically first construct local behavioral models corresponding to each requirement, then systematically organize them based on the preconditions, postconditions, and triggering relationships between behaviors, and repeatedly verify them to ensure the overall consistency and rationality of the system behavior. However, current automatic modeling technologies have not yet formed a technical solution that can simulate the above cognitive process and automatically guarantee the quality of system-level behavioral models.

[0008] Therefore, how to further realize the system-level organization of multiple behavior models on the basis of automatically generating a single behavior model, and effectively ensure the structural consistency and semantic correctness of the requirement model, has become a key technical problem that urgently needs to be solved in the field of software requirements engineering and automated modeling. Summary of the Invention

[0009] Given that existing automated requirement modeling technologies struggle to effectively guarantee the structural relationships and consistency between multiple behavioral models at the system level when dealing with system-level requirement texts, especially when the requirement text contains multi-layered nested conditional branches, loop structures, and parallel processes, the purpose of this invention is to propose a system-level requirement modeling and analysis method and platform based on LLM. This aims to ensure model generation efficiency while improving the overall quality of requirement models in terms of structural correctness, semantic consistency, and executability, thereby achieving automated construction from natural language requirement texts to system-level executable behavioral models.

[0010] To achieve the above objectives, the present invention provides the following technical solution:

[0011] A system-level requirements modeling and analysis method based on LLM includes:

[0012] Step 1: Identify atomic activities

[0013] Semantic parsing is performed on at least one input natural language requirement text. LLM is used to identify the smallest semantic unit in the requirement text that represents the operation behavior or state change, and atomic-level behavior nodes are extracted. Semantic equivalence judgment and multi-round consistency calibration are used to eliminate referential ambiguity and behavior redundancy, forming a standardized set of behavior nodes corresponding to each natural language requirement text.

[0014] Step 2: Extract the hierarchical relationship

[0015] For the natural language requirement text, a recursive descent parsing strategy is adopted to identify the control flow logic relationship described in the text layer by layer. Behavioral nodes containing conditional branches, loop structures or parallel structures are marked as nodes to be decomposed. The nodes to be decomposed are then subjected to hierarchical content expansion and structure verification until each node to be decomposed is parsed into atomic-level behavioral units, thereby constructing a behavioral relationship description with a hierarchical control structure. The output is a set of behavioral relationship descriptions corresponding to each natural language requirement text.

[0016] Step 3: Construct a behavioral model

[0017] Based on the standardized set of behavior nodes and the set of behavior relationship descriptions, a control structure for a requirement-level behavior model is constructed, model description code conforming to the syntax specification of the behavior model is generated, and the syntax and structure consistency of the model description code is verified to obtain an executable requirement-level behavior model that corresponds one-to-one with each natural language requirement text.

[0018] Step 4: Construct a system-level behavior tree

[0019] After obtaining multiple demand-level behavior models, the preconditions and postconditions of the behavior nodes in each behavior model are extracted. Based on the preconditions and postconditions, behavior dependencies between cross-demand behavior nodes are established. The behavior dependencies are organized into a tree structure according to the behavior triggering order and state evolution path to form a system-level behavior tree.

[0020] Step 5: Check for consistency

[0021] Based on the system-level behavior tree, the following consistency analysis is performed on multiple requirement-level behavior models: behavior execution order conflict analysis; state precondition and postcondition mismatch analysis; constraint conflict analysis between cyclic or parallel behaviors; the final output is the model consistency feedback result.

[0022] Furthermore, step 2 specifically includes:

[0023] 2-1: Frame identification: Use LLM to identify the main control logic relationship type in the current parsing level. The main control logic relationship type includes at least sequential relationship, conditional relationship, loop relationship and concurrent relationship, and mark the behavior node containing internal nested logic as the node to be decomposed;

[0024] 2-2: Layered parsing: For the node to be decomposed, its internal behavioral logic is expanded layer by layer according to the layered progressive strategy from the outside to the inside; when there are still nodes to be decomposed in the expansion result, recursive parsing is continued until each node is parsed into atomic-level behavioral units.

[0025] 2-3: Hierarchical Validation: Based on the syntax parsing tool, the number of branches, the order of behavior execution, the integrity of the nested structure, and the consistency with the semantic requirements of the input natural language are validated in the current level; when the validation result does not meet the preset consistency conditions, diagnostic information is generated and the hierarchical parsing sub-step is triggered to correct the current level;

[0026] 2-4: Output Relationship Description: After completing all level validations, construct a behavioral relationship description with a hierarchical control structure based on LLM, and output a complete text relationship description.

[0027] A system-level requirements modeling and analysis platform based on LLM that implements the above method includes:

[0028] The atomic activity identification module is used to perform semantic parsing on at least one natural language requirement text, extract atomic-level behavior nodes, and generate a standardized set of behavior nodes through semantic consistency calibration.

[0029] The hierarchical relationship extraction module is used to identify the control flow logic relationship in the requirement text using a recursive descent parsing strategy. It performs hierarchical expansion and structure verification on behavior nodes containing nested control structures to generate a hierarchical description of behavior relationships.

[0030] The behavior model construction module is used to construct a requirement-level behavior model structure based on the standardized behavior node set and the behavior relationship description, and generate model description code that conforms to the behavior model syntax specification.

[0031] The system-level behavior tree construction module is used to construct a system-level behavior tree based on the preconditions and postconditions of behavior nodes in multiple requirement-level behavior models.

[0032] The consistency check module is used to analyze and detect the behavioral consistency among multiple requirement-level behavioral models based on the system-level behavior tree.

[0033] As can be seen from the above technical solution, compared with the prior art, this invention, by introducing a hierarchical and progressive logical parsing mechanism, combines the semantic understanding capability of LLM with a structured hierarchical reasoning process. This enables refined parsing of complex nested control flow logic and automatic generation of executable behavior models, and on this basis, supports system-level synthesis and consistency analysis of multi-requirement behavior models. This invention can effectively improve the semantic understanding depth, model structure correctness, and system consistency verification capability in the automatic modeling process, significantly improving the accuracy, completeness, and cross-domain generalization capability of requirement modeling, providing reliable technical support for requirement engineering analysis, formal modeling, and intelligent software system design. Attached Figure Description

[0034] Figure 1 A flowchart illustrating the LLM-based system-level requirements modeling and analysis method provided by this invention;

[0035] Figure 2 A schematic diagram of the overall architecture of the LLM-based system-level requirements modeling and analysis platform provided by the present invention;

[0036] Figure 3 A schematic diagram of the requirement model corresponding to the exemplary requirement text provided by the present invention;

[0037] Figure 4 This is a schematic diagram of an exemplary system-level behavior tree provided by the present invention. Detailed Implementation

[0038] The technical solutions of the present invention will now be clearly and completely described with reference to the accompanying drawings of the embodiments of the present invention. It should be understood that the described embodiments are only some implementations of the present invention and are not intended to limit the scope of protection of the present invention. Equivalent transformations or substitutions made by those skilled in the art to the embodiments without departing from the concept of the present invention should all fall within the scope of protection of the present invention.

[0039] This invention discloses a system-level requirements modeling and analysis method based on LLM, the core process of which is as follows: Figure 1 The diagram illustrates the requirement-level behavioral model generated by the method of the present invention in a general software requirement scenario, to demonstrate the modeling effect of the present invention when dealing with complex requirements including conditional branches, loop structures, and parallel processes.

[0040] The overall process includes stages such as atomic activity identification, hierarchical relationship extraction, and behavioral model construction, and can further realize system-level behavioral synthesis and consistency analysis on this basis.

[0041] 1. In the atomic activity identification step, atomic-level behavior nodes are extracted from the input natural language requirement text, and a standardized set of behavior nodes is generated.

[0042] Considering the common problems of unclear reference, redundant expression, and semantic ambiguity in natural language demand texts, this embodiment adopts a closed-loop processing mechanism consisting of multiple sub-steps to improve the accuracy and consistency of behavior node recognition.

[0043] 1-1 Activity Extraction Sub-step: In the activity extraction sub-step, semantic parsing of the natural language requirement text is performed based on LLM to identify candidate behavior nodes representing operations or state changes. To ensure the structured and processable nature of the output, a pre-designed structured prompt template is used, limiting the LLM to an expert role and explicitly constraining it to only output a set of behavior nodes conforming to a predefined format, such as outputting activity names as JSON arrays without additional explanatory text. By introducing task objective descriptions, few-shot examples, and output format constraints into the prompt template, the uncertainty of the model output can be effectively reduced, thereby ensuring the standardization of candidate behavior nodes.

[0044] 1-2. Semantic Filtering Sub-step: In the semantic filtering sub-step, redundancy elimination is performed on candidate behavior nodes. Specifically, a referential resolution tool is used to parse the referential relationships in the requirement text, mapping pronouns, aliases, or ellipsis expressions to their corresponding antecedents, thereby identifying repetitive behavior nodes introduced by the diversity of textual expression. This step effectively eliminates the node repetition problem caused by expressions such as "this operation," "the above processing," and "this step," improving the semantic purity of the behavior node set.

[0045] 1-3. Multi-round calibration sub-steps: In the multi-round calibration sub-steps, LLM is used to iteratively compare the filtered set of behavioral nodes with the original requirement text to verify the completeness of node semantics and text consistency. When omissions, improper merging, or semantic oversimplification of behavioral nodes are detected, a revised node set is generated and the next round of calibration begins; when the verification passes, a confirmation flag is output and the iteration ends. Through the closed-loop mechanism of "extraction-filtering-calibration," a standardized set of behavioral nodes that is highly semantically aligned with the requirement text is finally obtained.

[0046] 2. In the hierarchical relationship extraction step, a recursive descent parsing strategy is adopted to analyze the logical relationships in the requirement text layer by layer, generating behavioral relationship descriptions with a clear hierarchical structure.

[0047] In response to the multi-layered nested control flow structures commonly found in system-level requirement texts (such as nested loops in conditional structures, parallel branches within loop bodies, etc.), this embodiment constructs a closed-loop hierarchical parsing mechanism of "frame extraction - content filling - in-layer inspection" to simulate the analysis process of human experts peeling away complex logic layer by layer.

[0048] 2-1. Frame Extraction Sub-step: In the frame extraction sub-step, the main logical relationship types in the current text level are identified based on LLM. These logical relationship types include sequential relationships, conditional relationships, cyclic relationships, and concurrent relationships. Through few-shot examples and chain reasoning mechanisms, the model is guided to identify conditional structures triggered by hypothetical phrases, sequential structures indicated by temporal markers, concurrent structures characterized by parallel identifiers, and iterative patterns reflected by repetitive expressions. When the model identifies that a certain behavioral node still contains unexpanded complex logic, it marks that node as a node to be decomposed, triggering the subsequent recursive parsing process.

[0049] 2-2 Content Filling Sub-Step: In the content filling sub-step, a hierarchical and progressive strategy is used to fill in the internal behavioral logic of each node to be decomposed layer by layer. Each node to be decomposed is treated as an independent parsing unit, and it is identified whether it contains conditional branches, loop structures, or parallel tasks. The corresponding behavioral nodes and logical relationships are then added to the behavioral relationship description. If complex internal structures still exist in the filling result, the decomposition mark is retained, and recursion continues to deeper levels until all nodes are parsed into atomic-level behavioral units.

[0050] 2-3. Intra-layer Inspection Sub-step: In the intra-layer inspection sub-step, the parsing results of the current layer are structurally and semantically verified based on the parse tree. Verification includes the accuracy of the number of branches, the rationality of the execution order, the completeness of nested substructures, and the consistency between the overall structure and the implicit logic of the requirement text. When parsing deviations are detected, diagnostic information containing specific linguistic basis is generated and fed back to the content filling sub-step to trigger targeted corrections, thus forming a closed-loop quality control process of "extraction—filling—checking—refilling".

[0051] 3. In the behavior model construction step, based on the standardized set of behavior nodes and the hierarchical description of behavior relationships, an executable requirement-level behavior model is constructed, such as... Figure 3 As shown.

[0052] 3-1. Structural Analysis Sub-step: In the structural analysis sub-step, the scattered behavioral nodes and behavioral relationship descriptions are integrated into a unified structured intermediate representation. This intermediate representation explicitly preserves the control flow semantics of the original requirements in a hierarchical structure, and provides clear and unambiguous input for subsequent model generation.

[0053] 3-2. Model Generation Sub-step: In the model generation sub-step, the structured intermediate representation is mapped to model code conforming to the behavioral model syntax specification based on LLM. The generated model code contains standard syntax elements for describing process start and end, conditional branches, loop structures, and parallel execution, thus forming a complete behavioral model description.

[0054] 3-3. Syntax Checking Sub-step: In the syntax checking sub-step, the generated model code is compiled and verified using the model rendering engine to detect syntax errors, structural defects, and node connectivity issues. When an error is detected, diagnostic information containing the error location and correction suggestions is generated and fed back to the model generation sub-step to regenerate the model code until all verifications are passed, thereby ensuring the executability of the output behavioral model.

[0055] 4. After generating requirement-level behavior models corresponding to multiple requirement texts, the system-level behavior synthesis phase begins.

[0056] The preconditions and postconditions corresponding to behavior nodes are extracted from each demand-level behavior model. Based on the condition satisfaction relationship, the behavioral dependencies and state connection relationships between different behavior models are analyzed, and a system-level behavior tree is constructed accordingly. (See also...) Figure 4This is used to illustrate the system-level behavior tree that represents the overall behavioral logic of a requirement, constructed after obtaining multiple requirement-level behavioral models and analyzing the behavioral dependencies between different behavioral models based on the preconditions and postconditions of behavioral nodes. Nodes represent individual requirement models, and edges represent behavioral dependencies constrained by preconditions and postconditions, thus explicitly depicting the combinational relationships of multiple requirement-level behavioral models at the system level.

[0057] 5. In the consistency check step, based on the system-level behavior tree, the consistency between multiple requirement-level behavior models is analyzed.

[0058] The consistency analysis includes at least one or more of the following: whether there are conflicts in the order of behavior execution; whether there are mismatches between the preconditions and postconditions of behavior nodes; and whether there are constraint conflicts between loop structures or parallel structures. When inconsistencies are detected, a consistency diagnosis result is generated to indicate potential conflict risks in the requirements modeling phase, providing a basis for requirements modification or system design.

[0059] Corresponding to the above methods, embodiments of the present invention also provide a system-level requirements modeling and analysis platform based on LLM, the overall structure of which is as follows: Figure 2 As shown, this diagram illustrates the overall composition of the system and the collaborative relationships between its functional modules. The system includes an atomic activity identification module, a hierarchical relationship extraction module, a behavior model construction module, a system-level behavior tree construction module, and a consistency check module.

[0060] The atomic activity identification module includes:

[0061] Activity extraction is used to identify candidate behavior nodes from the natural language requirement text based on LLM;

[0062] Semantic filtering is used to parse referential relationships in text using a referential resolution tool to remove redundant behavioral nodes.

[0063] Activity calibration is used to iteratively compare candidate behavior nodes with the original requirement text using LLM to verify the semantic integrity and text consistency of the nodes.

[0064] The hierarchical relationship extraction module includes:

[0065] Framework extraction is used to identify the main logical relationship type of the current text layer and mark the nodes to be decomposed based on LLM;

[0066] Hierarchical parsing is used to fill in the internal behavioral logic of the node to be decomposed layer by layer using a hierarchical progressive strategy, generating a progressively refined description of behavioral relationships.

[0067] Hierarchical validation is used to verify the correctness of the current layer structure based on the syntax parse tree and generate a diagnostic report.

[0068] The behavior model construction module includes:

[0069] The extraction results are synthesized and used to integrate the standardized set of behavior nodes and the description of behavior relationships into a unified structured intermediate representation;

[0070] Model generation, used to convert the structured intermediate representation into standardized model code based on LLM into UML activity diagrams;

[0071] Model verification is used to compile and verify the standardized model code using a model rendering engine.

[0072] The modules exchange sets of behavior nodes, descriptions of behavior relationships, behavior models, and system-level behavior tree information through standardized data interfaces, forming a pipelined processing flow with a feedback mechanism. When the verification process of any module fails, the system feeds back the diagnostic information to the corresponding upstream module for correction until the predetermined quality constraints are met, thereby ensuring the accuracy, consistency, and executability of the final output.

[0073] As can be seen from the above complete implementation method, the present invention constructs a recursive, verifiable, and scalable system-level requirement modeling method by combining the hierarchical analysis strategy of human experts with the semantic understanding capability of LLM. It can not only automatically generate requirement-level executable behavior models, but also perform comprehensive and consistency analysis of multiple requirement behaviors at the system level, effectively improving the automation level, structural reliability, and consistency assurance capability of system-level requirement modeling.

[0074] To further describe this technical solution in detail, the following example illustrates multiple identity authentication requirements during the startup process of a smart device.

[0075] Requirement Text 1 (System Startup Phase): "After system startup, an initialization check process should be executed to verify whether the operating environment meets the preset conditions. If the check fails, the error message should be recorded and subsequent operations should be terminated; if the check passes, the system should enter a standby state."

[0076] Requirement Text 2 (User Operation Phase): "When the device starts up, it should first perform identity authentication to verify the legitimacy of the user or device. If authentication fails or cannot be completed, relevant information should be displayed and subsequent operations should be suspended. After successful authentication, the device should initiate a multi-method authentication process, passing at least multiple authentication methods according to the preset security level. Each authentication step should include timeout handling and error handling mechanisms. If the number of consecutive authentication failures exceeds a preset threshold, security protection operations should be performed and an alert notification should be issued. After successful authentication, relevant information about the authentication process should be recorded for subsequent auditing and analysis."

[0077] Requirement Text 3 (Abnormal and Security Handling Phase): "During system operation, if abnormal behavior or the number of consecutive erroneous operations exceeds the threshold, the system should trigger a security protection process, including restricting function access, logging security events, and sending alarm information."

[0078] The above-mentioned multiple requirement texts describe the behavioral logic of the system at different stages such as startup, interaction and exception handling. The texts form overall system behavioral constraints through implicit preconditions and postconditions.

[0079] For each input request text, the system executes an atomic activity identification process. Taking request text one as an example, the activity extractor identifies candidate behavior nodes based on LLM, including but not limited to: performing initialization checks, recording error information, terminating operations, and entering a standby state. For request texts two and three, the system identifies sets of candidate behavior nodes related to identity verification, request processing, and security protection, respectively. Subsequently, a semantic filter uniformly parses referential expressions appearing within and across texts, eliminating redundant nodes caused by differences in expressions such as "this process," "the above operation," and "corresponding processing," and standardizes and merges synonymous behaviors. After completing the atomic activity identification, the system independently executes a hierarchical relationship extraction and behavior model construction process for each request text, generating a corresponding single behavior model.

[0080] Taking requirement text 2 as an example, the framework extractor identifies its top-level logical structure as a conditional branching relationship, including a "identity verification failed" branch and a "identity verification passed" branch. The "identity verification passed" branch is marked as a node to be decomposed because it contains unexpanded request processing logic. The system further recursively parses this branch, identifying the internal condition judgments, sequential execution, and exception handling logic layer by layer until all behavioral nodes are parsed into atomic units. After each layer of parsing, the in-layer checker verifies the branch completeness, execution order, and logical consistency, triggering corrections if necessary. After completing the hierarchical relationship extraction, the behavior model construction module integrates the standardized set of behavior nodes and the hierarchical behavior relationship description into a structured intermediate representation and generates an executable behavior model that conforms to the behavior model syntax specification. After syntax verification, multiple independent behavior models corresponding to requirement texts 1, 2, and 3 are output respectively.

[0081] After generating multiple individual behavior models, the system further enters the system-level modeling stage. The system automatically extracts the preconditions and postconditions of key behavior nodes from each behavior model. For example, "entering standby state" is a precondition for the user operation stage behavior model; "request processing completed" is a precondition for the anomaly detection behavior model; and "triggering the security protection process" is a shared postcondition for multiple models. Based on these precondition / postcondition relationships, the system constructs a system-level behavior tree, organizing multiple behavior models according to chronological order, trigger dependencies, and state evolution relationships to form a unified system-level behavior structure. This system-level behavior tree clearly describes the behavior connection methods and state transition logic between different stages of the system.

[0082] After the system-level behavior tree is constructed, the system executes a consistency check process, including but not limited to: checking the matching of behavior preconditions and postconditions; checking for behavioral conflicts or circular dependencies between different models; and verifying the reachability and termination of the system-level execution path. When a consistency problem is detected, such as when a precondition of a certain behavior model cannot be met in the system-level behavior tree, the system will generate corresponding diagnostic information and feed it back to the relevant model generation stage for correction. After multiple rounds of correction and verification, a logically consistent and structurally complete requirement model is finally generated.

[0083] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the systems disclosed in the embodiments, since they correspond to the methods disclosed in the embodiments, the descriptions are relatively simple; relevant parts can be referred to the method section.

[0084] The above description of the disclosed embodiments enables those skilled in the art to make or use the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A system-level requirements modeling and analysis method based on LLM, characterized in that, include: Step 1: Identify atomic activities Semantic parsing is performed on at least one input natural language requirement text. LLM is used to identify the smallest semantic unit in the requirement text that represents the operation behavior or state change, and atomic-level behavior nodes are extracted. Semantic equivalence judgment and multi-round consistency calibration are used to eliminate referential ambiguity and behavior redundancy, forming a standardized set of behavior nodes corresponding to each natural language requirement text. Step 2: Extract the hierarchical relationship For the natural language requirement text, a recursive descent parsing strategy is adopted to identify the control flow logic relationship described in the text layer by layer. Behavioral nodes containing conditional branches, loop structures or parallel structures are marked as nodes to be decomposed. The nodes to be decomposed are then subjected to hierarchical content expansion and structure verification until each node to be decomposed is parsed into atomic-level behavioral units, thereby constructing a behavioral relationship description with a hierarchical control structure. The output is a set of behavioral relationship descriptions corresponding to each natural language requirement text. Step 3: Construct a behavioral model Based on the standardized set of behavior nodes and the set of behavior relationship descriptions, a control structure for a requirement-level behavior model is constructed, model description code conforming to the syntax specification of the behavior model is generated, and the syntax and structure consistency of the model description code is verified to obtain an executable requirement-level behavior model that corresponds one-to-one with each natural language requirement text. Step 4: Construct a system-level behavior tree After obtaining multiple demand-level behavior models, the preconditions and postconditions of the behavior nodes in each behavior model are extracted. Based on the preconditions and postconditions, behavior dependencies between cross-demand behavior nodes are established. The behavior dependencies are organized into a tree structure according to the behavior triggering order and state evolution path to form a system-level behavior tree. Step 5: Check for consistency Based on the system-level behavior tree, the following consistency analysis is performed on multiple requirement-level behavior models: behavior execution order conflict analysis; state precondition and postcondition mismatch analysis; constraint conflict analysis between cyclic or parallel behaviors; the final output is the model consistency feedback result.

2. The method according to claim 1, characterized in that, Step 2 specifically includes: 2-1: Frame identification: Use LLM to identify the main control logic relationship type in the current parsing level. The main control logic relationship type includes at least sequential relationship, conditional relationship, loop relationship and concurrent relationship, and mark the behavior node containing internal nested logic as the node to be decomposed; 2-2: Layered parsing: For the node to be decomposed, its internal behavioral logic is expanded layer by layer according to the layered progressive strategy from the outside to the inside; when there are still nodes to be decomposed in the expansion result, recursive parsing is continued until each node is parsed into atomic-level behavioral units. 2-3: Hierarchical Validation: Based on the syntax parsing tool, the number of branches, the order of behavior execution, the integrity of the nested structure, and the consistency with the semantic requirements of the input natural language are validated in the current level; when the validation result does not meet the preset consistency conditions, diagnostic information is generated and the hierarchical parsing sub-step is triggered to correct the current level; 2-4: Output Relationship Description: After completing all level validations, construct a behavioral relationship description with a hierarchical control structure based on LLM, and output a complete text relationship description.

3. A system-level requirements modeling and analysis platform based on LLM that implements the method of any one of claims 1-2, characterized in that, include: The atomic activity identification module is used to perform semantic parsing on at least one natural language requirement text, extract atomic-level behavior nodes, and generate a standardized set of behavior nodes through semantic consistency calibration. The hierarchical relationship extraction module is used to identify the control flow logic relationship in the requirement text using a recursive descent parsing strategy. It performs hierarchical expansion and structure verification on behavior nodes containing nested control structures to generate a hierarchical description of behavior relationships. The behavior model construction module is used to construct a requirement-level behavior model structure based on the standardized behavior node set and the behavior relationship description, and generate model description code that conforms to the behavior model syntax specification. The system-level behavior tree construction module is used to construct a system-level behavior tree based on the preconditions and postconditions of behavior nodes in multiple requirement-level behavior models. The consistency check module is used to analyze and detect the behavioral consistency among multiple requirement-level behavioral models based on the system-level behavior tree.

Images