Patent Application
20190243324
This application claims priority to French Application No. 18 50996 filed Feb. 7, 2018, which is incorporated herein in its entirety.
The present invention concerns a method for transforming a sequence comprising several words from a natural language in order to make the sequence executable in real=−time to control a machine.
Certain known methods use classes, but they are very limited when it comes to interpreting a natural language given the complexity of language and the differences between one language and another.
Certain prior art documents also propose methods for interpreting a natural language, for example the document U.S. Pat. No. 6,243,670. This document describes a method that recognizes a list of object types characteristic of languages, verbs, adverbs, nouns, pronouns, etc. This method is also limited because the number of languages and the structural differences between one language and another make the described method non-universal. The described method also requires prior knowledge of a dictionary of words from the language in question and their semantic status.
Examples of documents that represent the state of the art are the following documents: WO 00/23889 which describes a method for compiling a source code comprising declarations in natural language; and US 2017/0239576 which describes a method for automatically generating a program from a natural language for specific computer applications to generate an application, such as a video game.
These state-of-the-art documents present a database including a dictionary. The dictionary has a number of heavy elements in resources. The result of the program gives a code that is fixed and cannot evolve without fundamental modification of the program. These programs require to be compiled to compile with each modification of the program.
A machine is a device or a set of devices capable of performing a certain task or fulfilling a certain function, either under the control of an operator or autonomously.
Machines are becoming more and more complex. It is increasingly inefficient to use a panel of switches or levers. For this reason, it is necessary to find a new technical solution to improve the control of machines by providing for a recognition of commands expressed in a natural language that makes it possible to control the machine.
The object of the present invention is to eliminate these drawbacks.
To this end, according to a first aspect, the present invention concerns a computer-implemented method for transforming a sequence comprising several words from a natural language in order to make the sequence executable in real-time to control a machine. The method comprises at least following steps: a) preprocessing, b) dichotomy, and c) identification-creation.
A sequence, constituted by several characters forming words from a natural language, is compared with data from a database comprising classes. Each class comprising at least the first two of the following elements:
If the class also includes a class expression and a direction, then the class is called a Generalized class. If the direction is upstream, the class is called an upstream Generalized class. If the direction is downstream, the class is called a downstream Generalized class.
If it is an upstream Generalized class, then the class in the first position of its class expression is an upstream function class and the class in the second position of its class expression is a parameter class.
If it is a downstream Generalized class, then the class in the first position of its class expression is a parameter class and the class in the second position of its class expression is a downstream function class.
A function class is at least one of the following elements: an upstream function class, and a downstream function class.
A table of specific upstream or downstream function classes called Dep function classes is defined. A Dep function class is either an upstream Dep function class or a downstream Dep function class. The Dep function classes present in the table have the characteristic that any generalized class of any of the Dep function classes is known by the method to be a function class in the inverse direction from the Dep function class, called a ParDep function class, thus
A table of hierarchical relationships is also defined, for pairs constituted by an upstream function class or a Dep function class and by a downstream function class or a Dep function class. The hierarchical relationship indicates for each of the pairs present in the table which of the two function classes of the pair is Hierarchically dominant over the other.
If in a sequence an upstream function class precedes a downstream function class or a hierarchically dominant Dep function class, and the function classes are separated by a non-empty parameter, then the non-hierarchically dominant upstream function class has precedence in the adoption of the parameter over the downstream function class or the hierarchically dominant Dep function class.
If in a sequence, a downstream function class is subsequent to an upstream function class or a hierarchically dominant Dep function class, and the function classes are separated by a non-empty parameter, then the non-hierarchically dominant downstream function class has precedence in the adoption of the parameter over the upstream function class or the hierarchically dominant Dep function class.
The database also comprises reserved classes. Each reserved class comprises a number and a simple expression, each simple expression of which is preceded by a tag.
The database comprises the following predefined elements: first reserved class, second reserved class, third reserved class, fourth reserved class, fifth reserved class.
The first reserved class, the second reserved class, the third reserved class and the fourth reserved class are hereinafter called GI classes.
The first three GI classes correspond to the first GI class, the second GI class, and the third GI class. The last three GI classes correspond to the second GI class, third GI class, and fourth GI class.
The function of the first reserved class and the fourth reserved class is to indicate in a sequence the start and the end of a Generalized class.
The second reserved class, always positioned inside a part of the sequence delimited by the first reserved class and the fourth reserved class, separates the part of the sequence into two sub-parts. The first sub-part represents an upstream function class and the second sub-part represents a parameter class, and indicates that the part of the sequence represents an upstream Generalized class.
The third reserved class, always positioned inside a part of the sequence delimited by the first reserved class and the fourth reserved class, separates the part of the sequence into two sub-parts. The first sub-part represents a parameter class and the second sub-part represents a downstream function class, and indicates that the part of the sequence represents a downstream Generalized class. A sequence or sequence part comprising GI classes is called a GI expression.
The fifth reserved class is a function class and designates any class as executable by a machine.
The preprocessing step comprises a comparison of the sequence with the data from the database. If a reserved class is recognized in a part of the sequence, then the part of the sequence is substituted by the number of the corresponding reserved class,
The sequence is searched for the simple expressions and GI expressions known in the method to be an upstream function class or a downstream function class. The sequence is dichotomized until all the function classes contained in the sequence that can result in dichotomies have been dichotomized. For each of the upstream function classes or downstream function classes found in the sequence, the dichotomy step comprises the following:
The dichotomy step b) allows nesting Generalized classes. The fact that the dichotomy step allows nesting Generalized classes does not allow Generalized classes to be interlinked.
For each generalized class contained in the sequence:
For a part of the sequence that is not a generalized class and is unknown, the part of the sequence is stored in the database with at least the following two pieces of information: a new number and its simple expression, the sequence obtained is called the LGI expression of the sequence.
In an embodiment, the method further comprises an execution step d), wherein it is iterated from the first to the last classes of the sequence and wherein
The claimed method enables a system to learn as it goes along, and to build its knowledge based on prior knowledge.
The method makes it possible:
All of which combines to create a universal and efficient man-machine interface.
The claimed method makes it possible to understand an unknown sequence in order to apply it to control a machine.
The claimed method is non-resource-intensive and can be implemented locally (without an internet connection) and run by a computer.
A computer is understood include a processor and to mean a programmable information processing system or device that operates by sequentially reading a set of instructions organized into programs.
The following examples are considered to be computers having a processor or processing unit: a digital tablet, a mobile telephone, particularly of the “smartphone” type, a smart watch, smart glasses, a remote control, headphones, a virtual reality headset, a smart TV, a game console, or a modem/router.
In real-time, it is meant that the characters are transmitted or collected b without waiting for the end of the process treatment. For example, characters are transmitted in writing or by the dictation of a voice transmitted in real-time. The claimed method is capable of driving a physical machine at a speed adapted to the evolution of the machine.
Database is defined as physical memory. The database makes it possible to store and retrieve all raw data or information related to the character or characters of a sequence.
The resulting advantages of the process are multiple:
System learning ability conferred to the user. By inserting in a text to learn the classes IG, the user thus controls the understanding of the process. Once a text has been learned by the process, it will be able to reproduce, for different examples, the dichotomy and this according to its learning. In other words, it will be able to re-insert itself these classes IG in the text that is submitted to it without IG. This dichotomy using GIs reflects the understanding of the system and allows the correct execution of the text/sequence/class being processed. In other words, the IG classes define a method of writing comprehension!
It should be noted that IG classes are visible and easily readable by the user when inserted into a text (a sequence/class). And this means for the user an extremely reduced learning.
The user here does not need to be a computer scientist to evolve the process, i.e., to educate him.
Possibility for the user to see and verify everything the process has learned and how he understood it. This allows the user to have full control over the knowledge of his system—a point that is particularly important at this time.
Possibility of easily correcting said understanding of the method. It suffices to recall the misunderstood sequence in its IG form (the text with its GIs) and to change the position or meaning of the erroneous IGs. The system will then re-learn the sequence with the new understanding.
Universal in principle (independent of the language treated) and therefore no dictionary or rules related to the language and other specific characteristics but also several languages can coexist simultaneously in the process.
This is a fundamental difference—in the state-of-the-art examples, the systems or methods described require pre-knowledge of languages or access to a remote dictionary (vocabulary and semantic structure elements, i.e., hundred or thousand instances per language) to work.
While the process of the claimed invention pre-knows only four classes GI to semantically structure the texts that are submitted to it and whatever the language used! The current knowledge is built from the previous knowledge, i.e., “over water” and according to needs. The interpretation is real time.
No compilation needed to operate nor any programming operation, freezing the system.
The claimed method is made extremely light, allowing it to operate with very limited resources, allowing it to be shipped directly into the machine without external means of communication necessary.
For example, and for the simple case of a small car described below, the claimed method will require only about thirty instances in the database.
By inserting four specific (reserved) classes, called GI classes, into the sequences, the claimed method makes it possible to show how a sequence is comprehended by the system, and allows the user to “see” this comprehension. These GI classes also potentially enabling the user to easily correct the comprehension.
The claimed invention is advantageously implemented according to the embodiments and variants described below, considered individually or in any technically feasible combination.
In an embodiment, the updating of the Dep function table in the dichotomy step b) is determined based on the following conditions:
This feature enables the claimed method to update the Dep function table, and thus to function without having prior knowledge of this table.
In an embodiment, in the dichotomy step b), the claimed method comprises the following elements: if an upstream function class is earlier in a sequence than a downstream function class, then the hierarchical relationship between the upstream function class and the downstream function class is evaluated as follows:
The evaluation enables the claimed method either to update the table of hierarchical relationships between the functions, or in the dichotomy step b) if executed in real time, to substitute for the table of hierarchical relationships, and thus to function without having prior knowledge of the table of hierarchical relationships.
In an embodiment, in the dichotomy step b), the claimed method includes the following elements:
The implementation of this feature, which implies stationarity/consistency of the hierarchies for all Pardep functions of the same Dep function relative to other functions, allows the method to increase the dichotomies in accordance with the proper comprehension of a sequence.
In an embodiment, in the dichotomy step b), if an upstream function class comes earlier in a sequence than a Dep function class that is also upstream, the hierarchical relationship of the upstream function class and the list of all the downstream ParDep function classes of the upstream Dep function class is evaluated. In the case of an upstream function, the following option is added into the determination of the end position of the parameter of the upstream function: i.e., the position preceding the simple expression of an upstream Dep function class that is hierarchically dominant over the upstream function class.
In an embodiment, in the dichotomy step b), if a downstream function class is later in a sequence than a Dep function class that is also downstream, the hierarchical relationship of the downstream function class and the list of all the downstream ParDep function classes of the downstream Dep function class is evaluated. In the case of a downstream function, the following option is added into the determination of the start position of the parameter of the downstream function: i.e., the position following the simple expression of a downstream Dep function class that is hierarchically dominant over the downstream function class.
The implementation of this feature anticipates the appearance of a downstream ParDep function later in the sequence than an upstream function and allows the application of the hierarchy of the upstream function with the downstream Pardep functions of the upstream Dep function. Consequently, increasing the capacity of the method to predict how a new sequence must be dichotomized, and thus comprehended.
In an embodiment, in the identification-creation step c), if the generalized class is known, its class expression and its direction are updated. Thus, for each Generalized class, the update makes it possible both to correct the comprehension of a sequence by using the GI classes directly in the sequence, and to apply the most recent hierarchies, thereby correcting errors in the comprehension of previously learned sequences. The system can therefore evolve continuously.
In an embodiment, the second upstream number is at least greater than two thirds of the first upstream number, and the second downstream number is at least greater than two thirds of the first downstream number.
This feature, by raising the decision threshold for the majority rule in the definition of the Dep function classes, reduces false interpretations of Dep functions and hence dichotomy and comprehension errors, at the cost of only a few additional learning sequences.
In an embodiment, in the dichotomy step b), during the search for function classes in the sequence, the dichotomy step b) also entails that if a function class is found in the sequence and the GI expression of the function class contains other function classes, then the function class is processed before the other function classes.
This feature, by giving priority to the functions whose expressions are the largest, allows the claimed method to actually consider function classes in a sequence to be generalized classes themselves, and consequently improves the comprehension capacity of the claimed method. Such cases are common in certain languages.
In an embodiment: in the preprocessing step a), the database also includes a sixth reserved class. The sixth reserved class is a downstream function class and designates any Dep function class as an equivalence function if the Dep function class is found to be a parameter in a generalized class whose function is the sixth reserved class. Thus, any parameter class of a generalized class whose function is the ParDep function class of a Dep and equivalence function class has as an equivalent class the parameter class of the Dep function class in the generalized ParDep function class.
In the execution step d), if a class is found in the sequence and there is a known generalized class whose parameter is the class and whose function is a ParDep function class of a Dep and equivalence function class, then the LGI expression of the class is substituted in the sequence by the LGI expression of its equivalent class. The iteration resumes at the start of the class. The LGI expression of the equivalent class starts with the number of the class and is obtained through iteration by having all the numbers of the generalized classes of the LGI expression of the class followed by the number of the first GI class, then by the number of the first class of the class expression of the generalized class, then by the number of the second GI class if the class is an upstream generalized class or by the number of the third GI class if the class is a downstream generalized class, then by the number of the second class of the class expression of the generalized class, then by the number of the fourth GI class.
These features together make it possible to transform any class into another class, and in particular, any sequence representing an order written in a natural language into a class executable by a machine.
In an embodiment, in the dichotomy step b), if there is no hierarchical relationship between two function classes, then for each of the two function classes, the list of related function classes is searched for in the database. The recurrence of each function class is then compared in order to evaluate the hierarchy between these two lists. The list of classes related to a class being defined as the list of classes that are a parameter class within generalized classes, the function classes of which are also applied to the class within a generalized class.
This feature makes it possible to name and categorize classes sharing various characteristics, and thus, by naming a new class in the same category, allows it to benefit from the hierarchies already learned for the other classes in the category.
In an embodiment, in the preprocessing step a), if the reserved class tag followed by a number is found, then this expression is substituted in the sequence by the number of the class with the same number.
This feature makes it possible refer to any class known to the database in a sequence.
Other advantages, objects, and features of the present invention emerge from the following description, provided for explanatory purposes and in no way limiting, in reference to the attached drawings, in which:
The following terms are used in an example below:
Several terms will be used hereinafter, and their definitions are as follows:
Hereinafter, what appears in brackets { . . . } is what is entered into a computer and constitutes the class expressions.
A sequence is defined as being a series of elements entered and processed one after another. In this case, a sequence will be understood to be a series of numbers. An order such as {turn right}, which is a character string, is actually a series of numbers—coded using either the ASCII (American Standard Code for Information Interchange) or the Unicode (computer standard enabling text exchanges in various languages) table—and therefore {turn right} is in fact a sequence.
The essential function of the method is to recognize and process sequences.
A database will hold the sequences processed by the method. The method will assign a number (No) to each of these sequences, this No is called a class No, or more simply, a “class.”
A class can also be written in the form of other classes. In other words, a sequence can be written from sequences that are already known.
If in the base, we have two classes C1={turn} and C2={right}, then the class C3={turn right} can also be written C3=={C1C2}, {C1C2} being the sequence constituted by the class C1 and the class C2.
In the sequences, the classes can play the role of a Function or a Parameter.
If we add into the base the class C4={left} then the class CS={turn left}, can also be written CS=={C1C4}.
We can therefore teach the claimed method that C1={turn} is a function that has two parameters: C2={right} in the class C3 and C4={left} in the class CS
Certain sequences have a particular meaning known to the method.
These sequences will be called “Reserved Words” (Rwords)
To make them recognizable, and by convention, they always begin with the character “{circumflex over ( )}”.
Just like the other sequences, these Reserved Words are assigned a class No.
These Reserved Classes can be used in the sequences and are immediately recognized by the method during the preprocessing phase.
previously, we have taught the method that there are four reserved classes: CR0={{circumflex over ( )}[ }, CR1={{circumflex over ( )}»}, CR2={{circumflex over ( )}«} and CR3={{circumflex over ( )}]}.
These four classes known to the method allow us to establish the roles (Function or Parameter) played by the classes in a sequence.
The following are also used: for CR0, the first reserved class {{circumflex over ( )}[ }; for CR1, the second reserved class {{circumflex over ( )}»}; for CR2, the third reserved class {{circumflex over ( )}«}; and for CR3, the fourth reserved class {{circumflex over ( )}]}.
The figures in flow chart form serve to illustrate the following description.
In order to teach the method the order {turn right}, in which {turn} plays the role of a function and {right} plays the role of a parameter, we directly enter the sequence: {{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]}.
The method recognizes in the sequence the sequences of Reserved Words used and substitutes them with the corresponding class numbers (Nos). The sequence will then be {CR0turn CR1leftCR3} (step 0).
Next, the method identifies in the base (or will create if unknown) the classes {turn} and {right} or C1 and C2, {turn} being the sequence bounded by CR0 and CR1 and {right} being the sequence bounded by CR1 and CR3. The method then identifies in the base (or will create if unknown) the class {turn right} or C3, {turn right} being the sequence of C1+the sequence of C2. Next, the method will also store in the base, for the class C3, its class expression or {C1C2} and its direction, which indicates where the function is found in the expression {C1C2}, in this case “Am” (for upstream) since we have used {{circumflex over ( )}»}, and in {C1C2} the upstream class C1 is the function and hence the downstream class C2 is the parameter.
The example described herein presumes that for the language used the sequence is read from left to right.
This step is performed by the identification-creation step (step 2), whose purpose is to identify in the database, or create if unknown, all the component classes delimited by the classes CR0 through CR3 in the sequence.
Thus, the class C1={turn} is now known to the method as an Upstream function class in C3.
If we now directly enter the sequence {turn left} (without mentioning the reserved classes CR0 through CR3), the method will search this sequence to see if it can find any known functions (step 1/1). It finds in this sequence the previously learned class C1={turn} already known to be an Upstream function class in the class C3. By construction, the method will generalize the role of C1 in C3 by considering that C1 can also be an Upstream function class in {turn left}. Thus, the method itself adds the reserved classes CR0 through CR3 into the sequence as for C3. Our sequence then becomes: (steps 1/2 and 1/3) {{circumflex over ( )}[turn {circumflex over ( )}»left{circumflex over ( )}]}.
This step is performed by the Dichotomy step (step 1), whose purpose is to insert into the sequence it must process the classes CR0 through CR3 based on the functions known to the method. The method will then continue learning this sequence exactly as above (see step 2).
The database is completed by the sequence C1={turn}, C4={left}, C5={turn left} and C5=={C1C4} with the Direction=Am.
Thus, the method comprises the concatenation of the following steps.
Step 0: preprocessing; step 1: dichotomy; step 2: identification-creation.
The classes C3 and C5 are called “Generalized Classes” or G classes. The concept of generalization consisting of widely replicating a behavior observed in a case taken as an example, in this case the function role that a class can have.
The G classes have in the database, in addition to their simple expression, a class expression, always constituted by two classes, and a direction. The G classes being always constituted by a function and a parameter, the direction will indicate where the function is located in the class expression. If the direction is Am, the function will be at the beginning and the parameter will be at the end, and vice versa.
A G class can be written {{circumflex over ( )}[Function class{circumflex over ( )}»Parameter class{circumflex over ( )}]} for an Upstream G class or {{circumflex over ( )}[Parameter class{circumflex over ( )}«Function class{circumflex over ( )}]} for a Downstream G class.
The classes CR0={{circumflex over ( )}[ }, CRI={{circumflex over ( )}»}, CR2={{circumflex over ( )}«}, CR3={{circumflex over ( )}]} will be called GI classes (G Indication classes), and they define the G classes in a sequence. Since the function and parameter classes themselves can be G classes, the GI classes make it possible to establish the functional dichotomy of a sequence. This functional dichotomy expresses the way in which the method has understood the sequence.
Of the two elements of a G class, the function will be the one that is applied to the other.
Example: common sense tells us that in {turn right} it is {turn} that is applied to {right} and not the other way around.
The method knows how to recognize certain functions that make it possible to link two classes.
Hence the sequence: {{circumflex over ( )}[Cx{circumflex over ( )}«{circumflex over ( )}[F0{circumflex over ( )}»Cy{circumflex over ( )}]{circumflex over ( )}]} (1).
In this sequence Cx and Cy are any two classes playing the role of a parameter. These two classes are linked in the sequence by the function F0.
We see that in this sequence:
A Class that is a function in one direction whose G classes using this class as a function are also functions but in the inverse direction is characteristic of so-called Dependent Functions or “Dep Functions.”
If the method detects a majority of sequences like (1) above for a function F0, then it will generalize this behavior (the role of a function played by F0 and the role of a function with the inverse direction from F0 played by the G classes using F0) and will consider F0 to be a Dep Function.
Which means that:
Let us assume here:
If we enter the sequence: {{circumflex over ( )}[turn right{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL1{circumflex over ( )}]{circumflex over ( )}]}.
The dichotomy step does not modify the sequence (no function is known).
Once this sequence is learned by the identifier-Creator (step 2), the method will know that {means} is an Upstream Dep function and thus, if we then enter: {turn left means {circumflex over ( )}SETWHEEL−1}.
The dichotomy step recognizes in the sequence the previously learned function {means} (step 1/1) and will insert into this sequence the Reserved Classes CR0 through CR3 corresponding to an Upstream Dep Function situation. Which results in (steps 1/2 and 1/3): {{circumflex over ( )}[turn left{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL−1{circumflex over ( )}]{circumflex over ( )}]}.
A sequence which is subsequently learned normally by the Identifier-Creator (step 2).
Hereinafter, the term “GDep class” will be used to designate this type of sequence, i.e. one that corresponds to form (1) or (2).
Hereinafter and by convention, the spaces separating the words of a natural language in a sequence are, in a generalized class, always carried exclusively by the function (comprised/included in the expression of the function) and not by the parameter.
In order to control a machine, the method must recognize the classes/sequences that must call the routines for controlling the machine.
We have defined in the method the Reserved Word {{circumflex over ( )}EXE}, which is an Upstream function class, in order to make this recognition possible.
By construction, the method considers to be an Executable class:
The method has an “Execution” step (step 3/3) that will recognize these classes and execute them.
Another example:
Let us assume that we have connected to the method a small vehicle whose wheels we can turn with a wheel control routine and with the parameter:
{1} to turn the wheels to the right,
{−1} to turn the wheels to the left,
{0} to set the wheels straight, and
{circumflex over ( )}SETWHEEL is assumed to have been initialized in the Reserved Words and linked in the Execution algorithm to the routine for controlling the wheels of the vehicle.
We will establish as an Upstream Function the Rword {circumflex over ( )}SETWHEEL by entering {{circumflex over ( )}[{circumflex over ( )}SETWHEEL{circumflex over ( )}»1{circumflex over ( )}]}.
We will tag {circumflex over ( )}SETWHEEL with {circumflex over ( )}EXE to make the G classes using the function {circumflex over ( )}SETWHEEL executable. We will then enter: {{circumflex over ( )}[{circumflex over ( )}SETWHEEL{circumflex over ( )}«{circumflex over ( )}EXE{circumflex over ( )}]}.
Thus, the entry of {{circumflex over ( )}SETWHEEL1}:
Because Cx is a G class whose function {circumflex over ( )}SETWHEEL is “tagged” with {circumflex over ( )}EXE, the execution step calls the wheel control routine with the parameter {1} which turns the wheels to the right.
Likewise, {{circumflex over ( )}SETWHEEL0} sets the wheels straight and {{circumflex over ( )}SETWHEEL−1} turns the wheels to the left.
The execution step being called by the method, which is itself called after the Dichotomy and the Identification-Creation. The concatenation of steps is thus step 0: preprocessing; step 1: dichotomy; step 2: identification-creation; step 3: application 3, execution 3/3
The purpose of the method being to convert an order into an executable sequence, it must identify both the sequences to be converted and their equivalent sequence.
In order to do this, the Reserved Word {{circumflex over ( )}EQV}, a Downstream Function, is defined in the method, making it possible, as before, to “tag” functions. Once tagged with {circumflex over ( )}EQV a function is recognized by the method as an equivalence function.
In this case, the tagged functions are Dep, thus making it possible to link a sequence to its equivalent sequence. Les G Dep and Equivalence classes will have the following form:
{{circumflex over ( )}[C{circumflex over ( )}«{circumflex over ( )}[Feqv{circumflex over ( )}»Ceqv{circumflex over ( )}]{circumflex over ( )}]}, with {{circumflex over ( )}[Feqv{circumflex over ( )}«{circumflex over ( )}EQV{circumflex over ( )}]} being known/learned, wherein
The method has an equivalence step that will search the base, for the C classes entered into it, their equivalent class Ceqv (step 3/2).
This algorithm is called in the Application algorithm prior to Execution.
The concatenation of Algorithms thus being the following:
step 0: preprocessing; step 1: dichotomy; step 2: identification-creation; step 3: application 3, equivalent 3/2, execution 3/3.
We must first teach the method an equivalence for a class. Let us continue with the previous example by entering: {{circumflex over ( )}[turn right{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL1{circumflex over ( )}]{circumflex over ( )}]} (1).
This establishes {means} as an Upstream Dep Function.
We establish {means} as a equivalence Function by “tagging” it with {circumflex over ( )}EQV
We will therefore enter: {{circumflex over ( )}[means {circumflex over ( )}«{circumflex over ( )}EQV{circumflex over ( )}]}.
The above sequence (1) is now considered by the equivalence step, and thus by the method, to be a G Dep and Equivalence class.
If we now enter: {turn right}.
The dichotomy step has no effect this time (there is no function in the sequence) (step 1).
The identification-creation step finds the class, because it was created during (step 1) above, i.e., Cy (step 2).
Thus, the sequence is now {Cy} (step 3/1).
The Application/execution step starts the iteration for Cy (step 3/1).
The equivalence step for Cy (step 3/2) is called, and an equivalent class Cx={{circumflex over ( )}[{circumflex over ( )}SETWHEEL{circumflex over ( )}»1{circumflex over ( )}]} is found; the sequence {Cy} is therefore replaced by the sequence {Cx{circumflex over ( )}[{circumflex over ( )}SETWHEEL{circumflex over ( )}»1{circumflex over ( )}]} (see LGI sequences below).
The application/execution step then resumes for this new sequence.
The Application step starts the iteration for Cx (step 3/1).
It then suffices to enter the equivalences: {turn left means {circumflex over ( )}SETWHEEL−1} and {go straight means {circumflex over ( )}SETWHEEL0}, in order for the orders {turn left} and {go straight} to be correctly executed.
During the various steps 0/1/2, the sequences will evolve. Lets look at how:
the sequence received is a “String” (character string), and each character is coded either:
By construction, in this exemplary application the first classes are reserved for characters. The non-character classes come afterwards. And in order to include in the same sequence both characters and classes (Rwords for example) whose Nos will be found after 255 (in ASCII), the sequence is conventionally binarized in 32 bits for current computers (step 0/1). The maximum number of class thus being (2{circumflex over ( )}31−1) (class Nos are always positive).
The sequences processed by the method are, at the end of the Sequence Reception (step 0) and thereafter, strings of “Large Integers,” the English terminology for “grands entiers” in French.
During preprocessing, the sequences corresponding to reserved words are replaced by their class number Nos.
The purpose of the Dichotomizer is to insert the GI classes (CR0 through CR3) into the sequence to be processed based on the functions:
If the sequence to be processed is {{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]}, assuming {turn} to be already known as an Upstream function class. The only function class found will be {turn} but it is already participating in a G class, in which it is preceded by CR0={{circumflex over ( )}[ } and followed by CR1={{circumflex over ( )}»}.
Thus, the Dichotomizer cannot process this function and therefore does not modify the sequence.
If the sequence to be processed is: {{circumflex over ( )}[turn right{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL1{circumflex over ( )}]{circumflex over ( )}]} and assuming {turn} and {{circumflex over ( )}SETWHEEL} to be already known as Upstream function classes.
The first function found will be {turn}, which is not participating as a function in a G class and can therefore be processed (step 1/1). The range of its parameter ends at CR2={{circumflex over ( )}«}, so the entity to be processed is the parameter: {turn right}, the interlinking of G classes being prohibited (step 1/2).
The dichotomizer transforms {turn right} into {{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]} in the sequence (step 1/3).
This gives us the sequence: {{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL1{circumflex over ( )}]{circumflex over ( )}]}
The Dichotomizer then resumes the function search (step 1/1).
It will find {turn}, which is already expressed and is participating as a function in a G class, and therefore moves on: it will not consider either {means {circumflex over ( )}SETWHEEL1} or {means}, which at this point are not known as functions (the sequence has not yet been created, this being done in the next step (step 2).
It finds {{circumflex over ( )}SETWHEEL}, which is not expressed and can therefore be processed exactly as before for {turn}.
The entity to be processed this time being the parameter {{circumflex over ( )}SETWHEEL1} (step 1/2).
{{circumflex over ( )}SETWHEEL1} is therefore transformed in the sequence into {{circumflex over ( )}[{circumflex over ( )}SETWHEEL{circumflex over ( )}»1{circumflex over ( )}]} (step 1/3).
The Dichotomizer resumes the function search and will find no more unexpressed functions.
We will then have on output from the Dichotomizer the sequence: {{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}[{circumflex over ( )}SETWHEEL{circumflex over ( )}»1{circumflex over ( )}]{circumflex over ( )}]{circumflex over ( )}]}; this sequence expresses the structure of the corresponding class.
In this example the Dichotomizer has received a sequence already comprising GI classes.
It has nevertheless completed the dichotomy of the sequence submitted to it by going through all the functions known to the method that are present in this sequence.
A sequence comprising the GI classes for all the functions known to the method and present in the sequence will be called a “GI sequence.” This sequence format is the output format of the sequences for the Dichotomizer. This will also be the input format of the sequences for the Identification-Creation algorithm.
The purpose of the identification-Creation step is either to identify (if known) the component classes of the sequence (delimited by the GI classes), or to create them in the database.
Let us take as the sequence to be processed the previous GI sequence output from the Dichotomizer: {{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}[{circumflex over ( )}SETWHEEL{circumflex over ( )}»1{circumflex over ( )}]{circumflex over ( )}]{circumflex over ( )}]} (1), in which only {turn}, {{circumflex over ( )}SETWHEEL} and {1} are known from the base. In fact, {1} being a character, by construction it is already known ({1} to be the class 49 in the case of extended ASCII or UTF-8).
This GI sequence will gradually be converted, as classes are identified or created, into an LGI sequence in which: the Nos of the G classes will be added into the GI sequence BEFORE their class CR0.
sequences of the Non-G classes will simply be substituted by their Nos.
Example: if Cx={turn} and Cy={right} in the base for {{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]} will result in {{circumflex over ( )}[Cx{circumflex over ( )}»Cy{circumflex over ( )}]}.
The “L” in LGI comes from Lead class, the English terminology for “numéro de class en tête” in French. In other words, a “sequence with Lead and G Indication classes.” In this format, a sequence itself carries all of the necessary information for its Application/execution (step 3).
A G class can only be created if its Function AND its Parameter are already known in the base—in other words, if a class number No has already been assigned to them. The concatenations of the Dichotomizing step take this into account.
Applied to our sequence (1), this means Start iteration for the class CR0={{circumflex over ( )}[ } in the 1st position in (1) (step 2/1). The G class in the sequence is unknown—if it were actually known we would have a Lead Class {C{circumflex over ( )}[ . . . And its Function and Parameter are unknown in the sequence (again, no lead class for either of the latter). We are therefore in the situation of step 2/7->Return iteration.
Continue iteration for the class CR0={{circumflex over ( )}[ } in the 2nd position in (1) (step 2/1): Here again we are in the situation of step 2/7: an unknown G class in the sequence whose Function and Parameter are also unknown in the sequence->Return iteration.
Continue iteration for the class {t} in the 3rd position in (1) (step 2/1): This is a Non-G class (since not CR0 and not followed by CR0}, unknown in the sequence (since not followed by CR1 or CR2 or CR3).
We are in the situation of step 2/5. Accordingly
Continue iteration for the class CR1={{circumflex over ( )}»} in the 4th position in (2) (step 2/1): We are in the situation of step 2/2->Return iteration.
Continue iteration for the class {r} in the 5th position in (2) (step 2/1): This is a Non-G class (since not CR0 and not followed by CR0}, unknown in the sequence (since not followed by CR1 or CR2 or CR3).
We are in the situation of step 2/5. Accordingly
Continue iteration for the class CR3={{circumflex over ( )}] } in the 6th position in (3) (step 2/1): We are in the situation of step 2/3. Accordingly, we resume the iteration in the second position—which is the start position of the G class corresponding to CR3 in the sixth position and to the absence of a lead.
Continue iteration for the class CR0={{circumflex over ( )}[ } in the 2nd position in (3) (step 211): We are in the situation of an unknown G class in the sequence (no lead) whose Function and Parameter are known (Cx and Cy)—this is the situation of step 2/6. Accordingly
Continue iteration for the class CR2={{circumflex over ( )}«} in the 8th position in (4) (step 2/1): The method continues in the same way and creates all of the necessary classes, constructing the LGI sequence with the form {Cs{circumflex over ( )}[Cz{circumflex over ( )}[Cx{circumflex over ( )}»Cy{circumflex over ( )}]{circumflex over ( )}«Ct{circumflex over ( )}[Cw{circumflex over ( )}»Cu{circumflex over ( )}[CR6{circumflex over ( )}»Cv{circumflex over ( )}]{circumflex over ( )}]{circumflex over ( )}]} with: Cx={turn} Cy={right}, Cz={turn right}=={CxCy}Am, CR6={{circumflex over ( )}SETWHEEL}, Cv={1}, Cu={{circumflex over ( )}SETWHEEL1}=={CR6Cv}Am, Cw={means} Cu={{circumflex over ( )}SETWHEEL1}, Ct={means {circumflex over ( )}SETWHEEL1}=={CwCu}Am, Cz={turn right}, Ct={means {circumflex over ( )}SETWHEEL1}, Cs={turn right means {circumflex over ( )}SETWHEEL1}=={CzCt}Av.
The LGI sequences have the great advantage of linearizing the structure of the classes (see
It should be noted that the 1st class of an LGI sequence will always be the class No of the sequence! (Cs in the above example).
These sequences are very easy to reconstruct from the database.
We take a class Cs for which we want the LGI sequence (we will reuse the data from the example).
We will start with the sequence {Cs}, iteration on the classes of the sequence (We ignore the GI classes CR0 through CR3):
And, so on up to the following LGI sequence: {Cs{circumflex over ( )}[Cz{circumflex over ( )}[Cx{circumflex over ( )}»Cy{circumflex over ( )}]{circumflex over ( )}«Ct{circumflex over ( )}[Cw{circumflex over ( )}»Cu{circumflex over ( )}[CR6{circumflex over ( )}»Cv{circumflex over ( )}]{circumflex over ( )}]{circumflex over ( )}]}.
The dichotomy step, in order to make it possible to consider a function identified in a sequence, must observe the following boundary rules:
These rules ensure correct chronology in the dichotomy and avoid interpretation errors.
Example: we presume in this case to know that {turn} is an Upstream function. In the sequence {make a U-turn and stop} the function {turn} will not be considered in this sequence because it does not observe the above-mentioned boundary rule.
An Upstream (Dep or non-Dep) function must not be at the end of a sequence or immediately followed by CR1={{circumflex over ( )}»} or by CR2={{circumflex over ( )}«} or by CR3={{circumflex over ( )}]} (One of the last three GI classes).
A Downstream (Dep or non-Dep) function must not be at the start of a sequence or immediately preceded by CR0={{circumflex over ( )}[ } or by CR1={{circumflex over ( )}»} or by CR2={{circumflex over ( )}«} (One of the first three GI classes).
These rules guarantee that the parameter of the function is an existing (non-zero) parameter.
An Upstream function preceded by CR0={{circumflex over ( )}[ } and followed by CR1={{circumflex over ( )}»} is already participating in a G class and therefore will not be considered. The same applies to a Downstream function preceded by CR2={{circumflex over ( )}«} and followed by CR3={{circumflex over ( )}]}.
The term Hierarchy designates the relationship that can exist between two functions with inverse directions.
Let F1 be an Upstream function, F2 a Downstream function and Pi a parameter, if in the database, there are one (or more) class(es) Ci with the form Ci={{circumflex over ( )}[F1{circumflex over ( )}»{circumflex over ( )}[Pi{circumflex over ( )}«F2{circumflex over ( )}]{circumflex over ( )}]}, then the method deduces from this that there is a dominant hierarchy of F1 over F2. This hierarchy will be written F1>>>F2.
If on the other hand there are one (or more) class(es) Cj in the base with the form Cj={{circumflex over ( )}[{circumflex over ( )}F1{circumflex over ( )}»Pj{circumflex over ( )}]{circumflex over ( )}«F2{circumflex over ( )}]}, then the method deduces from this that there is a dominant hierarchy of F2 over F1. This hierarchy will be written F1<<<F2.
If simultaneously there are Ni classes with the form Ci and Nj classes with the form Cj, the method takes the most frequently known hierarchy. In other words, if Ni>Nj, the method takes F1>>>F2 and vice versa.
If there is a hierarchy with a function that is a G class of a Dep function, then the method applies the same hierarchy for all other functions that are also G classes of the same Dep function (but with a parameter that may be different).
These hierarchies are directly and essentially useful in the dichotomy of a sequence and enable the dichotomy module to determine the range of the parameter applicable to a function. In fact, the parameter of a non-dominant function cannot contain a function that is dominant over it.
Example: If we have submitted to the method the following sequence: {{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}[{circumflex over ( )}SETWHEEL1{circumflex over ( )}]{circumflex over ( )}]{circumflex over ( )}]} (5).
The method has therefore learned:
If we then enter the sequence: {turn left means {circumflex over ( )}SETWHEEL−1}. The dichotomy step finds the function {turn} having as a parameter all or part of {left means {circumflex over ( )}SETWHEEL−1}. The dichotomy searches for the functions in this parameter and finds {means}, which is an Upstream Dep function for which the G classes are automatically Downstream functions and for which we know an example that is hierarchically dominant over {turn} in the sequence (5).
The method consequently limits the range of the parameter to {left}. After the insertion of the GI classes, the sequence will be: {{circumflex over ( )}[turn {circumflex over ( )}»left{circumflex over ( )}] means {circumflex over ( )}SETWHEEL−1}.
The next acceptable function will be {means}, an Upstream function having as a parameter all or part of {{circumflex over ( )}SETWHEEL−1}.
The dichotomy step does not find any downstream Function in this parameter, so it will not limit the range of the parameter and will insert the GI classes, such that {{circumflex over ( )}[turn {circumflex over ( )}»left{circumflex over ( )}]{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL−1{circumflex over ( )}]}. Then, it will resume the function search for this sequence. It will find {{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL−1{circumflex over ( )}]}, which is a Downstream function because {means} is an Upstream Dep function. The parameter {{circumflex over ( )}[turn {circumflex over ( )}>>left{circumflex over ( )}]} being a G class, there is no need to search for a function in this case. Thus, the dichotomy step will insert the following GI classes {{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»left{circumflex over ( )}]{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL−1{circumflex over ( )}]{circumflex over ( )}]}, and then it will resume the function search and find {{circumflex over ( )}SETWHEEL}, an upstream function.
After the insertion of the GI classes, we will have: {{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»left{circumflex over ( )}]{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}[{circumflex over ( )}SETWHEEL{circumflex over ( )}»−1{circumflex over ( )}]{circumflex over ( )}]{circumflex over ( )}]}, which is the dichotomy of our sequence.
Each simple sequence (comprising only characters, and not comprising any GI sequences) must be present only once in the database. Thus, each simple sequence is represented by a single unique class No in the database. In order to maintain this principle of uniqueness, the identification-creation module observes the following rules:
In certain cases, (absence of a function definition, no defined hierarchy, etc.), the dichotomy step may establish a faulty dichotomy for a sequence. In that event, the sequence need only be re-entered, indicating the GI classes in connection with what must be understood. The sequence will then be corrected.
For this example, we will return to the control of a small vehicle introduced above and develop it further. We will start with a blank base and display the status of the base in each step.
In the case of Reserved Words:
Establish {circumflex over ( )}SETWHEEL as an Upstream function: {{circumflex over ( )}[{circumflex over ( )}SETWHEEL{circumflex over ( )}»1{circumflex over ( )}]}.
Establish {circumflex over ( )}SETWHEEL as an Executable Function: {{circumflex over ( )}SETWHEEL{circumflex over ( )}«{circumflex over ( )}EXE{circumflex over ( )}]}.
Establish {means} as an Equivalence: {{circumflex over ( )}[means {circumflex over ( )}«{circumflex over ( )}EQV{circumflex over ( )}]}.
Teach the Equivalences:
(i) For turning the wheels to the right: {{circumflex over ( )}[turn right{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL1{circumflex over ( )}]{circumflex over ( )}]}.
(ii) For turning the wheels to the left: {turn left means {circumflex over ( )}SETWHEEL−1}.
(iii) To set the wheels straight: {go straight means {circumflex over ( )}SETWHEEL0}.
This time we will use the Rword {circumflex over ( )}SETENGINE, an Upstream Function whose parameters are {1} for forward, {0} for stop, {−1} for reverse.
{circumflex over ( )}SETENGINE is linked in the execution step to the control of the engine.
The corresponding orders are: {go ahead} for forward, {stop} for stop, and {move back} for reverse.
Establish {circumflex over ( )}SETENGINE as an Upstream Function: {{circumflex over ( )}[{circumflex over ( )}SETENGINE{circumflex over ( )}»1{circumflex over ( )}]}
Establish {circumflex over ( )}SETENGINE as an Executable Function: {{circumflex over ( )}[{circumflex over ( )}SETENGINE{circumflex over ( )}«{circumflex over ( )}EXE{circumflex over ( )}]}
Teach the Equivalences:
(ii) For setting the engine in reverse: {move back means {circumflex over ( )}SETENGINE−1}.
(iii) For stopping the engine: {stop means {circumflex over ( )}SETENGINE0}
At this point we have therefore taught the method to execute the necessary orders for controlling our vehicle, i.e.: turn right, turn left, go straight, go ahead, move back, and stop.
In this case we want to have synonyms for certain orders, for example, we want the method to correctly understand the order {make a right}. To achieve this, we could simply enter {make a right means {circumflex over ( )}SETWHEEL 1} which will work.
Instead, we will enter the equivalence: {make a right means turn right}.
Once this equivalence is learned in the usual way, we will be able to enter {make a right}:
This order will then be executed by the machine.
In a variant, according to one example, the identification-creation step is performed at the same time as the dichotomy step.
Returning to
A function class is also just called a function. A parameter class is also just called a parameter.
The principle of dichotomy is that the hierarchical relationships between two functions make it possible to dichotomize a sequence.
Case 1—Assuming an upstream function precedes a downstream function in the sequence: If the System knows of a simple hierarchy between these two functions→the System applies this hierarchy (inserts the corresponding GI classes into the sequence).
The case of a known hierarchy in the table of hierarchical relationships, we take a database in which it is known of the following elements that: {turn} is an upstream function; {quickly} is a downstream function; and the hierarchical relationship: {turn}<<<{quickly} (the function {quickly} is dominant over the function {turn}).
The sequence {turn right quickly} is entered.
In the dichotomy step b), the upstream function {turn} is recognized to be correctly bounded and can therefore be considered.
A search is then conducted for the range of its parameter, which begins with “r.”
The downstream function {quickly} is then recognized to be hierarchically dominant over {turn}.
Thus, the parameter ends with the previous “t” {quickly} and the function {turn} has precedence over the function {quickly} in the adoption of the parameter {right}. The corresponding GI are inserted into the sequence {{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}] quickly}, and then the algorithm continues. The only correctly bounded function not yet processed in the sequence is {quickly}. There is no hierarchical interaction with another function, and its parameter begins at the start of the sequence and ends in the position preceding {quickly}. Thus, the following GI are inserted: {{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]{circumflex over ( )}″quickly{circumflex over ( )}]}.
The case of an unknown hierarchy in the table, we use the evaluation of a hierarchy. We take a database in which there are three known sequences: S1={{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»north{circumflex over ( )}]{circumflex over ( )}″quickly{circumflex over ( )}]}, S2={{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»south{circumflex over ( )}]{circumflex over ( )}]{circumflex over ( )}″quickly{circumflex over ( )}]} and S3={{circumflex over ( )}[turn {circumflex over ( )}»{circumflex over ( )}[left{circumflex over ( )}″quickly{circumflex over ( )}]{circumflex over ( )}]}.
From these three sequences, the System knows that: {turn} is an upstream Function; and {quickly} is a downstream Function.
The sequence {turn right quickly} is entered.
During the dichotomy step b) and exactly as in Example 1 herein, the two functions {turn} and {quickly} are recognized, but the lack of a hierarchical relationship between these two functions in the table requires the system (or method) to evaluate it. The number of recurrences for both functions is therefore counted, i.e., N12=1 (corresponding to S3) and N21=2 (corresponding to S1 and S2), thus indicating that, since N21>N12, then {turn}<<<{quickly}, and just as in Example 1 herein, the GI such as {{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]{circumflex over ( )}″quickly{circumflex over ( )}]} are inserted into the sequence.
If the system (or method) does not know any simple hierarchy between these two functions, and at least one (or both) of the functions are ParDep functions, then the system will search for the hierarchy of:
The case of an unknown Hierarchy of an upstream Function versus a downstream ParDep function: use the lists of ParDep functions of a Dep function used in a ParDep function. We take a database in which it is known of the following elements that: {means} is an upstream Dep Function; S4={{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL1{circumflex over ( )}]}; and S5={{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»left{circumflex over ( )}]{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL−1{circumflex over ( )}]{circumflex over ( )}]}.
The System therefore knows that: {turn} is an upstream function; and S4 is a downstream ParDep function. Let S6={{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL−1{circumflex over ( )}]} be a downstream ParDep function.
The System knows of no direct/simple hierarchical relationship of {turn} versus {means {circumflex over ( )}SETWHEEL1}, and {turn right means {circumflex over ( )}SETWHEEL1} is entered.
During the dichotomy step b), the upstream function {turn} will be processed because it is correctly bounded (the GI classes). During the search for the range of its parameter, the downstream function S4={means {circumflex over ( )}SETWHEEL1} is found, but so is the upstream Dep function {means}, both of them correctly bounded. The function S4, being a generalized class using {means}, will take priority over the latter in the processing in the absence of any knowledge of a hierarchical relationship between these two functions. Since S4 is a ParDep function, the hierarchical relationship of {turn} versus the list of ParDep functions the Dep function {means}, i.e., S4 and S6, is evaluated. The generalized class S5 gives us an occurrence such as {turn}<<<S6, so this hierarchy will be applied and {turn} will therefore take precedence in the adoption of the parameter {right} and ultimately, the system/method will obtain: {{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL1{circumflex over ( )}]{circumflex over ( )}]}.
If the system still does not find a hierarchy, the system will then search for the hierarchy of: the list of upstream functions related to the upstream function; and/versus the list of downstream functions related to the downstream function. If the System then finds a hierarchy→the System applies the found hierarchy.
Case 2—Upstream function preceding an upstream Dep function in the sequence: Only functions with inverse directions can interact with each other hierarchically, so in the hierarchical evaluation, the upstream Dep function will be substituted by the list of downstream ParDep functions of this upstream Dep function.
This corresponds to an anticipation in the sequence of a future downstream ParDep function of the upstream Dep function that will appear during the dichotomy.
The case of an unknown Hierarchy of an upstream Function Versus an upstream Dep Function: use the lists of ParDep functions. We take a database in which it is known of the following elements that: {means} is an upstream Dep Function Dep; and S5={{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»left{circumflex over ( )}]{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL−1{circumflex over ( )}]{circumflex over ( )}]}. The System therefore knows that: {turn} is an upstream function. Let S6={{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL−1{circumflex over ( )}]} be an upstream ParDep function, and {turn right means {circumflex over ( )}SETWHEEL1} is entered.
During the dichotomy step b) the upstream function {turn} will be processed because it is correctly bounded During the search for the range of its parameter, the upstream Dep function {means} is found, the hierarchical relationship of the function {turn} versus the ParDep function list of {means}, i.e., S6, is then evaluated. The generalized class S5 gives us an occurrence such as {turn}<<<S6. Therefore, {turn} will take precedence in the adoption of the parameter {right} and the following GI will be inserted {{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}] means {circumflex over ( )}SETWHEEL1}. The next function to be processed is the function {means}, which is an upstream function. Since there are no other functions with which it can interact hierarchically, its parameter will begin at {circumflex over ( )}SETWHEEL and end at the end of the sequence. The following GI is then inserted: {{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL1{circumflex over ( )}]}. The last function to be processed is the downstream ParDep function {{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL1{circumflex over ( )}]}. After the insertion of the GI classes and ultimately, the system/method will obtain: {{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL1{circumflex over ( )}]{circumflex over ( )}]}.
The case of an unknown Hierarchy of an upstream Function versus an upstream Dep Function: use related functions for the hierarchical evaluation: {means} as an upstream Dep function {signifies} as an upstream Dep function; and the hierarchical relationship {turn}<<<{means}. Two sequences: S7={{circumflex over ( )}[means{circumflex over ( )}″ is a verb of equivalence{circumflex over ( )}]} and S8={{circumflex over ( )}[signifies{circumflex over ( )}″ is a verb of equivalence{circumflex over ( )}]}, and {turn right signifies {circumflex over ( )}SETWHEEL1} is entered.
During the dichotomy step b) the upstream function {turn} will be processed because it is correctly bounded. During the search for the range of its parameter, the upstream Dep function {signifies} is found. The hierarchical relationship of the function {turn} versus the list of ParDep functions of {signifies} is then evaluated. The list being empty, there is therefore no hierarchy via this mode, so the related functions of {signifies} are searched. The system/method will then find via S7 and S8, the function {means}, and will then search for the hierarchy of {turn} versus {means}, which the system/method knows to be {turn}<<<{means}. Thus, {turn} will take precedence in the adoption of the parameter {right} and ultimately, the system/method will obtain: {{circumflex over ( )}[{circumflex over ( )}[turn {circumflex over ( )}»right{circumflex over ( )}]{circumflex over ( )}«{circumflex over ( )}[means {circumflex over ( )}»{circumflex over ( )}SETWHEEL1{circumflex over ( )}]{circumflex over ( )}].
This feature is nonlimiting and can even be expanded. It is possible, for example, if no hierarchies are found at the end of the preceding concatenations, to expand the list of related functions obtained previously by all the functions related to this list, then resume the hierarchical evaluations, and so on.
There is a compromise to be made between the processing times linked to the hierarchical evaluations and the acceptable comprehension error in the system/method.
| Number | Date | Country | Kind |
|---|---|---|---|
| 18 50996 | Feb 2018 | FR | national |
