Self-programming system

Abstract

Methods in a system for programming in natural language, comprising the steps - Machine capture and analysis (S100) of digital input information, which includes a plurality of input elements in natural language, - Determine (S200), by the system, based on analyzing the input information, an elementary data type of an input element of the input information, and - Generating (S300) source code for the elementary data type, the step of which includes capturing the input information: - Dividing the input information into sentences, where a sentence comprises a sequence of consecutive input elements in the input information and ends with a separator; and where the step of determining (S200) the elementary data type comprises the following substeps: - Recognizing a first set comprising a first sequence of input elements and a second set comprising a second sequence of input elements, wherein the first sequence and the second sequence differ only at one position, wherein the first sequence includes a first difference input element at this position and the second sequence includes a second difference input element at this position, - Determining the elementary data type for the difference input elements; assigning the specified elementary data type to each of the difference input elements.

Description

[0001] The present invention relates to a method for self-programming in natural language and a corresponding system. Technological background

[0002] Traditional machine learning calculates transition probabilities from one word to another based on predefined models, often based on Markov model probability theory. However, systems capable of independently and flexibly developing their own models and logic for any natural language from input information are still lacking. Methods capable of reprogramming themselves to adapt to new tasks or environments without requiring manual reprogramming are also missing.

[0003] Currently, no method exists that can make decisions regarding the transition from one state to another based on logic derived from input information or self-programmed logic. Likewise, no method exists that can autonomously control systems using such techniques.

[0004] The above information serves only as background information to facilitate understanding of the description. It does not constitute a statement or assertion as to whether any of it could be considered prior art in relation to the disclosure.

[0005] US Patent 7,765,097 B1 describes a method for automatic code generation that includes the following steps: obtaining a parse tree, wherein the parse tree represents at least one instruction and wherein the instruction is in natural language and wherein the at least one instruction is freely formulated; determining a plurality of sentence fragments from the parse tree; generating at least one instantiated concept for each of the plurality of sentence fragments; inserting the instantiated concept into an instantiated concept mapping; traversing the instantiated concept mapping, wherein the traversal of the instantiated concept mapping for each instantiated concept in the instantiated concept mapping includes obtaining a code output rule according to the instantiated concept and outputting code according to the code output rule upon completion of claims.

[0006] A Part of Speech Tagger according to WO 2014 / 115189A1 identifies each word in a sentence according to its word class. The Grammatical Analyzer analyzes the grammatical structure of a sentence, identifies the sentence's constituents, and tags each constituent. The Label Sequence Matcher compares a sequence of constituent labels with one or more transformation rules. The Code Generator generates the test components and the system under test.

[0007] An article by BRILL, E., entitled “A Simple Rule-Based Part of Speech Tagger,” published in: Proceedings of the Third Conference on Applied Computational Linguistics (ACL), Trento, Italy, 1992, 112–116, describes a simple rule-based part-of-speech tagger that automatically acquires its rules and tags with an accuracy comparable to stochastic taggers. The main contribution of this work is to show that the stochastic method is not the only viable method for part-of-speech tagging.

[0008] The object of the present invention is to address the aforementioned problems and to improve and simplify the programming of technical systems through self-programming.

[0009] This task is solved by a method and a system for programming in natural language with the features of the independent claims. Advantageous embodiments and further developments are specified in the dependent claims. Summary of the invention

[0010] A fundamental problem in natural language analysis and programming is that, unlike standardized input elements such as a date, a number, a telephone number, an email address, or the like, ordinary input elements in natural language, especially words, cannot be easily typed by machines, since they are initially only recognized by the system as a simple string and are not further differentiated.

[0011] While it is already possible to assign a data type (in the conventional sense known from computer science) such as "Integer" to a number, such as "23", or to automatically recognize an input element of the form "29.08.2022" as being of the data type "date", it is not yet easy to assign a "data type" to words in natural language that would make it possible to recognize and type equivalent or related words in a certain way, i.e., for the purpose of programming in natural language.

[0012] This problem is solved by the present invention. The invention is defined by the attached claims. The following description is subject to this limitation. Any disclosure outside the scope of the stated claims serves only for illustration and comparison purposes.

[0013] A preferred embodiment of a method in a natural language programming system, which is in Fig. As shown schematically in Figure 1, it comprises the following steps: Digital input information, e.g., in the form of text, is captured and analyzed automatically (step S100). The input information comprises a multitude of input elements, especially words, in natural language.

[0014] Preferably, a very large amount of input information is processed.

[0015] In step S200, the system then determines, based on the analysis of the input information, a so-called elementary data type of an input element of the input information.

[0016] The following section details how this analysis and the determination of the data type can be carried out.

[0017] The term “elementary data type” is used in connection with the present invention in a specific sense and should not be confused with a data type in the conventional sense, such as “char”, “integer”, “float”, “boolean”, etc.

[0018] Elementary data types are defined for input elements in order to classify these input elements into classes or groups of input elements, whereby input elements to which the same elementary data type is assigned are then, in a certain sense, equivalent in the context of natural language programming.

[0019] This will be explained using a number of examples below.

[0020] Initially, an elementary data type is an abstract construct and carries no inherent meaning in the input element. Therefore, in the following, different elementary data types will simply be designated as T1, T2, etc.

[0021] An elementary data type serves to make structural information inherent in the input information visible in a certain way. Source code generated for each elementary data type (see step S300) then serves to store objects, i.e., concrete instances, of the elementary data type—that is, input elements to which this elementary data type is assigned—along with this structural information after the input information has been analyzed.

[0022] Within the scope of the present invention, other types of data types will be introduced, such as a generic data type T, and a non-elementary data type TT1, TT2, etc. Conventionally known data types, such as "integer", "boolean", as well as standardized data types, such as "time", "date", etc., are hereinafter referred to as "initial data types".

[0023] The generic data type T serves only the purpose of simplifying the technical implementation of the invention and does not represent a central concept.

[0024] A non-elementary data type TTi is not assigned to a single input element, i.e., not a single word, but to a plurality of words, a sentence structure, or something similar. The source code generated by the system to store this structure, along with information about the elementary data types already assigned to the individual elements of the structure, is simultaneously the source code that allows an instance of the non-elementary data type assigned to the structure to be stored. The terms "structure" and "non-elementary data type" are used almost interchangeably in the following.

[0025] Furthermore, higher-level structures can be recognized and corresponding source code generated, whose elements are not necessarily only assigned elementary data types, but whose elements themselves are already structures to which non-elementary data types are already assigned.

[0026] When the term "data type" is used below, it should always be clear from the context whether an elementary data type or a non-elementary data type (or both) is meant.

[0027] As mentioned previously, the procedure for storing the aforementioned structural information further includes step S300, which involves generating source code for the elementary data type in order to store an object of that elementary data type in the system. A separate source code is generated for each specific data type.

[0028] Finally, in step S400, the system creates an elementary object of the elementary data type to store the specific input element. Creating this object typically requires compiling the source code.

[0029] An elementary object created in this way then contains information about the elementary data type as well as the value of the input element; i.e., in the case of a word as the input element, the word itself, along with the elementary data type associated with the word, is stored in the elementary object.

[0030] There are various ways this information can be stored in the system. One preferred method, which we will often use as an example for the sake of clarity and simplicity, is a so-called Input Element Data Type List (EDL).

[0031] There, for each input element Wi, a data type Tj assigned to that element is specified: Table 1: Input element data type list Input element Data type W1 T1 W2 T1 W3 T2 W4 T2

[0032] It should be noted at this point that, according to a preferred embodiment, it is provided that more than one data type can be assigned to an input element.

[0033] A preferred embodiment of a system 1 for programming in natural language is described in Fig. 2 shown and includes - an input device 10 for entering input information and for entering a (further explained below) programming string; - a recording device 20 for recording the input information; - a structural analysis device 30 for analyzing the input information, - a storage device 40; and - at least one processor 50 for generating and / or executing program code, wherein the system is configured to execute a procedure described above.

