WO2026000006A1 - Method for functional analysis of a source system - Google Patents

Abstract

The invention relates to a method for functional analysis of a source system (1), wherein a syntax tree model (3) is generated from the program code data of the source system (1). In order to propose a method for functional analysis of a source system (1), in particular with extensive program code data, which method makes it possible to better identify interrelated functional units and, with high result quality and at the same time low resource requirements, to improve further processing by means of a large language model, the invention provides that a syntax analysis unit (4) generates a syntax embedding model by decomposing the syntax tree model (3) into individual syntax element embeddings (5), each representing a syntax element, and stores said syntax embedding model in a syntax embedding model memory (6), and that a language analysis unit (8) generates a language embedding model by decomposing the program code data into individual language element embeddings (9), each representing a language element, and stores said language embedding model in a language embedding model memory (10), whereupon, by means of a query unit (12), at least one query embedding (13) is generated from a query (11) representing a functional element of the source system (1) and those syntax element embeddings (5) and language element embeddings (9) which lie within a predefined range of similarity to the query embedding (13) are retrieved from the syntax embedding model memory (6) and the language embedding model memory (10), whereupon the syntax elements represented by the retrieved syntax element embeddings (5) and the language elements represented by the retrieved language element embeddings (9) are transferred as result elements (14) to an output unit (15), which generates therefrom a functional description dataset (16) and outputs the latter.

Description

Procedures for one

Technical field

The invention relates to a method for functional analysis of a source system, wherein a syntax tree model is generated from the program code data of the source system.

State of the art

For the automated functional analysis of computer-implemented systems, it is known, for example, from US20220261241A1, to create a syntax tree from the system's program code data and to generate a function description text in natural language using a neural network. The neural network is trained using both known specifications of the programming language employed and a training set of open-source program code databases. A disadvantage of such a method is that it does not consider the documentation derived from the syntax tree, recognizes related functional elements only inadequately, and the function description text in natural language achieves only a low level of abstraction, so that manual analysis of the program code is often necessary.

US20240020116A1 discloses a method for generating natural language elements based on program code data of a system. A machine learning model is trained using program code data with known functionality and natural language elements associated with this program code data, after which natural language elements are generated from unknown program code data. Based on these result elements Summaries, code documentation, and translations can be created using a large language model. Additionally, program code data can be generated from a natural language query. A disadvantage of this method is that only language elements with a known function can be recognized.

Furthermore, it has already been proposed to generate a functional analysis of program code data directly through inference with a large language model. However, disadvantages of this approach include, on the one hand, the limited size of the inference dataset and, on the other hand, the hallucinations and inaccuracies in the functional description typical of large language models, which make the functional analysis of source systems with extensive program code data impossible.

Description of the invention

The invention is therefore based on the objective of proposing a method for the functional analysis of a source system of the type described above, in particular with extensive program code data, which makes it possible to better identify related functional units and to improve further processing by a large language model while maintaining high result quality and simultaneously requiring low resources.

The invention solves the stated problem by using a syntax analysis unit to generate a syntax embedding model by decomposing the syntax tree model into individual syntax element embeddings, each representing a syntax element, and storing them in a syntax embedding model memory; and by using a language analysis unit to generate a language embedding model by decomposing the program code data into individual language element embeddings, each representing a language element, and storing them in a language embedding model memory; after which a query unit retrieves a functional element from the source system. For each query representing the query, at least one query embedding is created, and those syntax element embeddings and language element embeddings that lie within a predefined similarity range to the query embedding are retrieved from the syntax element embedding model memory and the language element embedding model memory. The syntax elements and language elements represented by these retrieved embeddings are then passed as result elements to an output unit, which generates and outputs a function description record. As a result of these measures, even very large program code data, with regard to both program logic and any comments and documentation in natural language contained within the program code, can be decomposed into smaller function elements. The result elements characterize the aspects of the respective function element so comprehensively, even in distributed program code segments, that a complete function description record can be generated despite reduced resource consumption. The query unit can preferably generate two query embeddings from the query, one for the language embedding model and one for the syntax embedding model. This is particularly necessary when the dimensions of the embedding models differ. Key-value mappings, which assign syntax and language elements to individual keys, can be used as the simplest embedding models. Vector space models can also be used as embedding models, so that the language and syntax element embeddings are accordingly implemented as language and syntax element vectors. In the case of vector space models as embedding models, the query embeddings can be implemented as query vectors, where the dimension of a first query vector corresponds to the dimension of the language vector space and the dimension of a second query vector corresponds to the dimension of the syntax vector space. Finally, graph embedding models can also be used as embedding models, which define individual syntax and language elements via their relationships to other syntax and language elements. The similarity range, in particular the distance between the language and syntax element embeddings on the one hand and the respective query embeddings on the other, can be determined, especially in the embodiment of vector space models, for example, by their cosine similarity. Alternatively, other similarity measures, such as the Jaro-Winkler distance, the Levenshtein distance, or the Jaccard index, can be used to determine those language and syntax element embeddings that lie within a predefined similarity range to the query embeddings. The similarity range can also be determined, for example, by specifying a number of syntax or language element embeddings ranked in ascending order according to their distance to the respective query embedding. The program code data can include both functional commands in a programming language and documentation in natural language. The program code data can be retrieved from the source system.

To generate a complete functional description dataset despite incompletely documented program code data and architectural concepts extending beyond the pure program code data, it is proposed that the documentation data of the source system, at least partially available in natural language, be decomposed by the language analysis unit into individual language element embeddings, each representing a language element. These embeddings are then added to the language embedding model and stored in the language embedding model memory. This enriches the language element embeddings already present in the language embedding model memory and assignable to individual program code sections with additional information. This additional information is not derived from the program code data itself, but from other documentation data, such as specifications, project documentation, case management system data, or manuals.

