Self-programming system

Abstract

The present invention relates to a method in a system for programming in natural language, and to a corresponding system. The method comprises the following steps: - capturing and analysing (S100) by machine digital input information which comprises a plurality of input elements in natural language, - determining (S200), by the system, based on the analysis of the input information, an elementary data type of an input element of the input information, and - generating (S300) a source code for the elementary data type.

Description

[0001] Self-programming system

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

[0003] Technological background

[0004] Traditional machine learning calculates transition probabilities from one word to another based on predefined models, often based on Markov model probability theory. However, systems that can independently and flexibly develop their own models and logic for any natural language from the input information are still lacking. There is a lack of methods that have the ability to reprogram themselves to adapt to new tasks or environments without requiring manual reprogramming.

[0005] To date, no method exists that can make decisions about transitioning from one state to another based on logic derived from input information or self-programmed logic. Likewise, there is no method that can autonomously control systems using such techniques.

[0006] The above information is provided only as background information to facilitate understanding of the description. It does not constitute a determination or claim as to whether any of it may be applicable as prior art to the disclosure.

[0007] The object of the present invention is to take the above-mentioned problems into account and to improve and simplify the programming of technical systems by self-programming.

[0008] This problem is solved by a method and a system for programming in natural language having the features of the independent claims. Advantageous embodiments and further developments are specified in the dependent claims.

[0009] Summary of the invention

[0010] A fundamental problem in the analysis of natural language and in programming in natural language is that, in contrast to standardized input elements, such as a date, a number, a telephone number, an e-mail address or the like, ordinary input elements in natural language, in particular words, cannot be easily typed by machines, since they are initially only recorded by the system as a simple character 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) to a number, such as "23", such as "Integer", or it is possible for an input element of the form "29.08.2022" to be automatically recognized as being of the data type "Date", it has not yet been easy to assign a "data type" to words in natural language, which 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.

[0013] A preferred embodiment of a method in a system for programming in natural language, which is shown schematically in Fig. 1, comprises the following steps:

[0014] Digital input information, e.g., in the form of text, is captured and analyzed by machine (step S100). The input information comprises a plurality of input elements, in particular words, in natural language.

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

[0016] The system then determines in step S200, based on analyzing the input information, a so-called elementary data type of an input element of the input information.

[0017] How this analysis and determination of the data type can be carried out is described in detail below.

[0018] The term “elementary data type” is used in the context of the present invention in its own meaning and should not be confused with a data type in the conventional sense, such as “char”, “integer”, “float”, “boolean”, etc.

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

[0020] This will be explained below using a series of examples. First, a basic data type is an abstract construct and does not carry any inherent meaning to the input element. Therefore, various basic data types will be referred to simply as TI, 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 an elementary data type (see step S300) serves to store objects, i.e., concrete instances, of the elementary data type—input elements to which this elementary data type is assigned—along with this structural information after analyzing the input information.

[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 referred to below as "initial data types".

[0023] The generic data type T serves only to simplify 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 to a word, but to a set of words, a sentence structure, or similar. Source code, which is then 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 storing an instance of the non-elementary data type assigned to the structure. The terms "structure" and "non-elementary data type" are used interchangeably below.

[0025] Furthermore, higher-level structures can then 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 simply below, it should always be clear from the context whether an elementary data type or a non-elementary data type (or both) is meant. As already mentioned, the method for storing the structural information mentioned above further includes the step S300 of generating source code for the elementary data type in order to store an object of the elementary data type in the system. A separate source code is generated for each specific data type.

[0027] Finally, in step S400, the system creates a primitive object of the primitive data type to store the specific input element. Creating the object typically requires compiling the source code.

[0028] An elementary object created in this way then includes information about the elementary data type as well as about the value of the input element, ie in the case of a word as input element, the word itself is stored in the elementary object together with the elementary data type assigned to the word.

[0029] There are various ways this information can be stored in the system. A preferred option, which we will often use as an example below for the sake of clarity and simplicity, is a so-called input element data type list (EDL).

[0030] There, for each input element Wi, a data type Tj is assigned to this element:

[0031] Table 1 : Input element data type list

[0032] It should already 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 shown in Fig. 2 and comprises an input device 10 for entering input information and for entering a programming character string (explained below); a detection device 20 for detecting 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 carry out a method described above. As explained below, a language structure of the input information can be recognized and stored in an accessible manner using the method according to the invention. This then makes it possible to make the system quasi-"intelligent."For this purpose, the analyzed input information is post-processed with the elementary and non-elementary data types assigned to the input elements and other structural elements in a suitable manner, as explained below. This post-processed and prepared input information then allows, for example, the system to automatically receive a natural language answer to a question entered in natural language.

[0034] This invention is fundamentally different 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.

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

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

[0037] These structures represent the entire language in the form of small program building blocks. The system develops these program building blocks independently, without the involvement of a human programmer, and continuously expands them to adapt to changes or additions to the input information. This approach enables dynamic and adaptive modeling of language structures, enabling the system to handle new information in a variety of ways. Further user input can subsequently lead to the activation of these program components, with the smallest units being activated first. This can trigger a chain reaction in which further program components of the higher-level structures are activated.The platforms, including Linux, Windows and Apple, execute these program components, using proven mechanisms that have been the subject of intensive research and development for decades, even if their specific contribution is not explicitly mentioned in this invention.

[0038] The application of these mechanisms ensures efficient and resource-saving execution of the program components. This underscores the power of the invention by relying on proven principles to enable the seamless and effective implementation of the generated program structures.

[0039] 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.

[0040] Another important application of the described method is that the passing of parameters and the correct assignment of parameters in the context of natural language programming can be considerably simplified.

[0041] To explain this, reference will be made to a previous invention of the present inventor, see e.g. WO 2017 / 186469 AL There the concept of a string program code component, ZPK, was introduced.

[0042] A ZPK comprises a program code segment that implements a technical functionality and a definition string that includes a natural language expression.

[0043] A ZPK can be called or executed in the system by entering a so-called programming character string. This occurs when the programming character string "sufficiently" matches the definition character string of the ZPK. Since both the programming character string and the definition character string are in natural language, and since natural language is diverse and variable, it is not always easy to decide whether an entered programming character string "essentially" corresponds to the definition character string or not. This problem can be solved very elegantly with the present invention by using a so-called data type list instead of a definition character 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).