[0034] As explained below, the inventive method allows the language structure of the input information to be recognized and stored in an accessible manner. This then makes it possible to make the system virtually "intelligent." For this purpose, the analyzed input information is processed in a suitable manner, as described below, using the elementary and non-elementary data types assigned to the input elements and other structural elements. This processed and prepared input information then allows, for example, the system to automatically generate a natural language answer to a question entered in natural language.

[0035] This invention differs fundamentally from conventional machine learning. In the traditional approach, transition probabilities from one word to another are calculated based on predefined models, often based on the probability theory of the Markov model.

[0036] In contrast, the present invention automatically creates its own models that dynamically adapt to the input information. The generated model relies on entirely new approaches and differs fundamentally from traditional machine learning methods.

[0037] According to the present invention, fundamental structures of natural language are captured, and for each captured language structure, a source code is automatically generated and stored in the system. The smallest units of the structures are, in turn, grouped together by higher-level structures and stored in the system as source code, as described in detail below.

[0038] These structures represent the entire language in the form of small program modules. The system develops these modules autonomously, without the intervention of a human programmer, and continuously extends them to adapt to changes or additions to the input information. This approach enables dynamic and adaptive modeling of the language structures, allowing the system to handle new information in a variety of ways.

[0039] Subsequently, further user input can activate these program components, with the smallest units being activated first. This can trigger a chain reaction, activating further program components within the higher-level structures. The platforms, including Linux, Windows, and Apple, handle the execution of these program components, employing proven mechanisms that have been the subject of intensive research and development for decades, even though their specific contribution is not explicitly mentioned in this invention.

[0040] The application of these mechanisms ensures efficient and resource-saving execution of the program components. This underscores the effectiveness of the invention, as it draws on proven principles to enable the seamless and effective implementation of the generated program structures.

[0041] The execution of these program components then triggers actions that control devices, enable the exchange of electronic data with internal or external systems, or generate statements in natural language. This holistic approach marks an innovative step in the field of self-learning systems.

[0042] Another important application of the described method is that the passing of parameters and the correct assignment of parameters in connection with natural language programming can be significantly simplified.

[0043] To explain this, reference will be made to an earlier invention of the present inventor, cf. e.g. WO 2017 / 186469 A1. There, the concept of a string program code component, ZPK, was introduced.

[0044] A ZPK comprises a program code segment that implements a technical functionality, as well as a definition string that contains an expression in natural language.

[0045] A ZPK (Central Programming Key) can be called or executed in the system by entering a so-called programming string. This occurs if the programming string "sufficiently" matches the definition string of the ZPK. Since both the programming string and the definition string are in natural language, and since natural language is diverse and variable, it is not always easy to decide whether an entered programming string "essentially" matches the definition string or not.

[0046] This problem can be solved very elegantly with the present invention by using a so-called data type list instead of a definition string. Instead of a word in natural language, this list contains one or more elementary data types assigned to the word during the analysis. The resulting structure is referred to below as the data type list program code component, DPK.

[0047] A word in a programming string that is assigned a corresponding elementary data type can then be uniquely associated with the original word in the definition string if the respective elementary data types match. Minor linguistic variations that previously prevented unambiguous mapping no longer occur, as they disappear through typing by data type. Checking the validity of a parameter can also be simplified and standardized through the use and assignment of data types. Brief description of the characters

[0048] The invention is explained in more detail below using specific embodiments and accompanying drawings as examples. The figures show: Fig. 1 Schematic representation of the steps of a preferred embodiment of the method according to the invention; Fig.2 schematically a preferred embodiment of a system according to the invention; Fig. 3 schematically different structures defined in the input information; Fig. 4 schematically represents a tree structure generated by the system; and Fig. 5 external devices schematically connected to the system. Detailed description of the invention

[0049] The following description examines individual aspects of the procedure described here in more detail. In particular, it shows how elementary and non-elementary data types can be determined and what further steps can be taken to analyze the input information with regard to its inherent structure. This concerns an initial phase, which will also be referred to as the analysis phase.

[0050] The text then describes how the identified and captured structural information can be used for natural language programming and for providing a voice assistant system. This concerns a phase following the analysis phase, in which input information can still be entered into the system. Preparatory steps

[0051] For the sake of clarity, an input element consisting only of letters, i.e. a "word" in the conventional sense, will be denoted by Wi, i = 1, 2, etc.

[0052] Input elements that can already be assigned an initial data type, such as "time", "date", etc., are designated with Ej, j = 1, 2, etc.

[0053] Input information, usually a text in natural language, and conventionally structured input elements (separators), especially punctuation marks, are referred to below as Ik, k = 1, 2, etc.

[0054] Input information in the form of a simple, short text in natural language could, for example, have the following form: W1 W2 W3 I1 W11 W12 W13 W14 I2 W21 W22 W23 W25 I3 W1 W2 W4 I2 W1 W2 W99 I2.

[0055] The input elements Wi are ordinary words; I1 could be a comma, I2 a period, and I3 a semicolon.

[0056] Since no words Wi have been entered into the system yet, the system will initially assign the generic data type T to these words in a first phase of analyzing the input information.

[0057] Depending on the programming language, the source code for this generic data type can be defined as follows: class T { char[] value; constructor (char[] v) { value = v;}}

[0058] The words “W1”, “W2” and “W3” can be assigned to the data type as follows: O1 = T.constructor (“W1”); O2 = T.constructor (“W2”); O3 = T.constructor (“W3”); Oi, i = 1, 2, 3, denotes an elementary object.

[0059] The generic data type T acts only as a placeholder and is introduced for technical reasons. Once the system determines and assigns an elementary data type to the input element, the data type T can be replaced by that elementary data type.

[0060] The resulting objects can be assigned to the system as follows: System.add (O1, O2, O3);

[0061] Thus, an object comprises the information pair (data type, value) and can be captured or stored using "System.Add".

[0062] The same principle applies in principle to input elements of initial data types (not specified in the above exemplary input information) (“-23” -> Integer, “2,4”-> float, “29.08.2022”->“Date, “12:45”-> Time, ...): O4 = Integer.constructor(“-23”); O5 = Date.constructor(“08 / 15 / 2022”);

[0063] Alternatively, as already described, the information on input elements and associated data types can also be recorded in the input element data type list (EDL) (see Table 1 above).

[0064] Thus, according to one embodiment of the method, the step of capturing the input information can comprise the following sub-steps: - Capturing a string representing the input information; - Detecting an input element in the string; - For each input element: - Determining a generic data type T; - Creating an object of generic data type T to store the input element.

[0065] Typically, only one object is created for each input element. If an input element, especially a word, appears multiple times in the input information, this does not result in the creation of further objects for that input element. Sentence recognition

[0066] The system then recognizes so-called "sentences" in the input information.

[0067] For the purposes of this description, a "sentence" is defined as a sequence of input elements, usually words Wi, that follow each other (immediately) in the input information, with the sentence ending with a separator, in particular a punctuation mark. A sentence can therefore consist, in particular, of a sequence of words followed by a separator / punctuation mark.

[0068] Sentence recognition can take place in the first phase of input information analysis described above.

[0069] In the example above, the system could therefore divide the input information into sentences as follows: W1 W2 W3 I1 W11 W12 W13 W14 I2 W21 W22 W23 W25 I3 W1 W2 W4 I2 W1 W2 W99 I2.

[0070] According to one embodiment, it can be provided that individual predefined input elements (words) are ignored or marked as optional when forming sentences. This can be useful in order to filter out filler words that contribute little meaning at this stage. Such a procedure is known to those skilled in the art from the automatic processing of natural language and therefore does not need to be described in detail here.