To address potential gaps in the syntax and language elements, which are considered

Result elements are passed to the output unit, to be filled and On the other hand, to resolve overly precise or contradictory information, the output unit can generate an inference dataset for a large language model from the result elements and pass it to an inference platform, after which the inference response is output as a function description dataset. This has the advantage that a relatively small, yet highly specific inference dataset can be generated from the result elements, preventing potential hallucinations arising from the large language model. This allows the respective inference platform to be used more reliably to reduce the level of abstraction of the result elements and to resolve potential contradictions or fill gaps using generally available information. Furthermore, the inference dataset allows the inference response to be adapted as a function description dataset to a target system that may differ in its architecture from the source system. Generative pretrained transformers (GPTs), for example, can be used as large language models.

To enable the applicability of the method according to the invention to different source systems, it is proposed that the syntax tree model be programming language-independent, in particular a Generic Abstract Syntax Tree Metamodel (GASTM). This has the advantage that the syntax tree model, and thus also the syntax embedding model memory, can be constructed and reused independently of the programming language used. A syntax element can comprise one or more nodes of the syntax tree model, which preferably form functional relationships or a functional unit.

A complete mapping of functions relevant to the source system can be achieved if a generator unit selects function elements of the source system from the syntax tree model based on predefined rules and generates a query for each function element to be passed to the query unit. As a result of these measures, the individual function elements of the source system are systematically selected from the syntax tree based on their syntax elements. A syntax tree model is selected, whereby the predefined rules can be based, for example, on specific flow patterns in call and stack tracing or on other syntactic relationships. The use of such rules makes it possible to analyze different source systems according to a common system with regard to their function and to generate function description data records for the individual function elements.

Although it may generally be sufficient in a preferred embodiment to provide machine-readable information in a markup language within the function description data set, the inventive method can improve simple porting between different system architectures if the function description data sets include program code data for a target system whose architecture differs from that of the source system. Due to these features, the output unit provides a function description data set in a machine-readable language, which is preferably directly executable on the target system and stored in a program code memory of the target system. For this purpose, the program code data contained in the function description data set can be transferred to the target system.

Brief description of the invention

The invention is illustrated in the drawing, for example, in a schematic block diagram.

Ways to implement the invention

A method according to the invention comprises a source system 1, from whose program code data a syntax tree model 3 is generated using a syntax tree generator 2. By decomposing the syntax tree model 3, several syntax element embeddings 5, each representing a syntax element, can be generated by a syntax analysis unit 4, which are then stored in a Syntax embedding models are stored in a syntax embedding model memory 6. In parallel, language element embeddings 9 can be generated in a language analysis unit 8 from both the program code data of the source system 1 and from documentation data 7 of the source system 1 that is available in natural language, and these are stored in a language embedding model in a language embedding model memory 10.

Based on a query 11, several query embeddings 13 can be generated in a query unit 12, the dimension of which in a preferred embodiment corresponds to the dimension of the language or

This corresponds to the syntax embedding model. From the syntax embedding model memory 6 and the language embedding model memory 10, those syntax element embeddings 5 and language element embeddings 9 that lie within a predefined similarity range, in particular at a predefined distance, to the query embeddings 13 are then retrieved and passed as result elements 14 to an output unit 15. In the output unit 15, a function description data record 16 is then generated from the result elements 14.

Preferably, the output unit 15 can first generate an inference data set 17 for a large language model from the received result elements 14 and transfer it to an inference platform 18. The inference response 19 can then be used in the output unit 15 to create the function description data set 16, in particular to form the function description data set 16.

In the embodiment shown, the query 11 can be created in a generator unit 20 based on the functional elements of the syntax tree model 3.

The functional description data set 16 resulting from the procedure can include program code data for a target system 21 whose architecture differs from that of the source system 1. ```

Claims

Patent claims 1. A method for functional analysis of a source system (1), wherein a syntax tree model (3) is generated from the program code data of the source system (1), characterized in that a syntax embedding model is generated by a syntax analysis unit (4) by decomposing the syntax tree model (3) into individual syntax element embeddings (5), each representing a syntax element, and stored in a syntax embedding model memory (6), and that a language analysis unit (8) generates a language embedding model by decomposing the program code data into individual language element embeddings (9), each representing a language element, and stores in a language embedding model memory (10), after which a query unit (12) generates at least one query embedding (13) from a query (11) representing a functional element of the source system (1), and those syntax element embeddings (5) and language element embeddings (9) are retrieved from the syntax embedding model memory (6) and the language embedding model memory (10). are retrieved which lie within a predefined similarity range to the query embedding (13), after which the syntax elements represented by the retrieved syntax element embeddings (5) and the language elements represented by the retrieved language element embeddings (9) are passed as result elements (14) to an output unit (15), which generates and outputs a function description data record (16). 2. Method according to claim 1, characterized in that documentation data (7) of the source system (1), which is at least partially in natural language, is decomposed by the language analysis unit (8) into individual language element embeddings (9), each representing a language element, which are added to the language embedding model and stored in the language embedding model memory (10). 3. Method according to one of claims 1 or 2, characterized in that the output unit (15) generates an inference data set (17) for a large language model from the result elements (14) and passes it to an inference platform (18), after which the inference response (19) is output as a function description data set (16). 4. Method according to one of claims 1 to 3, characterized in that the syntax tree model is a generic abstract syntax tree metamodel. 5. Method according to one of claims 1 to 4, characterized in that a generator unit (20) selects functional elements of the source system (1) from the syntax tree model according to predefined rules and generates a query (11) for each functional element for transfer to the query unit (12). 6. A method according to any one of claims 1 to 5, characterized in that the function description data set (16) comprises program code data for a target system (21) whose architecture differs from that of the source system (1).