[0044] A word in the programming string to which an elementary data type is assigned in the same way can then be considered unambiguously assignable to the word originally present 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 due to typing by data types. Checking a parameter for its correctness can also be simplified and standardized through the use and assignment of data types.

[0045] Short description of the characters

[0046] The invention is explained in more detail below using individual embodiments and the accompanying drawings. The figures show:

[0047] Figure 1 schematically shows steps of a preferred embodiment of the method according to the invention;

[0048] Figure 2 schematically shows a preferred embodiment of a system according to the invention;

[0049] Figure 3 schematically shows various structures determined in the input information;

[0050] Figure 4 schematically shows a tree structure generated by the system; and

[0051] Figure 5 schematically shows external devices connected to the system.

[0052] Detailed description of the invention

[0053] The following description examines individual aspects of the method described here in more detail. In particular, it demonstrates how elementary and non-elementary data types can be determined and which further steps can be performed to analyze the input information with regard to its inherent structure. This concerns a first phase, which will be referred to below as the analysis phase.

[0054] It then also describes how the recognized and captured structural information can be used for natural language programming and for providing a voice assistance system. This concerns a phase following the analysis phase, during which input information can still be entered into the system.

[0055] Preparatory steps

[0056] For ease of understanding, an input element consisting only of letters, i.e. a “word” in the conventional sense, is referred to below as Wi, i = 1, 2, etc.

[0057] Input elements that can already be assigned an initial data type, such as “time”, “date”, etc., are denoted by Ej, j = 1, 2, etc.

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

[0059] An input information in the form of a simple short text in natural language could, for example, have the following form:

[0060] Wl W2 W3 II Wl 1 W12 W13 W14 12 W21 W22 W23 W25 13 Wl W2 W4 12 Wl W2 W99 12.

[0061] The input elements Wi are ordinary words, II could be a comma, 12 a period and 13 a semicolon.

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

[0063] 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;

[0064] }

[0065] }

[0066] The words “Wl”, “W2” and “W3” can be assigned to the data type as follows: 01 = T. constructor (“Wl”);

[0067] 02 = T. constructor (“W2”);

[0068] 03 = T. constructor (“W3”);

[0069] Oi, i = 1, 2, 3, denotes an elementary object.

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

[0071] The resulting objects can be assigned to the system as follows:

[0072] System.add(01, 02, 03);

[0073] Thus, an object contains the information pair (data type, value) and can be captured or saved using “System. Add”.