[0071] Sentences identified in this way can be stored appropriately in the system, at least temporarily. Determining elementary data types based on the sets of difference input elements

[0072] To determine elementary data types for the input elements of the input information, the sentences identified in the manner described above can be compared.

[0073] The aim is in particular to find similar sentences, i.e. sentences whose respective sequences of input elements at least partially match, i.e. differ only at exactly one position, such as the sentences W1 W2 W3 I1 and W1 W2 W4 I2.

[0074] These two sentences have word sequences with the same number of words, and the words W1 and W2 appear in both word sequences in the same order and in the same position.

[0075] The word sequences differ only in the third position; in the first sequence, the input element W3 is found there, which can be described as the first differential input element. In the second sequence, the second differential input element, W4, is located there.

[0076] The system determines an elementary data type for the detected difference and programs source code to declare it in the programming language, e.g., in the following form: class T1 { char[] variable; constructor (char[] v) { variable = v;}}

[0077] The very simple procedure described above can easily be generalized to coherent sequences of words in sentences, in order to cover, for example, the following cases:

[0078] The main structuring unit remains a sentence, but not only "whole" sentences are considered, but also sequences of sub-words thereof (e.g. all sub-word sequences of a given length).

[0079] The procedure may include the following general steps: - Recognizing a first set comprising a first sequence of input elements and a second set comprising a second sequence of input elements, wherein the first sequence and the second sequence differ only at one position, wherein the first sequence includes a first difference input element at this position and the second sequence includes a second difference input element at this position, - Determining an elementary data type for the difference input elements; - Generating source code for the elementary data type, where each of the difference input elements is assigned a specific elementary data type.

[0080] In principle, it is possible to replace the data type previously assigned to each of the difference input elements (in the examples, input elements W3 and W4) with the elementary data type that has been determined for the difference structure.

[0081] This applies in particular if the previously assigned data type was the generic data type T: Input element Data type W1 T W2 T W3 T1 W4 T1

[0082] However, it can often be advantageous to retain a previously assigned elementary data type (unlike the generic data type T) and to assign the newly determined elementary data type in addition.

[0083] If the system recognizes and considers, for example, the further sentence W1 W2 W99 I2, it recognizes similar sentences in an analogous way and would consequently also assign the elementary data type T1 to the input element W99. Input element Data type W1 T W2 T W3 T1 W4 T1 W99 T1 String program code components for determining elementary data types

[0084] In addition to the above procedure, a suitably configured ZPK can also be used in the system to determine elementary data types of input elements of the input information, as described below.

[0085] As mentioned previously, a ZPK comprises a program code segment that implements a technical functionality, as well as a definition string that contains an expression in natural language.

[0086] As described, the system has recognized a differential input element for each of the following sentences, namely input elements W3 and W4. (Separators are omitted here for simplicity): Sentence 1 with word sequence 1: [...] W1 W2 W3 [...] Sentence 2 with word order 2: [...] W1 W2 W4 [...]

[0087] After the initial detection of this difference, the system can program a ZPK (Zero Point Characteristic) by means of which a corresponding difference input element can be recognized for further sentences with corresponding word sequences, and the corresponding elementary data type can then be assigned to this difference input element.

[0088] The ZPK can take the following form:

[0089] When capturing another similar word sequence, such as "W1 W2 W100", the system can search for the ZPK whose definition string corresponds to the pattern "W1 W2 x", where x is a variable to which various input elements, in the example the input element W100, can be assigned.

[0090] If this is the case, the ZPK code segment is executed, which results in the data type T1 being assigned to the input element W100:

[0091] The input element data type list is thus extended as follows: Input element Data type W1 T W2 T W3 T1 W4 T1 W99 T1 W100 T1

[0092] In general terms, the process can include the following further steps: - Generating, by the system, a string program code component (PCC) to determine an elementary data type of an input element of the input information, the ZPK includes: - a program code segment that implements a technical functionality; and - a definition string comprising a natural language expression, wherein the definition string includes those input elements in which the first sequence and the second sequence match, and a variable corresponding to a difference input element of the sequence at one position; and where the program code segment implements a functionality which, when executed, - upon input of a sentence comprising a sequence of input elements that matches the definition string word by word except for one position, and which includes another input element that can be assigned to the variable at that one position, - assigns to this additional input element the elementary data type determined for the difference input elements.

[0093] Orders in the definition string and the word sequence are generally taken into account, so that different ZPKs can exist for different orders.

[0094] Assuming that a very large number of sentences are entered into the system, the above process in the EDL will gradually replace all generic data types T with recognized elementary data types: Input element Data type W1 T2 W2 T3 W3 T1 W11 T3 W12 T2 W13 T6 W14 T4 W21 T3 W22 T2 W23 T6 W24 T5 W4 T1 W99 T1 ... ... Recognizing and recording simple structures

[0095] The following steps, which the procedure described here may include, serve to further structure the input information. The first step involves identifying simple structures within the input information.

[0096] Here, a structure is understood to be a linguistic structure of the input information, such as a sentence (main clause or subordinate clause), a clause, such as an insertion, etc.

[0097] Unlike a "sentence" in the above sense, a structure no longer describes the input information at the level of words, but at the level of elementary (and later also non-elementary) data types that are now assigned to the individual input elements.

[0098] To identify such structures, separators can again be used, such as conventional punctuation marks, paragraphs and other commonly used control characters for structuring texts. In particular, a previously identified sentence can give rise to a structure.

[0099] For the sentence W1 W2 W3 I1, a data type list of the form (T2, T3, T1) can be created, e.g. using the EDL, because the words W1, W2, W3 are assigned the data types T2, T3, T1.

[0100] The system then programs the following source code for the structure in question: class S1 { T2 variable1; T3 variable2; T1 variable3; constructor (T2 v1, T3 v2, T1 v3) { variable1 = v1; variable2 = v2; variable3 = v3;}}

[0101] In the following, it will also be said that the structure S has the data type list (T2, T3, T1).

[0102] For the sake of understanding, it will be important to distinguish between a "structure" in the abstract sense and a concrete object or an instance of that structure. The structure itself merely corresponds to a template that then allows any objects of the structure to be stored.

[0103] An abstract structure (as a template) can, for example, be defined as comprising three elements of a given data type, where the order of these elements can be specified.

[0104] The source code shown above can be generated for this purpose.

[0105] The constructor specifies the order in which the elements of the given data types appear.

[0106] An object of this structure S1 could, for example, be the word sequence W1 W2 W3.

[0107] This object can also be written in the form S1.Constructor("W1", "W2", "W3").

[0108] The step of capturing the input information can therefore include the following steps: - For a set of input information, where each input element of the set is assigned at least one elementary data type: - Generating source code for a structure that maps the set at the data type level, which allows an instance of the structure to be stored, with information about the elementary data types assigned to the input elements of the set and their order.

[0109] In the case that a multiple elementary data types are already assigned to an input element of the sentence, one of the methods described below can be used.

[0110] Let's assume the simple case that the word W3 already has the elementary data types T1 and T20 assigned to it. Then, in addition to the structure S1 mentioned above, the system would further define the structure S1.1:

[0111] Alternatively, an additional constructor could be added to the structure S1, for example in the following way:

[0112] According to one embodiment, a data type can also be assigned to a structure defined in this way, then a non-elementary data type.

[0113] The process may then include the following steps: - Determining a non-elementary data type for the structure;

[0114] Source code for the non-elementary data type already exists, namely the source code of the structure.

[0115] Therefore, the specific non-elementary data type can be assigned to the structure as well as to all elements encompassed by the structure.

[0116] The structure S1 could, for example, be assigned the non-elementary data type TT3. Then, if the record W1 W2 W3 is stored as an instance of the structure S1, the additional non-elementary data type TT3 could be specified for the input elements of the record in the EDL: Input element Data type W1 T2, TT3 W2 T3, TT3 W3 T1, TT3 W11 T3 ... ...

[0117] It should be noted at this point that the structure can also store several sequences of the elementary data types if the input information also contains a set that includes input elements of the same data types, but in a different order (e.g. T2, T3, T1 and T3, T2, T1).

[0118] To capture further sequences, the procedure may include the following additional steps: - in the case of a further set which includes input elements whose assigned elementary data types correspond to the elementary data types of the set, but are arranged in a different order; - Extending, through the system, the source code for the structure so that it allows additional information to be stored in the other sequence.

[0119] If, at a later time, a sentence is detected whose input elements are assigned the same data types but in a different order, e.g., "T3 T2 T1", the structure is extended as follows (e.g., by adding another constructor): class S1 { T2 variable1; T3 variable2; T1 variable3; constructor (T2 v1, T3 v2, T1 v3) { variable1 = v1; variable2 = v2; variable3 = v3;} constructor (T3 v1, T2 v2, T1 v3) { variable1 = v1; variable2 = v2; variable3 = v3;}}

[0120] Structures and instances of captured structures can be stored in the system in various ways, similar to how this has already been described with reference to elementary objects, e.g. by means of a so-called structure instance data type list, SDL.

[0121] This allows the source code defining each structure to be stored within it. Table 2: List of structure instance data types Structure and the instances stored for it Data type S1 TT1 Instances of structure S1 (e.g. sentences) S1_1 S1_2 S1_3 ... S2 TT2 Instances of structure S2 (e.g. sentences) S2_1 S2_2 S2_3 ... S3 TT3 ...

[0122] Suitable references can be provided between the EDL and SDL lists. Alternatively, the recognized structures, i.e., their source code, on the one hand, and the instances recorded for each structure, on the other hand, can be stored separately, i.e., in their own suitable data structures. Analysis methods for determining elementary data types

[0123] In addition to the procedures described above for determining an elementary data type for an input element of the input information, the system may also provide one or more analysis methods by means of which an elementary data type can be assigned to an input element of the input information.

[0124] Analysis methods are preferably used when at least a considerable amount of input information has already been processed in the manner described above.

[0125] Then, an already known structure (or its source code) can be extended by an analysis method as described below.

[0126] Such an analysis method basically has the following general form: analysisMethod(T1,…,Tn), where T1,..., Tn each correspond to an elementary or initial data type.

[0127] The analysis method can be uniquely identified, regardless of its structure, by its so-called "signature", i.e., by the type and order of the data types Ti; that is, there should not be two analysis methods with the same signature.

[0128] The structure S1 described above, which is set up to store instances whose elements are assigned the elementary data types T2, T3, T1 (in that order), can then be supplemented or extended as follows (highlighted in bold): The function “addTo-input-element-data-type-list(x, Ti)” adds a new entry to the input element data type list for each input element x, with the corresponding data type Ti.

[0129] If another sentence containing the word sequence "W1 W2 W198" is entered into the system, the system will search for the corresponding data type for each word in the input element data type list.

[0130] Thus, W1 corresponds to T2 and W2 to T3. The word W198 is new, meaning there is no entry for it in the EDL yet. The input element W198 could initially be assigned the generic data type T. Input element Data type W1 T2 W2 T3 W3 T1 W4 T1 ... ... ... ... W198 T

[0131] In a further step, the system searches the set of recognized and stored structures for an analysis method whose argument exactly matches the sequence T2, T3, and char[]. This corresponds to: S1. parseMethod(T2 v1, T3 v2, char[] x)

[0132] The system will then execute the function `analyseMethode (W1, W2, W98)`. This will extend or modify the input element data type list as follows: Input element Data type W1 T2 W2 T3 W3 T1 W4 T1 ... ... ... ... W198 T1

[0133] In general terms, the procedure can include the following further steps: - Extending the source code of the structure by the system to include an analysis method for determining an elementary data type of an input element of the input information, wherein the analysis method is set up to compare the data types of a word sequence of another sentence entered into the system with the information about the elementary data types assigned to the input elements of the sentence and, based on this, to determine an elementary data type of an input element of the word sequence of the other sentence.

[0134] In contrast to the methods described above for determining an elementary data type for an input element, which were previously based solely on sentences and their subsequences as well as the input elements encompassed by them, this method now relies on elements of a "higher" level, namely on structures that are no longer defined by input elements, but by elementary data types. Substructures and associated non-elementary data types

[0135] In principle, in a further phase of the analysis of the input information, similar to what has been done above at the word level, further structural information can now be obtained and stored at the structure level, e.g. by means of differentiation, as is described in more detail below.

[0136] Similar to how sentences or word sequences contained therein were previously examined with regard to partial agreement and recognized differences (keyword difference element) in order to determine elementary data types for individual input elements, an analogous process at the level of structures can serve to recognize and store relevant substructures and the non-elementary data types then assigned to them.

[0137] The following example illustrates this: Assume the system has detected two structures S18 and S28, whose data type lists (defined by the respective constructor) look like this: S18: T1 T3 T88 T99 T7 S28: T5 T88 T99 T11

[0138] Here, the elementary data types T88 and T99 appear in the same order in both data type lists.

[0139] The system combines the two elementary data types into a new substructure, e.g., S21, and assigns the new non-elementary data type TT21 to it. `class TT21 { T88 variable1; T99 variable2; Konstruktor (T88 v1, T99 v2) { variable1= v1; variable2 = v2;}}`

[0140] According to a first embodiment of an adaptation of already recognized structures, the system can then, in a further step, replace the elementary data types T88 and T99 in both data type lists of the corresponding structures S18 and S28 with the new non-elementary data type TT21, approximately as follows: S18: T1 T3 TT21 T7 S28: T5 TT21 T11

[0141] Alternatively, according to a second embodiment, the existing data type lists in the recognized structures S18, S28 can remain unchanged, and new structures S18.1, S28.1 are additionally introduced into the system (along with the associated source code), which differ from the already recognized structures in that the non-elementary data type TT21 becomes part of the data type list instead of the sequence of elementary data types T88 T99.

[0142] In the next step, the system can then replace the two data types T88 and T99 in all already known structures with TT21 in the same order, as described (or add correspondingly adapted “duplicated” structures).

[0143] A very concrete example would be the following: Input element Data type Blue T88 White T88 trousers T99 Shirt T99

[0144] The data type T88 is recognizable as a "color", the data type T99 refers to a "garment".

[0145] In general terms, the procedure can therefore comprise the following steps: - Identifying two structures whose data type lists have common elementary data types, where the common elementary data types appear in the same order in both data type lists; - Generating source code for a substructure encompassing the common elementary data types, - Determining a non-elementary data type for the substructure, where the specific non-elementary data type is assigned to the substructure and the elements encompassed by the substructure.

[0146] The process can then proceed to the next step of the - Adapting recognized structures with reference to the specific non-elementary data type of the common input elements.

[0147] It is understood that the "difference formation" described above is not limited to structures that themselves only include non-elementary data types as elements, but structures whose data type list includes one or more non-elementary data types may also be affected. Forming higher-level structures

[0148] To better analyze the structural information hidden in the input information, it can be useful to also determine and store so-called higher-level structures.

[0149] A higher-level structure is understood here to be a structure which at least also includes elements that are no longer elementary data types, but are themselves structures that in turn comprise elementary data types.

[0150] Fig. Figure 3 clearly illustrates what can be understood by an overarching structure.

[0151] The “simple” structures S1, S3 and S4 contain data type lists consisting of elementary data types, e.g. the data type lists T1 T2 T3 or T5 T6 T7 or T10 T11.

[0152] The higher-level structure S11 comprises the simpler structures S1 and S3. The higher-level structure S7 comprises the elementary data type T7 as its first element and the simpler structure S4 as its second element. The higher-level structure S13 comprises the simpler structures S3 and S4 as well as the higher-level structure S7. The further higher-level structure S17 in turn comprises the higher-level structures S11 and S13.