[0074] The same applies in principle to input elements of initial data types (not specified in the exemplary input information above) ("-23" -> Integer, "2,4" -> float, "29.08.2022" -> "Date, "12:45" -> Time, ...):

[0075] 04 = Integer.constructor(“-23”);

[0076] 05 = Date, constructor^, 08 / 15 / 2022");

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

[0078] Thus, according to one embodiment of the method, the step of capturing the input information may comprise the following substeps:

[0079] - Capturing a character string representing the input information;

[0080] - Detect an input element in the string; - For each input element:

[0081] Determine a generic data type T;

[0082] Create an object of generic data type T to store the input element.

[0083] Typically, only one object is created for each input element. If an input element, especially a word, occurs multiple times in the input information, this does not result in additional objects being created for that input element.

[0084] Recognizing sentences

[0085] The system then recognizes so-called “sentences” in the input information.

[0086] A "sentence" within the meaning of this description is considered to be a sequence of input elements, usually words Wi, that follow one another (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.

[0087] Sentence recognition can occur in the first phase of input information analysis described above.

[0088] In the example above, the system could divide the input information into sentences as follows:

[0089] Wl W2 W3 II

[0090] Wi l W12 W13 W14 I2

[0091] W21 W22 W23 W25 13

[0092] Wl W2 W4 12

[0093] Wl W2 W99 12.

[0094] According to one embodiment, it can be provided that when forming sentences, individual predefined input elements (words) are ignored or marked as optional. This can be useful for filtering out filler words that have little meaning during this phase. Such a procedure is familiar to those skilled in the art from automatic natural language processing and therefore need not be described in detail here.

[0095] Sentences recognized in this way can be stored appropriately in the system, at least temporarily.

[0096] Determining elementary data types based on the sets

[0097] Difference input elements

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

[0099] The aim is in particular to find similar sentences, i.e. sentences whose respective sequences of input elements are at least partially identical, i.e. they differ only in one position, such as the sentences W 1 W2 W3 II and W 1 W2 W4 12.

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

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

[0102] The system determines an elementary data type for the detected difference and programs a source code to make it known in the programming language, e.g. in the following form: that TI { char[] variable; constructor (char[] v) { variable = v;

[0103] }

[0104] } The very simple procedure described above can easily be generalized to connected word sequences in sentences, for example to cover the following cases:

[0105] W1 W2 W3

[0106] W1 W2 W4 W5 W6 or

[0107] W1 W2 W3.

[0108] WO W1 W2 W4 W5 W6 or

[0109] W8 W9 W10 W11 W1 W2 W3

[0110] W1 W2 W4 W5 W6

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

[0112] The procedure may include the following general steps:

[0113] 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 comprises a first differential input element at this position and the second sequence comprises a second differential input element at this position,

[0114] Determining an elementary data type for the difference input elements;

[0115] Generating a source code for the elementary data type, assigning the specific elementary data type to each of the difference input elements.

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

[0117] This is especially true if the previously assigned data type was the generic data type T:

[0118] However, it can often be advantageous to keep a previously assigned elementary data type (unlike the generic data type T) and to assign the newly determined elementary data type additionally.

[0119] For example, if the system recognizes and considers the further record W1 W2 W99 12, it recognizes similar records in an analogous manner and would consequently also assign the elementary data type TI to the input element W99.

[0120] String program code components for determining elementary data types

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

[0122] As already mentioned, a ZPK comprises a program code segment that implements a technical functionality and a definition string that includes a natural language expression.

[0123] As described, the system has detected a differential input element for each of the following sentences, namely input elements W3 and W4. (Separators are omitted here for simplicity):

[0124] Sentence 1 with word sequence 1 : [...] W1 W2 W3 [...]

[0125] Sentence 2 with word sequence 2: [...] W1 W2 W4 [...]

[0126] After the first detection of this difference, the system can program a ZPK, 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.

[0127] The ZPK can have the following form: that ZPK {

[0128] / * Definition string: W1 W2 x * /

[0129] Code segment (T vl, T v2, char[] x) { addTo input element data type List (x, TI);

[0130] }

[0131] }

[0132] When entering another similar word sequence, such as “W 1 W2 W100”, the system can search for the ZPK whose definition string corresponds to the pattern “W 1 W2 x”, where x is a variable to which various input elements, in the example the input element W100, can be assigned.

[0133] If this is the case, the code segment of the ZPK is executed, which results in the input element W100 being assigned the data type TI:

[0134] Thus, the input element data type list is extended as follows:

[0135] Generally speaking, the procedure may include the following further steps:

[0136] Generating, by the system, a character string program code component, ZPK, for determining an elementary data type of an input element of the input information, the ZPK comprising: a program code segment implementing a technical functionality; and a definition character string comprising a natural language expression, the definition character string comprising those input elements in which the first sequence and the second sequence agree, as well as a variable corresponding to a difference input element of the sequence at the 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 which matches the definition string word by word except for the one position, and which comprises a further input element which can be assigned to the variable in the one position, - assigns to this further input element the elementary data type determined for the difference input elements.;

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

[0138] If we assume that a large number of records are entered into the system, the above process in the EDL will gradually replace all generic data types T with recognized elementary data types:

[0139] Recognizing and capturing simple structures. The following steps, which the procedure described here may include, serve to further structure the input information. The first step is to recognize simple structures in the input information.

[0140] A structure is understood here as a linguistic structure of the input information, such as a sentence (main clause or subordinate clause), a clause, such as an insertion, etc.

[0141] In contrast to 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, which are now assigned to the individual input elements.

[0142] To recognize such structures, separators can again be used, such as conventional punctuation marks, paragraphs and other commonly used control characters for structuring texts.

[0143] In particular, a previously recognized sentence can give rise to a structure.

[0144] For the sentence W 1 W2 W3 II, a data type list of the form (T2, T3, TI) can be created, e.g. using the EDL, because the words Wl, W2, W3 are assigned the data types T2, T3, TI.

[0145] The system then programs the following source code for the structure in question: that S1 {

[0146] T2 variable 1;

[0147] T3 variable2;

[0148] TI variables ; constructor (T2 vl, T3 v2, TI v3) { variable 1 = vl; variable2 = v2; variables = v3;

[0149] }

[0150] }

[0151] In the following, it will also be said that the structure S has the data type list (T2, T3, TI). For the sake of clarity, it will be important to distinguish a "structure" in the abstract sense from a concrete object or instance of that structure. The structure itself is merely a template that allows any object of the structure to be stored.

[0152] For example, an abstract structure (as a template) can be defined to include three elements of a given data type, whereby the order of these elements can be fixed.

[0153] For this purpose, the source code specified above can be generated.

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

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

[0156] This object can also be written in the form Sl.Konstruktor("Wl", "W2", "W3").

[0157] The step of capturing the input information may therefore include the following steps:

[0158] For a set of input information, where each input element of the set is assigned at least one elementary data type:

[0159] Generating a source code for a structure mapping the set at the data type level, which allows storing an instance of the structure with information about the elementary data types assigned to the input elements of the set and their order.

[0160] In the case that a plurality of elementary data types are already assigned to an input element of the set, one of the following procedures can be used.

[0161] Let's assume the simple case that the word W3 is already assigned the elementary data types TI and T20. Then, in addition to the structure S1 specified above, the system would further define the structure SE1: class S1.l { T2 variable 1;

[0162] T3 variable2;

[0163] T20 variables; constructor (T2 vl, T3 v2, T20 v3) { variable 1 = vl; variable2 = v2; variables = v3;

[0164] }

[0165] }

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

[0167] T2 variable 1;

[0168] T3 variable2;

[0169] TI variables;

[0170] T20 variables; constructor (T2 vl, T3 v2, TI v3) { variable 1 = vl; variable2 = v2; variables = v3;

[0171] } constructor (T2 vl, T3 v2, T20 v3) { variable 1 = vl; variable2 = v2; variables = v3;

[0172] }

[0173] }