[0153] Higher-level structures are treated in the process essentially analogously to the "simple" structures already described above. The process may include the following additional steps: - Recognizing a higher-level structure that includes at least one previously recognized structure; - Generating source code for the parent structure, which allows an instance of the parent structure to be stored, containing information about the elements encompassed by the parent structure and their order.

[0154] The process then typically includes the following steps: - Determining a non-elementary data type for the parent structure; assigning the determined non-elementary data type to the parent structure and the elements encompassed by the parent structure.

[0155] To capture the structural information contained in the input data as completely as possible, the structural analysis methods described above can be executed repeatedly and alternately. This may, for example, allow a relevant structure to be recognized only as a substructure of a previously formed higher-level structure.

[0156] In this way, the input information can finally be fully analyzed, the structural information it contains can be recognized and stored in the manner described. Natural Language Programming (ZPK and DPK)

[0157] As mentioned several times already, a string program code component (PCC) comprises a program code segment that implements a technical functionality, as well as a definition string that contains an expression in natural language.

[0158] Similarly, a so-called data type list program code component, DPK, can be defined.

[0159] This also includes a program code segment that implements a technical functionality, as well as at least an ordered list of data types, each comprising at least one elementary and / or non-elementary data type.

[0160] According to one embodiment, one or preferably several DPKs can be generated and stored in the system described here.

[0161] This can be viewed in various ways, as described in detail below.

[0162] Similar to the case of a ZPK within the context of the inventor's earlier application, DPKs can be used advantageously in the context of natural language programming: As a first step, a so-called programming string in natural language is entered into the system. This is usually a simple expression in natural language.

[0163] The system then recognizes the individual words of the programming string, taking into account separators such as spaces, control characters, punctuation, etc. These will be referred to as command words in the following.

[0164] For each command word in the programming string, the following steps are then performed: - Searching the captured and analyzed input information, e.g., input element data type list (EDL), for an input element that corresponds to the command word, in the sense of word similarity; - In the event that such an input element exists: Determine all data types assigned to this input element (except the generic data type T).

[0165] If, for each command word of the programming string, there is an input element corresponding to the command word in the input information, then at least a data type list is created as follows: The data type list for a command word includes one data type, which is assigned to the input element of the input information corresponding to the command word.

[0166] If the data type list of a DPK present in the system matches one of the at least one created data type lists (also with regard to the order of the data types), then the DPK in question is selected.

[0167] Finally, a program associated with the programming string is generated based on the program code segment of at least one selected DPK, or functionality implemented by the program code segment of at least one selected DPK is executed by the system.

[0168] The following simple example should illustrate this: The programming string consists of the command words W1, W2, W3. The word W1 is assigned the data types T1, T2, T3 in the EDL, The word W2 is assigned the data types T1, T4, T5 in the DDL, and The word W3 is assigned the data types T4 and T6 in the EDL. Then possible data type lists would be the following: (T1, T1, T4); (T1, T1, T6); (T1, T4, T4); (T1, T4, T6); (T1, T5, T4); (T1, T5, T6); (T2, T1, T4); (T2, T1, T6); (T2, T4, T4); (T2, T4, T6); (T2, T5, T4); (T2, T5, T6); (T3, T1, T4); (T3, T1, T6); (T3, T4, T4); (T3, T4, T6); (T3, T5, T4); (T3, T5, T6).

[0169] These results are obtained by playing through every possible combination.

[0170] Therefore, DPKs whose data type list has the form (T2, T4, T6) or (T1, T1, T4) could be selected according to the described procedure.

[0171] Even this very simple example makes it clear that it might be useful to limit the potentially very large number of theoretically possible data type lists.

[0172] Two possible embodiments will be highlighted here as examples: - once depending on a “hierarchy relationship” of the several data types that are assigned to an input element corresponding to the command word (according to the motto “highest specialization” first), and - secondly, if there is no hierarchical relationship, depending on the context, especially depending on the programming string as a whole.

[0173] The following is a general statement: In the step of creating the at least one data type list, if several data types are assigned to an input element of the input information, only a predefined number, e.g., only exactly one, of these data types can be used to create the at least one data type list.

[0174] This allows the number of generated data type lists to be effectively limited.

[0175] If the multiple data types assigned to the input element are hierarchically related to each other, then one of the multiple data types is used to create the at least one data type list, depending on its position in this hierarchical relationship. In particular, preferably the data type of the lowest hierarchical level or the data type of the highest hierarchical level can be used.

[0176] A hierarchical relationship between data types, as discussed here, exists, for example, when an input element is assigned the elementary data type T0, and a structure whose data type list includes the elementary data type T0 is assigned the non-elementary data type TT2. In this case, T0 is lower in the hierarchy than TT2. This example can easily be extended to multiple hierarchy levels.

[0177] If, however, the multiple data types assigned to the input element are not hierarchically related to each other, then one of the multiple data types can be used to create at least one data type list, depending on the programming string, in particular depending on a plurality of command words in the programming string, i.e., depending on the "context". How this context is determined in detail is a matter of individual case and can vary depending on the application. DPK from ZPK

[0178] A preferred embodiment for generating a DPK will be explained below.

[0179] In this process, a ZPK serves as the basis for creating a DPK; that is, a ZPK is first provided which, as already described several times, includes a definition string and a program code segment.

[0180] The essential step here is to create a data type list based on the definition string of the ZPK.

[0181] This data type list then serves as the data type list of the DPK, whereby the program code segment of the DPK is adopted unchanged by the ZPK.

[0182] The procedure for creating the data type list is practically analogous to the one described above, namely how a data type list was derived from a programming string, as follows.

[0183] Based on the definition string of the ZPK and the analyzed input information, the following steps are performed: - Recognizing definition words (in natural language) separated in the definition string by separators such as spaces, control characters, punctuation, etc.; - For each definition word in the definition string: Searching the captured and analyzed input information (preferably the EDL) for an input element that corresponds to the definition word (in the sense of word similarity); - In the event that such an input element exists: Determine all data types associated with this input element (except the generic data type T); - If for each definition word in the definition string, there is an input element corresponding to the definition word in the input information: Create at least one data type list, wherein the data type list includes a data type for each definition word, which is assigned to the input element of the input information corresponding to the definition word.

[0184] If multiple data type lists result from this process, different DPKs can be generated, one for each of the generated data type lists. ZPKs and DPKs from software packages and textbooks

[0185] Numerous software packages are available, in which developers provide software functionalities. To ensure comprehensibility, the corresponding program code is usually commented in natural language.

[0186] Based on this, ZPKs can be generated and added to the system in the manner described below as an example.

[0187] According to a preferred embodiment, the method may therefore comprise the following steps: - Providing a software package that includes documentation containing a function description in natural language for each function call; - The system creates a string program code component (PCC) that includes: - a program code segment that implements a technical functionality; and - a definition string that includes a natural language expression, wherein the definition string corresponds to or is derived from the function description, and wherein the program code segment corresponds to the program code of the function call.

[0188] Similarly, textbooks on the practice of programming can be processed as input information to provide the system with a further variety of ZPKs.

[0189] Table 3 below shows a very simple example: Table 3: Generating ZPK from documentation Function description / definition string Function call / Program code segment Add a and b Math.add(Integer a, Integer b) Generate a random number Math.random() ... ...

[0190] For each of these ZPKs newly added to the system, a corresponding DPK can then be generated and made available in the system in the manner described above. Supplementing the source code of elementary and non-elementary data types with program code

[0191] The preceding section describes in detail how the input information was analyzed in the first phase. Each input element, i.e., each word in particular, was assigned at least one elementary data type. For each such elementary data type, source code was generated that allows instances of this data type to be stored in the system.

[0192] Such source code can now be extended in a suitable manner by adding a program code segment.

[0193] Naturally, the source code generated by the system for recognized structures can also be extended by a program code segment in an analogous manner. This source code corresponds, as described above, to the source code of the non-elementary data type associated with the structure.

[0194] As described above, every structure (and thus implicitly every non-elementary data type) is characterized by a data type list. The data type list of an elementary data type contains only one element, namely the non-elementary data type itself.

[0195] In general, the procedure can therefore include, in particular, the following steps: - Searching the analyzed input information for a predefined data type or structure; - Modifying, through the system, a source code of a given data type or a source code of a given structure.

[0196] Modifying the source code can, in particular, include adding additional functionality by adding an additional code segment to the source code.

[0197] Searching and modifying can be done using a ZPK.

[0198] Such a ZPK can be provided to the system from the outside, e.g. by a so-called "mentor", i.e. a trusted user or administrator.

[0199] Such a change or addition to the source code of an elementary data type or elementary structure may, in individual cases, lead to a change in the input information.

[0200] By modifying the source code of the data type or structure, relationships between structures of the input information can be made visible.

[0201] Furthermore, by modifying the source code of the data type or the structure, it is possible to output information related to the input information.

[0202] The concepts, which initially seem quite abstract, will now be brought to life using simple examples.

[0203] For example, a mentor can use the following ZPK to modify the source code of an elementary data type.

[0204] The relevant ZPKs are taken from the following documentation: Description of the function Calling the functions ... ... Search the system for the data type x and program a code segment for it. ZPK91 code segment (data type x) ... ... In this code segment, call the code segment of the respective ZPK from the list of ZPKs in the order in which they appear. ZPK92.codesegment (List ZPKs) ... ...