[0174] According to one embodiment, a structure defined in this way can also be assigned a data type, in this case a non-elementary data type. The method can then comprise the following steps:

[0175] Determining a non-elementary data type for the structure;

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

[0177] The specific non-elementary data type can therefore be assigned to the structure and to all elements contained in the structure.

[0178] For example, the structure S1 could 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 record's input elements in the EDL:

[0179] It should be noted at this point that the structure can also store several sequences of the elementary data types, namely 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, TI and T3, T2, TI).

[0180] To detect further sequences, the method may comprise the following further steps: in the case of a further set comprising input elements whose associated elementary data types correspond to the elementary data types of the set, but are arranged in a different sequence;

[0181] Extending, by the system, the source code for the structure so that it allows to store additional information about the other order.

[0182] If, at a later point in time, a sentence is recognized whose input elements are assigned the same data types, but in a different order, e.g. “T3 T2 TI”, the structure is supplemented as follows (e.g. by adding another constructor): that S1 { T2 variable 1;

[0183] T3 variable2;

[0184] TI variables; constructor (T2 vl, T3 v2, TI v3) { variable 1 = vl; variable2 = v2; variables = v3;

[0185] } constructor (T3 vl, T2 v2, TI v3) { variable 1 = vl; variable2 = v2; variables = v3;

[0186] }

[0187] }

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

[0189] In particular, the source code defining each structure can be stored there.

[0190] Table 2: Structure instance data type list

[0191] Appropriate references may be provided between the EDL and SDL lists.

[0192] 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

[0193] In addition to the methods 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.

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

[0195] Then an already known structure (or its source code) can be extended with an analysis method in the manner described below.

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

[0197] The analysis method, regardless of its structure, can be uniquely identified by its so-called “signature,” i.e., by the type and sequence of the data types Ti, ie, there should not be two analysis methods with the same signature.