[0205] For example, for the programming string "Add zpk10 zpk2 zpk6 to data type T3", the system reprograms the data type T3 as follows: Class T3 { .... Code segment (){ Zpk10.codesgment(); Zpk2.codesgment(); Zpk6.codesgment();} ....

[0206] Similarly, as mentioned, source codes of structures can also be supplemented by one or more code segments:

[0207] The following is a concrete example of how to supplement the source code of a data type: The following new input information will be recorded in the system: "My boyfriend's name is Oliver. He's athletic."

[0208] And all input elements already entered with previous input information were already recorded in the analysis phase and entered into the input element data type list: Input element Data type list ... ... Sporty T1 happy T1 intimate T1 I T2 You T2 Er T2 She T2 Am T3 Are T3 Is T3 Hot T4 Is called T4 Because T5 For this reason T5 Oliver T7 Hans T7 Elisabeth T7 My T8 Your T8 Friend T9 patient T9 ... ...

[0209] Thus, the system creates a corresponding object for all new input elements: O1 = T8 constructor ("My"); O2 = T9 constructor ("Friend"); ... O7 = T1 constructor ("Happy");

[0210] We say that objects O1, ..., 07 are activated.

[0211] For the sake of simplicity, the active objects are presented in the following tabular form: Active objects (T8, My) (T9, friend) (T4, means) (T7, Oliver) (T2, He) (T3, is) (T1, happy)

[0212] The newly recorded structures are also presented in a simplified tabular form below. Structures Active instances ... ... S2 (T8, T9, T4, T7) [(T8, My) (T9, Friend) (T4, is called) (T7, Oliver)] S1 (T2, T3, T1) [(T2, He) (T3, is) (T1, happy)] ...

[0213] The mentor enters the following programming string into the system: Add "Search the system for active objects of data type T7. Replace me with T7" to data type T2.

[0214] The relevant ZPKs are taken from the following documentation: Description of the function Calling the functions ... ... Search the system for active objects of data type x ZPK93.codesegment (data type x) ... ... Replace me with x ZPK94.codesegment (data type x) ... ...

[0215] The specified programming string causes structures that have a data type of T2 to adjust themselves to their references. Language structures Active instances ... ... S2 (T8, T9, T4, T7) [(T8, My) (T9, Friend) (T4, is called) (T7, Oliver)] S1 (T7, T3, T1) [(T7, Oliver) (T3, is) (T1, happy)] ...

[0216] Thus, T2 (pronoun) will automatically be replaced by T7 (first name): My friend's name is Oliver. Oliver is athletic.

[0217] The following is a concrete example that deals with supplementing the source code of a structure: The following new input information is recorded in the system as follows: Word sequence 1: My friend's name is Oliver. Word sequence 2: He has a cold because he has a fever, he is weak, and he is tired. Word sequence 3: He is depressed because he is listless, sad, and tired.

[0218] The following input element data type list is available: Input element Data type list ... ... Sad T1 listless T1 Depressed T1 Tired T1 limp T1 Feverishly hot T1 A cold T1 I T2 Er T2 Am T3 Is T3 Hot T4 Is called T4 Because T5 For this reason T5 Oliver T7 Hans T7 My T8 Your T8 Friend T9 patient T9 ... ...

[0219] The system creates the active objects from the input element data type list and the new input information; these are simplified and presented in the following tabular form: Active objects (T1, sad) (T1, listless) (T1, depressed) (T1, tired) (T1, limp) (T1, feverishly hot) (T1, has a cold) (T2, He) (T3, Ist) T4 (meaning) (T5, Weil) (T7, Oliver) (T8, My) (T9, friend)

[0220] As already explained, the data type T2 (pronouns) will search the active objects for an object with the data type T7 (first names) and replace itself.

[0221] Thus, the captured language structures and their active instances are represented in a simplified manner as follows: Language structures Active instances ... ... S2 (T8, T9, T4, T7) [(T8, My) (T9, Friend) (T4, is called) (T7, Oliver)] S3(S1, T5, S1, S1, S1) (T7, Oliver) (T3, Ist) (T1, has a cold) (T5, Weil) (T7, Oliver) (T3, Ist) (T1, feverishly hot) (T7, Oliver) (T3, Ist) (T1, schlapp) (T7, Oliver) (T3, Ist) (T1, müde) (T7, Oliver) (T3, Ist) (T1, depressed) (T5, Weil) (T7, Oliver) (T3, Ist) (T1, listless) (T7, Oliver) (T3, Ist) (T1, trautlich) (T7, Oliver) (T3, Ist) (T1, müde) ... ...

[0222] The mentor enters the following programming string into the system: Add “The conjunction T5 separates the main clause from the subordinate clause.” to language structure S3.

[0223] The relevant ZPKs are taken from the following documentation: Description of the function Calling the functions ... ... The conjunction x separates the main clause from the subordinate clause. ZPK95.codesegment (T5 x) ... ...

[0224] The ZPK95.codesegment (T5 x) creates a tree structure shown in Fig, 4 using conventional algorithms.

[0225] Further input information is recorded in the system as follows: "Why does he have a cold?" Input element Data type list ... ... Why T10 How come T10 ... ...

[0226] The active objects are presented in a simplified tabular form below: Active objects (T1, sad) (T1, listless) (T1, depressed) (T1, tired) (T1, limp) (T1, feverishly hot) (T1, has a cold) (T2, He) (T3, Ist) T4 (meaning) (T5, Weil) (T7, Oliver (T8, My) (T9, friend) (T10, Why)

[0227] As already explained, the data type T2 will search the active objects for an object with the data type T7 and replace itself accordingly.

[0228] Why does he have a cold? -> (T10, Why) (T3, Is) (T7, Oliver) (T1, has a cold)

[0229] Thus, the recorded structures and their active instances are represented in a simplified manner as follows: Language structures Active instances ... ... S2 (T8, T9, T4, T7) [(T8, My) (T9, Friend) (T4, is called) (T7, Oliver)] S3(S1, T5, S1, S1, S1) (T7, Oliver) (T3, Ist) (T1, has a cold) (T5, Weil) (T7, Oliver) (T3, Ist) (T1, feverishly hot) (T7, Oliver) (T3, Ist) (T1, schlapp) (T7, Oliver) (T3, Ist) (T1, müde) (T7, Oliver) (T3, Ist) (T1, depressed) (T5, Weil) (T7, Oliver) (T3, Ist) (T1, listless) (T7, Oliver) (T3, Ist) (T1, trautlich) (T7, Oliver) (T3, Ist) (T1, müde) S4(T10, S1) (T10, Why) (T3, Is) (T7, Oliver) (T1, has a cold) ... ...

[0230] The mentor enters the following programming string into the system: Add "Answer question S4" to data type T10.

[0231] The relevant ZPKs are taken from the following documentation: Description of the function Calling the functions ... ... Answer question x ZPK96.codesegment (language structure x) ... ...

[0232] The ZPK96.code segment (language structure x) will perform the following steps: - Searches for an instance of structure S1 in the active instances in the tree structure. - Compare the values ​​of S1 from the input elements with S1 in the tree at the string level. The dynamic values ​​(e.g., date, numbers) always match. - If the structure S1 found in the tree is a parent instance, all or some of the child instances are returned as a response. - If it is a child instance, the parent instance is returned. - If the child instance found in the tree has multiple parent instances, all or some of the parent instances are returned as a response.

[0233] The output for the input information "Why does he have a cold?" can therefore look like this: - because Oliver has a fever and Oliver is weak and Oliver is tired.

[0234] Similarly, the following questions will display the corresponding answers: Question: Why is he depressed? Answer: because Oliver is listless, Oliver is sad, and Oliver is tired. Question: Why is he feverish? Answer: because Oliver has a cold. Question: Why is he sad? Answer: because Oliver is depressed. Question: Why is he tired? Answer: because Oliver is either depressed or has a cold.

[0235] As already explained, the input information "he is tired" has several higher-level instances in the tree, namely "He is depressed" and "He has a cold". Therefore, for the input information "Why is he tired?", the system will return the output information "because Oliver is either depressed or Oliver has a cold". Supplementing the source code of elementary and non-elementary data types with program code based on DPKs.

[0236] According to a preferred embodiment, source codes of elementary and non-elementary data types can be extended by a program code segment based on DPKs already present in the system, almost "naturally".

[0237] The purpose of such an extension can then be to enable the system to execute this program code segment or the functionality implemented by it in response to a specific user input.

[0238] This aspect will be explained in more detail below.

[0239] It should be reiterated that every structure (and thus implicitly every non-elementary data type) is characterized by a data type list. The data type list of an elementary data type contains only one element, namely the non-elementary data type itself.

[0240] Similarly, a DKP is also characterized by a data type list.

[0241] Therefore, it is logical to supplement the source code of a structure with the program code segment of a DKP if the data type list of the structure matches the data type list of the DPK.

[0242] The same approach can be taken with the source code of an elementary data type. activation

[0243] This term has already appeared in the specific examples above and will be discussed in a more general way below.

[0244] It is assumed here that a very large amount of input information has been processed and analyzed, that the system has ZPKs and DPKs, and that the source code of elementary and non-elementary data types (structures) has been supplemented by adding program code segments, as specified in the preceding section.

[0245] If new input information is entered into the system, for example in the form of the words W17 W23 W45, the system can search the EDL for these words and activate the elementary data types assigned to the words.

[0246] The consequence of such activation is that, if present, a program code segment of the elementary data type (which is present in the source code of the data type) is executed.

[0247] In general, the process can therefore include the following steps: - Received, by the system, further input information; - Determine, based on the previously analyzed input information, an elementary data type assigned to an input element of the further input information; - Activating the elementary data type, and - Execution of the program code segment of the source code of the elementary data type.

[0248] In a certain sense, this corresponds to a further simplified and automated programming in natural language.

[0249] In principle, non-elementary data types can also be activated in this way, which then also leads to the execution of the program code segment present in the source code of the same (or the structure to which such a non-elementary data type is assigned).

[0250] A distinction can be made regarding the requirements for activating a non-elementary data type. As described, the associated structure is defined by a data type list.

[0251] In the simplest case, this data type list only includes elementary data types.

[0252] According to one variant, such a structure or the associated non-elementary data type can already be considered activated if an elementary data type is activated in the data type list, i.e., if the further input information includes an input element to which this elementary data type is assigned.

[0253] According to a second variant, it may be stipulated that in order to activate the non-elementary data type or structure, it is necessary that all elementary data types in the data type list are activated.

[0254] Intermediate forms are also conceivable.

[0255] This concept can then be extended analogously to any structures and their associated non-elementary data types.

[0256] It is understood that the input of further input information and the activation of a series of elementary data types, depending on the activation rules outlined above, can trigger a "chain reaction" such that a series of structures at different levels, or their associated non-elementary data types, are also activated, and corresponding program code segments are executed.

[0257] In general, the process can therefore include the following steps: - Activating a non-elementary data type assigned to a structure in the case that at least one elementary or non-elementary data type is activated in the structure's data type list, in particular that all data types in the structure's data type list are activated, and - Execution of the program code segment of the structure's source code.

[0258] Once the additional input information has been fully processed and the program code segments of corresponding elementary or non-elementary data types have been executed, corresponding activations based on this additional input information can be withdrawn. Integration of sensors and image recognition

[0259] How in relation to Fig. As illustrated in Figure 5, external technical devices can also be connected to the system. Communication between the devices and the system can be contactless or contactless.

[0260] These devices can function both as receivers of commands from the system and as triggers of a command within the system.

[0261] Manufacturers of the devices can provide one or more ZPKs for their devices if they are to function as command receivers.

[0262] A thermometer, for example, can provide core parameters (CPMs) with the definition strings "Is it warm?", "Is it cold?", "How cold is it?", "What is the temperature?", etc. These CPMs are analyzed in the system during the analysis phase and, as described, converted into corresponding definition parameters (DPKs).

[0263] In a subsequent phase of the analysis, the thermometer can then respond to a user's input "Is it cold?" with the statement "Yes" or "No".

[0264] Acting as the trigger of a command is very easy to implement.

[0265] Any device can input arbitrary text into the system using the command "System.inputText(char[] text)". The system then treats the input text in the same way as if it were entered by a (human) user.

[0266] The text is analyzed, the corresponding structure is activated, and the program code is executed. The same applies to a ZPK / DPK whose definition string (data type list) "matches" the text as described.

[0267] Some devices only trigger commands, such as a video camera.

[0268] A braking system, for example, is merely a receiver of commands.

[0269] For example, if a recording captured by a video camera is analyzed and a traffic sign is detected, "Maximum speed 5km / h", the camera triggers the command "Drive at a walking pace" through the command System.inputText("Drive at a walking pace").

[0270] The manufacturer supplied a ZPK (Central Programming Key) for the braking system with the definition string "walking" and added it to the system.

[0271] Thus, the braking system reacts to a triggered event by entering "walking" and brakes the car until it reaches a speed of 5 km / h.

[0272] If the video camera detects another traffic sign, "Maximum speed 50km / h", it triggers the command System.inputText("drive").

[0273] Then the ZPK supplied to the engine control unit is activated with the definition string "drive", so that the car drives faster until it reaches a speed of 50 km / h.

[0274] The devices can also transmit values ​​directly without ZPK / DPK, i.e., via an object. When and under what circumstances the device activates its objects depends on the manufacturer.

Claims

Method in a system for programming in natural language, comprising the steps of: - machine-based acquisition and analysis (S100) of digital input information, which includes a plurality of input elements in natural language; - determination (S200) by the system, based on the analysis of the input information, of an elementary data type of an input element of the input information; and - generation (S300) of source code for the elementary data type, wherein the step of acquiring the input information includes: - dividing the input information into sentences, wherein a sentence comprises a sequence of input elements that follow one another in the input information and ends with a separator;and wherein the step of determining (S200) the elementary data type comprises the following sub-steps: - Recognizing a first set comprising a first sequence of input elements and a second set comprising a second sequence of input elements, wherein the first sequence and the second sequence differ only at one position, the first sequence comprising a first difference input element at that position and the second sequence comprising a second difference input element at that position; - Determining the elementary data type for the difference input elements; wherein each of the difference input elements is assigned the determined elementary data type.; Method according to claim 1, further comprising the step:- Generating (S400) by the system an elementary object of the elementary data type to store the input element. The method of claim 1 or 2, wherein the step of capturing the input information comprises: - capturing a string representing the input information; - recognizing the input elements in the string; - for each input element: - determining a generic data type; - creating an object of the generic data type to store the input element. The method of claim 1, comprising the following steps: - generating, by the system, a string program code component, ZPK, for determining an elementary data type of an input element of the input information, wherein the string program code component comprises: - a program code segment which implements a technical functionality; and - a definition string which comprises an expression in natural language, wherein the definition string comprises those input elements in which the first sequence and the second sequence are identical, as well as a variable corresponding to a difference input element of the sequence at one position;and wherein the program code segment implements a functionality which, when executed, upon input of a sentence comprising a sequence of input elements that matches the definition string except for one position, and which includes a further input element that can be assigned to the variable at one position, assigns to this further input element the elementary data type determined for the difference input elements. Method according to one of claims 1 to 4, comprising the further steps: For a set of input information, wherein each input element of the set is assigned at least one elementary data type: - Generating source code for a structure mapping the set at the data type level, which allows an instance of the structure to be stored, with information about the elementary data types assigned to the input elements of the set and their order. The method of claim 5, comprising the steps: - determining a non-elementary data type for the structure; wherein the determined non-elementary data type is assigned to the structure and the elements encompassed by the structure. A method according to claim 5 or 6, comprising the steps: in the case of a further set comprising input elements whose assigned elementary data types correspond to the elementary data types of the set, but are arranged in a different order: - Extending, by the system, the source code for the structure so that it allows additional information to be stored in the other order. A method according to any one of claims 5 to 7, comprising the steps of: - extending the source code of the structure by the system to include an analysis method for determining an elementary data type of an input element of the input information, wherein the analysis method is configured to compare the data types of a word sequence of a further sentence entered into the system with the information about the elementary data types assigned to the input elements of the sentence and, based on this, to determine an elementary data type of an input element of the word sequence of the further sentence. A method according to any one of claims 5 to 8, comprising the further steps of: - identifying two structures whose data type lists have common elementary data types, wherein the common elementary data types occur in the same order in the two data type lists; - generating source code for a substructure comprising the common elementary data types; - determining a non-elementary data type for the substructure, wherein the determined non-elementary data type is assigned to the substructure and the elements comprising the substructure. The method of claim 9, comprising the step of adapting recognized structures with reference to the specified non-elementary data type of the common input elements. Method according to one of claims 5 to 10, comprising the further steps: - Recognizing a higher-level structure which includes at least one already recognized structure; - Generating source code for the higher-level structure which allows an instance of the higher-level structure to be stored, with information about the elements included by the higher-level structure and their order. The method of claim 11, comprising the steps: - determining a non-elementary data type for the parent structure; wherein the determined non-elementary data type is assigned to the parent structure and the elements encompassed by the parent structure. A method according to any one of claims 1 to 12, further comprising the steps: - generating at least one data type list program code component, DPK, wherein a data type list program code component comprises: - a program code segment which implements a technical functionality; and at least one ordered data type list, each comprising at least one elementary and / or non-elementary data type. The method of claim 13, comprising the further steps of: - Inputting a programming string in natural language; - Recognizing command words in natural language in the programming string; - For each command word of the programming string: Searching the captured and analyzed input information for an input element corresponding to the command word; - If such an input element is found: Determining all data types associated with this input element;- If for each command word of the programming string in the input information there is a corresponding input element: - Create at least one data type list, wherein the data type list includes a data type for each command word, which is assigned to the corresponding input element of the input information; - Select at least one data type list program code component if the data type list of the at least one data type list program code component matches one of the at least one created data type lists; - Generate a program assigned to the programming string based on the program code segment of the at least one selected data type list program code component, or execute functionality implemented by the program code segment of the at least one data type list program code component. Method according to claim 14, wherein in the step of creating the at least one data type list, in the case that an input element of the input information is assigned several data types, only a predetermined number of these data types are used to create the at least one data type list. Method according to claim 14 or 15, wherein, if the several data types assigned to the input element are in a hierarchical relationship to each other, a data type from the several data types is used to create the at least one data type list depending on its position in this hierarchical relationship, in particular the data type of the lowest hierarchy level or the data type of the highest hierarchy level. Method according to claim 14 or 15, wherein a data type from the multiple data types is used depending on the programming string to create the at least one data type list. A method according to any one of claims 13 to 17, wherein generating a data type list program code component comprises the following steps: - Providing a string program code component comprising: a program code segment implementing technical functionality; and a definition string comprising a natural language expression; - Based on the definition string and the analyzed input information: generating at least one data type list as follows: - Recognizing, in the definition string, definition words in natural language; - For each definition word in the definition string: searching the captured and analyzed input information for an input element corresponding to the definition word; - If such an input element is found: determining all data types associated with this input element;- If for each definition word of the definition string in the input information there is a corresponding input element: Create at least one data type list, wherein the data type list includes a data type for each definition word, which is assigned to the corresponding input element of the input information; - Assign the program code segment of the string program code component as a program code segment of the data type list program code component; and - Assign the created at least one data type list as at least one data type list of the data type list program code component. A method according to any one of claims 1 to 18, comprising the steps of: - providing a program package which includes documentation in which a function description in natural language is given for a function call; - creating, by the system, a string-program code component which includes: - a program code segment which implements a technical functionality; and - a definition string which includes an expression in natural language, wherein the definition string corresponds to or is derived from the function description, and wherein the program code segment corresponds to the program code of the function call. A method according to any one of claims 1 to 19, comprising the following steps: - Searching the analyzed input information for a predetermined elementary data type or a predetermined structure; - Modifying, by the system, a source code of the predetermined elementary data type or a source code of the predetermined structure. The method of claim 20, wherein the modification of the source code comprises adding additional functionality by adding an additional code segment to the source code. Method according to claim 21, wherein a program code segment of a data type list program code component is added to the source code if the data type list of the elementary data type or structure matches the data type list of the data type list program code component. A method according to claim 21 or 22, comprising the steps of: - Receiving, by the system, further input information; - Determining, based on the previously analyzed input information, an elementary data type assigned to an input element of the further input information; - Activating the elementary data type; and - Executing the program code segment of the source code of the elementary data type. The method according to claim 23, further comprising the steps: - Activating a non-elementary data type assigned to a structure in the case that at least one elementary or non-elementary data type is activated in the data type list of the structure, in particular that all data types in the data type list of the structure are activated, and - Executing the program code segment of the source code of the structure. Method according to one of claims 20 to 24, wherein the searching and modification is performed by means of a string program code component. Method according to one of claims 20 to 22, wherein the input information is changed by modifying the source code of the data type or the structure. Method according to one of claims 20 to 23, wherein relationships between structures of the input information can be made visible by changing the source code of the data type or the structure. Method according to any one of claims 20 to 27, wherein by changing the source code of the data type or the structure it is possible to output information relating to the input information. System (1) for programming in natural language, comprising: - an input device (10) for inputting input information and for inputting a programming string; - a capture device (20) for capturing the input information; - a structure analysis device (30) for analyzing the input information; - a storage device (40); and - at least one processor (50) for generating and / or executing program code, wherein the system is configured to execute a method according to any one of claims 1 to 28.

Images