[0198] The structure Sl already described above, which is set up to store instances whose elements are assigned the elementary data types T2, T3, TI (in this order), can then be supplemented or extended as follows (highlighted in bold): that Sl {

[0199] T2 variable 1;

[0200] T3 variable2;

[0201] TI variables ; constructor (T2 vl, T3 v2, TI v3) { variable 1 = vl; variable2 = v2; variables = v3;

[0202] } public analyseMethode (T2 vl, T3 v2, char[] x) { addTo input element data type List (x, T1); public analyseMethode (T2 vl, char[] x, T1 v3) { addTo input element data type List (x, T3); public analyseMethode (char[] x, T3 v2, T1 v3) { addTo input element data type List (x, T2);

[0203] } }

[0204] 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.

[0205] If another sentence with 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.

[0206] Thus, W1->T2 corresponds to W2->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.

[0207] 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:

[0208] Sl. analysisMethod (T2 vl, T3 v2, char[] x)

[0209] The system will then execute the function analysisMethod(Wl, W2, W98). This will extend or adjust the input element data type list as follows:

[0210] In general terms, the procedure may include the following steps:

[0211] 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 thereon, to determine an elementary data type of an input element of the word sequence of the further sentence.

[0212] In contrast to the methods described above for determining an elementary data type for an input element, which were previously based only on sets and their subsequences as well as input elements contained in them, this method is now based on elements of a “higher” level, namely on structures that are no longer defined by input elements, but by elementary data types.

[0213] Substructures and associated non-elementary data types

[0214] In principle, in a further phase of the analysis of the input information, similar to what happened above at the word level, further structural information can be obtained and stored at the structural level, e.g. by means of difference formation, as is described in more detail below.

[0215] Similar to how sentences or word sequences comprised of them were previously examined for partial agreement and detected differences (keyword difference element) in order to determine elementary data types for individual input elements, an analogous process at the level of structures can be used to recognize and store relevant substructures and the non-elementary data types assigned to them.

[0216] The following example shows this as an example:

[0217] Suppose the system has detected two structures S18, S28 whose data type lists (defined by the respective constructor) look like this: S18: T1 T3 T88 T99 T7

[0218] S28: T5 T88 T99 T11

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

[0220] 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 {

[0221] T88 variable;

[0222] T99 variable2;

[0223] constructor (T88 vl, T99 v2) { variable 1= vl; variable2 = v2;

[0224] }

[0225] }

[0226] 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 the corresponding structures S18, S28 in both data type lists with the new non-elementary data type TT21, for example as follows:

[0227] S18: TI T3 TT21 T7

[0228] S28: T5 TT21 T11

[0229] 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 (including 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.

[0230] In the next step, the system can then replace the two data types T88 T99 in all already known structures, if they are in the same order one after the other, with TT21 in the manner described (or add correspondingly adapted “duplicated” structures).

[0231] A very concrete example would be the following:

[0232] The data type T88 can be identified as “color,” while the data type T99 represents a “piece of clothing.”

[0233] In general terms, the procedure can include the following steps:

[0234] Detecting two structures whose data type lists have common elementary data types, where the common elementary data types appear in the same order in the two data type lists;

[0235] Generating a source code for a substructure comprising the common elementary data types,

[0236] Determining a non-elementary data type for the substructure, whereby the determined non-elementary data type is assigned to the substructure and the elements contained in the substructure.

[0237] The process can then continue with a step of

[0238] - Adapting recognized structures with reference to the specific non-elementary data type of the common input elements.

[0239] It is understood that the “differentiation” described above is not limited to structures which, in turn, only include non-elementary data types as elements, but can also affect structures whose data type list includes one or more non-elementary data types.

[0240] Forming higher-level structures

[0241] In order to better analyze the structural information hidden in the input information, it may be useful to also determine and store so-called higher-level structures.

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

[0243] Figure 3 clearly illustrates what can be understood as a higher-level structure. The "simple" structures SI, S3, and S4 contain data type lists consisting of elementary data types, e.g., the data type lists TI T2 T3 or T5 T6 T7 or T10 TI 1.

[0244] The higher-level structure SI1 comprises the simple structures S1 and S3. The higher-level structure S7 comprises the elementary data type T7 as its first element and the simple structure S4 as its second element. The higher-level structure S13 comprises the simple 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 SI1 and S13.

[0245] In this process, higher-level structures are treated essentially analogously to the "simple" structures described above. The process may include the following additional steps:

[0246] - Detection of a higher-level structure which includes at least one structure already recognized;

[0247] - Generating source code for the parent structure that allows storing an instance of the parent structure with information about the elements contained in the parent structure and their order.

[0248] The procedure then usually includes the following steps:

[0249] - Determining a non-elementary data type for the parent structure; whereby the determined non-elementary data type is assigned to the parent structure and to the elements contained in the parent structure.

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

[0251] In this way, the input information can finally be fully analyzed and the structural information contained therein can be recognized and stored in the manner described.

[0252] Programming in natural language

[0253] ZPK and DPK As already mentioned several times, a string program code component, ZPK, comprises a program code segment that implements a technical functionality and a definition string that includes a natural language expression.

[0254] In an analogous manner, a so-called data type list program code component, DPK, can be defined.

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

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

[0257] This can be seen in different ways, as described in detail below.

[0258] Similar to the case of a ZPK in the inventor's earlier application, DPKs can be used advantageously in the context of natural language programming:

[0259] In a first step, a so-called natural language programming string is entered into the system. This is usually a simple natural language expression.

[0260] 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 below.

[0261] The following steps are then performed for each command word of the programming string:

[0262] 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 equality;

[0263] - If such an input element is present: Determine all data types assigned to this input element (except the generic data type T). If an input element corresponding to the command word in the programming string is present in the input information, at least one data type list is created as follows:

[0264] The data type list for a command word includes a data type which is assigned to the input element of the input information corresponding to the command word.

[0265] In the event that the data type list of a DPK present in the system matches one of the at least one created data type list (also with regard to the order of the data types), the DPK in question is selected.

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

[0267] The following simple example should illustrate this:

[0268] The programming string consists of the command words Wl, W2, W3.

[0269] Suppose the word W1 is assigned the data types TI, T2, and T3 in the EDL, the word W2 is assigned the data types TI, T4, and 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:

[0270] (TI, TI, T4); (TI, TI, T6); (TI, T4, T4); (TI, T4, T6); (TI, T5, T4); (TI, T5, T6);

[0271] (T2, TI, T4); (T2, TI, T6); (T2, T4, T4); (T2, T4, T6); (T2, T5, T4); (T2, T5, T6);

[0272] (T3, TI, T4); (T3, TI, T6); (T3, T4, T4); (T3, T4, T6); (T3, T5, T4); (T3, T5, T6).

[0273] These are created by playing through every possible combination.

[0274] Thus, using the described procedure, DPKs could be selected whose data type list has the form (T2, T4, T6) or (TI, TI, T4).

[0275] 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.

[0276] Two possible embodiments are highlighted here as examples:

[0277] - firstly, depending on a "hierarchical 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, in particular depending on the programming string as a whole.

[0278] This is summarized in general terms below:

[0279] In the step of creating the at least one data type list, in the case that several data types are assigned to an input element of the input information, only a predetermined number, e.g. only exactly one, of these data types can be used to create the at least one data type list.

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

[0281] If the multiple data types assigned to the input element are hierarchically related to one another, 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, the data type at the lowest hierarchical level or the data type at the highest hierarchical level can preferably be used.

[0282] A hierarchical relationship between data types discussed here exists, for example, when an input element is assigned the elementary data type TO, and a structure whose data type list includes the elementary data type TO, which is assigned the non-elementary data type TT2. Here, TO is lower in the hierarchy than TT2. The example can easily be extended to multiple hierarchy levels.

[0283] If, however, the multiple data types assigned to the input element are not hierarchically related to one another, 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 depends on the specific case and can vary depending on the application.

[0284] DPK from ZPK

[0285] A preferred embodiment for generating a DPK will be explained below. A ZPK serves as the basis for creating a DPK, i.e., a ZPK is first provided, which, in the manner already described several times, includes a definition string and a program code segment.

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

[0287] 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.

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

[0289] Based on the ZPK definition string and the analyzed input information, the following steps are performed:

[0290] Recognize, in the definition string, definition words (in natural language) separated by separators such as spaces, control characters, punctuation, etc.);

[0291] For each definition word of the definition string:

[0292] 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 equality);

[0293] - In case such an input element is present:

[0294] Determine all data types associated with this input element (except the generic data type T);

[0295] If for each definition word of the definition string there is an input element corresponding to the definition word in the input information:

[0296] Creating at least one data type list, wherein the data type list comprises a data type for each definition word which is assigned to the input element of the input information corresponding to the definition word.

[0297] If multiple data type lists result from this process, different DPKs can be generated, one for each of the generated data type lists.

[0298] ZPKs and DPKs from software packages and textbooks Numerous software packages are available in which developers provide software functionality. The corresponding program code is usually commented in natural language to ensure its comprehensibility.

[0299] On this basis, ZPKs can be generated and added to the system by the system in the manner described below as an example.

[0300] According to a preferred embodiment, the method may thus comprise the following steps:

[0301] - Providing a program package which includes documentation in which a function description in natural language is given for a function call;

[0302] - Creation, by the system, of a string program code component, ZPK, which includes:

[0303] - a program code segment that implements a technical functionality; and

[0304] - a definition string comprising 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.

[0305] In an analogous manner, textbooks on programming practice can be processed as input information to provide the system with a further variety of ZPKs.

[0306] Table 3 below shows a very simple example:

[0307] Table 3: Generate ZPK from documentation

[0308] For each of these newly added ZPKs to the system, a corresponding DPK can then be generated and made available in the system in the manner described above.

[0309] Supplementing the source code of elementary and non-elementary data types with program code. The above procedure describes in detail how the input information was analyzed in a first phase. Each input element, specifically each word, was assigned at least one elementary data type. For each such elementary data type, source code was generated, allowing instances of this data type to be stored in the system.

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

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

[0312] As also 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.

[0313] In general, the procedure may include the following steps:

[0314] - Searching the analyzed input information for a given data type or structure;

[0315] - Changing, by the system, a source code of the specified data type or a source code of the specified structure.

[0316] Modifying the source code may in particular include adding additional functionality by adding an additional code segment to the source code.

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

[0318] Such a ZPK can be provided to the system from outside, e.g. by a so-called “mentor”, ie a trusted user or administrator.

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

[0320] By changing the source code of the data type or structure, relationships between structures of the input information can be made visible. Furthermore, by changing the source code of the data type or structure, it is possible to output information related to the input information.

[0321] In the following, the concepts, which initially seem quite abstract, are brought to life using simple examples.

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

[0323] Class ZPK100 {

[0324] Definition string: Add ZPKs to data type x.

[0325] Code segment (data type x, List ZPKs) {

[0326] Search the system for data type x and program a code segment for it.

[0327] In this code segment, call the code segment of the respective ZPK from the list of ZPKs in the order in which they appear.

[0328] }

[0329] }

[0330] The corresponding ZPKs are taken from the following documentation:

[0331] For example, for the programming string “Add zpklO zpk2 zpkö to data type T3”, the system reprograms the data type T3 as follows:

[0332] Class T3 {

[0333] Code segment (){

[0334] Zpk 10. codesgmentQ;

[0335] Zpk2.codesgment();

[0336] Zpkö . codesgmentQ;}

[0337] }

[0338] Analogously, as mentioned, source codes of structures can also be supplemented with one or more code segments:

[0339] Class ZPK101 {

[0340] Definition string: Add ZPKs to structure x.

[0341] Code segment (structure x, list ZPKs) {

[0342] Search the system for structure x and program a code segment for it.

[0343] In this code segment, call the code segment of the respective ZPK from the list of ZPKs in the order in which they appear.

[0344] }

[0345] }

[0346] Here is a concrete example of adding to the source code of a data type:

[0347] The following new input information is recorded in the system:

[0348] "My boyfriend's name is Oliver. He's athletic."

[0349] 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:

[0350] Thus, the system creates a corresponding object for all new input elements:

[0351] 01 = T8.constructor (“My”); 02 = T9.constructor (“friend”);

[0352] 07= Partial constructor (“happy”);

[0353] We say that objects 01, . . ., 07 are activated. For simplicity, the active objects are represented in the following table:

[0354] The newly recorded structures are also presented in a simplified table format as follows.

[0355] The mentor enters the following programming string into the system:

[0356] Add "Search the system for active objects of data type T7. Replace me with T7" to data type T2. The corresponding ZPKs are taken from the following documentation:

[0357] The specified programming string causes the structures that have a data type of T2 to adapt themselves to their references.

[0358] Thus, T2 (pronoun) will automatically be replaced by T7 (first name):

[0359] My boyfriend's name is Oliver. He's athletic.

[0360] The following is a concrete example that deals with the addition of the source code of a structure:

[0361] The following new input information is recorded in the system as follows:

[0362] Word order: My friend's name is Oliver.

[0363] Word order 2: He has a cold because he is feverish and he is weak and he is tired.

[0364] Word sequence 3: He is depressed because he is listless and he is sad and he is tired.

[0365] The following input element data type list is available:

[0366] From the input element data type list and the new input information, the system creates the active objects, which are represented in the following simplified table form:

[0367] 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 with it.

[0368] Thus, recorded language structures and their active instances are represented in a simplified manner as follows:

[0369] The mentor enters the following programming string into the system:

[0370] Add "The conjunction T5 separates the main clause from the subordinate clause." to the language structure S3. The corresponding ZPKs are taken from the following documentation:

[0371] The ZPK95 code segment (T5 x) creates a tree structure shown in Fig. 4 using conventional algorithms. Further input information is captured in the system as follows:

[0372] “Why does he have a cold?”

[0373] The active objects are presented in a simplified table format as follows:

[0374]

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

[0376] Why does he have a cold? -> (T10, Why) (T3, Is) (T7, Oliver) (TI, cold) Thus, the recorded structures and their active instances are represented in a simplified manner as follows:

[0377] The mentor enters the following programming string into the system:

[0378] Add "Answer question S4" to data type T10. The corresponding ZPKs are taken from the following documentation:

[0379] The ZPK96 code segment (language structure x) will perform the following steps: Search for an instance of structure S1 among 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., dates, numbers) always match.

[0380] If the found structure Sl in the tree is a parent instance, all or some of the child instances are returned as a response.

[0381] If it is a child instance, the parent instance is returned.

[0382] If the child instance found in the tree has multiple parent instances, all or part of the parent instances are returned as a response.

[0383] The output for the input information “Why does he have a cold?” can therefore look like this: because Oliver is feverish and Oliver is weak and Oliver is tired.

[0384] Similarly, the answers given for the following questions are displayed:

[0385] Question: Why is he depressed?

[0386] Answer: because Oliver is listless and Oliver is sad and Oliver is tired.

[0387] Question: Why is he feverish?

[0388] Answer: because Oliver has a cold.

[0389] Question: Why is he sad?

[0390] Answer: because Oliver is depressed.

[0391] Question: Why is he tired?

[0392] Answer: because Oliver is either depressed or Oliver has a cold.

[0393] 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." Thus, 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

[0394] 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, in a quasi “natural manner”.

[0395] The purpose of such an extension can then be that this program code segment or the functionality implemented thereby can be executed in the system in response to a specific input from a user.

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

[0397] Recall again 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.

[0398] In the same way, a DKP is also characterized by a data type list.

[0399] In this respect, it is obvious 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.

[0400] The same procedure can be used with the source code of an elementary data type.

[0401] activation

[0402] This term has already appeared in the concrete examples above and will be discussed in more general terms below.

[0403] It should be 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 stated in the previous section.

[0404] If new input information is now 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 associated with them. The result 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.

[0405] In general, the procedure can include the following steps:

[0406] - Receiving, by the system, further input information;

[0407] - Determining, on the basis of the previously analyzed input information, an elementary data type assigned to an input element of the further input information;

[0408] - Activating the elementary data type, and

[0409] - Execute the program code segment of the source code of the elementary data type.

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

[0411] In principle, non-elementary data types can also be activated in this way, which then also leads to 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) being executed.

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

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

[0414] According to a first variant, such a structure or the associated non-elementary data type can be considered activated if an elementary data type is activated in the data type list, ie if the further input information comprises an input element to which this elementary data type is associated.

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

[0416] Intermediate forms are also conceivable.

[0417] This concept can then be extended analogously to any structure and its associated non-elementary data types. 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.

[0418] In general, the procedure can include the following steps:

[0419] - activating a non-elementary data type assigned to a structure in the event 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

[0420] - Execute the program code segment of the structure's source code.

[0421] After the further input information has been completely processed and the program code segments of corresponding elementary or non-elementary data types have been executed, corresponding activations based on this further input information can be withdrawn.

[0422] Connection of sensors and image recognition

[0423] As illustrated in Fig. 5, external technical devices can also be connected to the system. Communication between the devices and the system can be contactless or contact-based.

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

[0425] Device manufacturers can provide one or more ZPKs for their devices if they are to function as command receivers.

[0426] A thermometer, for example, can provide ZPKs with the definition strings "Is it warm?", "Is it cold?", "How cold is it?", "What is the temperature?", etc. These ZPKs are analyzed in the analysis phase of the system and converted to corresponding DPKs as described.

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

[0428] Acting as a trigger for a command is very easy to implement. With the command "System. inputText(char[] text)," any device can enter any text into the system. This way, the system treats the entered text in the same way as it would be entered by a (human) user.

[0429] 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) "fits" the text in the described way.

[0430] Some devices are only triggers of commands, such as a video camera.

[0431] A braking device, for example, is only a receiver of commands.

[0432] For example, if a video camera capture is analyzed and a traffic sign, "Maximum speed 5 km / h," is detected, the camera triggers the "Step by step" command using the System. inputText("Step by step") command.

[0433] For the braking device, the manufacturer has supplied a ZPK with the definition string “Step driving” and added it to the system.

[0434] Thus, the braking system reacts to an event triggered by the input “walk” and brakes the car until it reaches a speed of 5 km / h.

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

[0436] Then the ZPK supplied for the engine control unit is activated with the definition string “drive”, so that the car drives faster until it reaches the speed of 50 km / h.

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

Claims

Patent claims 1 Method in a system for programming in natural language, comprising the steps of machine-capturing and analyzing (S100) digital input information comprising a plurality of input elements in natural language, Determining (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) a source code for the elementary data type, wherein the step of capturing the input information comprises: Dividing the input information into sets, wherein a set comprises a sequence of consecutive input elements in the input information and ends with a separator; and wherein the step of determining (200) 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 comprises a first differential input element at this position and the second sequence comprises a second differential input element at this 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.

2. The method of claim 1, further comprising the step: Creating (S400), by the system, an elementary object of the elementary data type to store the input element.

3. The method of claim 1 or 2, wherein the step of capturing the input information comprises: Capturing a character string representing the input information; Detecting the input elements in the string; For each input element: Determining a generic data type; Create a generic data type object to store the input element.

4. The method according to claim 1, comprising the following steps: Generating, by the system, a character string program code component, ZPK, for determining an elementary data type of an input element of the Input information, wherein the ZPK comprises: a program code segment which implements a technical functionality; and a definition character string which comprises an expression in natural language, wherein the definition character string comprises those input elements in which the first sequence and the second sequence match, as well as a variable corresponding to a difference input element of the sequence, at the one position; and wherein the program code segment implements a functionality which, when executed, upon input of a set which comprises a sequence of input elements which matches the definition character string except for the one position, and which comprises a further input element which can be assigned to the variable at the one position, assigns to this further input element the elementary data type determined for the difference input elements.

5. Method according to one of claims 1 to 4, comprising the further steps: For a set of input information, where each input element of the set is assigned at least one elementary data type: Generating a source code for a structure mapping the record at the data type level, which allows to store an instance of the structure with information about the Elementary data types assigned to input elements of the set and their order.

6. The method according to claim 5, comprising the steps: Determining a non-elementary data type for the structure; whereby the determined non-elementary data type is assigned to the structure and the elements contained in the structure.

7. A method according to claim 5 or 6, comprising the steps of: in the case of a further set comprising input elements whose associated 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 to store additional information about the other order.

8. Method according to one of claims 5 to 7, comprising the 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 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 thereon, to determine an elementary data type of an input element of the word sequence of the further sentence.

9. Method according to one of claims 5 to 8, comprising the further steps: Recognizing two structures whose data type lists have common elementary data types, where the common elementary data types appear in the same order in the two data type lists; Generating a source code for a substructure comprising the common elementary data types, Determining a non-elementary data type for the substructure, where the substructure and the elements contained in the substructure are assigned the specific non-elementary data type.

10. The method of claim 9, comprising the step of adapting recognized structures with respect to the determined non-elementary data type of the common input elements.

11. Method according to one of claims 5 to 10, comprising the further steps: Recognition of a higher-level structure which includes at least one structure already recognized; Generating source code for the parent structure that allows storing an instance of the parent structure with information about the elements contained in the parent structure and their order.

12. The method according to claim 11, comprising the steps: Determining a non-elementary data type for the parent structure; whereby the determined non-elementary data type is assigned to the parent structure and to the elements contained in the parent structure.

13. The method according to any one of claims 1 to 12, further comprising the steps: Creating at least one data type list program code component, DPK, wherein a DPK 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.

14. The method according to claim 13, comprising the further steps: Entering a programming string in natural language; Recognition of natural language command words in the programming string; For each command word of the programming string: Searching the captured and analyzed input information for an input element that corresponds to the command word; In case such an input element is present: Determine all data types associated with this input element; If for each command word of the programming string there is an input element in the input information corresponding to the command word: Creating at least one data type list, wherein the data type list comprises a data type for each command word which is assigned to the input element of the input information corresponding to the command word, Selecting at least one DPK in the event that the data type list of the at least one DPK matches one of the at least one created data type list; Generating a program associated with the programming string based on the program code segment of the at least one selected DPK, or executing a functionality implemented by the program code segment of the at least one DPK by the system.

15. The method according to claim 14, wherein in the step of creating the at least one data type list, in the case that several data types are assigned to an input element of the input information, only a predetermined number of these data types is used to create the at least one data type list.

16. The method according to claim 14 or 15, wherein, if the plurality of data types assigned to the input element are in a hierarchical relationship to one another, a data type from the plurality of 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.

17. The method according to claim 14 or 15, wherein one data type from the plurality of data types is used to create the at least one data type list depending on the programming string.

18. The method according to any one of claims 13 to 17, wherein generating a DPK comprises the following steps: Providing a character string program code component, ZPK, comprising: a program code segment implementing a technical functionality; and a definition string comprising a natural language expression, Based on the definition string and the analyzed input information: Generate at least one data type list, as follows: Recognition, in the definition string, of definition words in natural language; For each definition word of the definition string: Searching the captured and analyzed input information for an input element that corresponds to the definition word; In case such an input element is present: Determine all data types associated with this input element; If for each definition word of the definition string there is an input element corresponding to the definition word in the input information: Creating at least one data type list, wherein the data type list comprises, for each definition word, a data type which is assigned to the input element of the input information corresponding to the definition word; Assigning the program code segment of the ZPK as the program code segment of the DPK; and Assigning the created at least one data type list as at least one data type list of the DPK.

19. Method according to one of claims 1 to 18, comprising the steps: Providing a program package which includes documentation in which a function description in natural language is given for a function call; Creation, by the system, of a string program code component, ZPK, which includes: - a program code segment that implements a technical functionality; and a definition string that includes a natural language expression, where the definition string corresponds to or is derived from the function description, and where the program code segment corresponds to the program code of the function call.

20. Method according to one of claims 1 to 19, comprising the following steps: Searching the analyzed input information for a given elementary data type or structure; Changing, by the system, a source code of the specified elementary data type or a source code of the specified structure.

21. The method of claim 20, wherein modifying the source code comprises adding additional functionality by adding an additional code segment to the source code.

22. The method according to claim 21, wherein a program code segment of a DPK 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 DPK.

23. Method according to one of claims 21 or 22, comprising the steps: Receiving, by the system, further input information; Determining, on the basis of 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 Execute the program code segment of the source code of the elementary data type.

24. The method of claim 23, further comprising the steps: Activating a non-elementary data type assigned to a structure in the event 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 Execute the program code segment of the structure's source code.

25. The method according to any one of claims 20 to 24, wherein the searching and modifying is carried out by means of a ZPK.

26. The method according to any one of claims 20 to 22, wherein changing the source code of the data type or structure changes the input information.

27. 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.

28. Method according to one of claims 20 to 27, wherein changing the source code of the data type or structure enables the output of output information relating to the input information.

29. A system (1) for programming in natural language, comprising an input device (10) for entering input information and for entering a programming character string; a detection device (20) for detecting the input information; a structure analysis device (30) for analyzing the input information, a memory device (40); and at least one processor (50) for generating and / or executing program code, wherein the system is configured to carry out a method according to one of claims 1 to 28.

Images